2020-09-26-nodejs

Step 1: Dependencies

Install dependencies.

npm i bcryptjs body-parser express express-session mongoose passport passport-local --save
npm i nodemon --save-dev

Step 2: User Schema

Create file - ./models/User.js & copy-paste contents as follows.

const mongoose = require('mongoose');
const UserSchema = new mongoose.Schema({
    name: { type: String, required: true },
    email: { type: String, required: true },
    password: { type: String, required: true },
    date: { type: Date, default: Date.now }
});
const User = mongoose.model('User', UserSchema);
module.exports = User;

Step 3: Passport Local Strategt

Create file - ./config/passport.js & just paste contents.

const LocalStrategy = require('passport-local').Strategy;
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');
const User = require('../models/User');
const passport = require('passport');

module.exports = (passport) => {
    passport.use(
        new LocalStrategy({ usernameField: 'email' }, (email, password, done) => {
            User.findOne({ email: email })
                .then(user => {
                    if (!user) {
                        return done(null, false, { message: 'That email is not registered' });
                    }
                    bcrypt.compare(password, user.password, (err, isMatch) => {
                        if (err) {
                            console.log(err);
                        }
                        if (isMatch) {
                            return done(null, user);
                        } else {
                            return done(null, false, { message: 'Incorrect password' });
                        }
                    });
                }).catch(error => {
                    console.log(console.error())
                });
        })
    );

    passport.serializeUser((user, done) => {
        done(null, user.id);
    });

    passport.deserializeUser((id, done) => {
        User.findById(id, (err, user) => {
            done(err, user);
        });
    });
}

Step 4: Request Validator

Create file - ./config/auth.js & copy-paste contents.

module.exports = {
    ensureAuthenticated: function(req, res, next) {
        if(req.isAuthenticated()) {
            next();
        } else {
            res.status(403).send('Please log in.');
        }
    }
};

Step 5: Mongo Connection

Create file - ./config/keys.js

module.exports = {
    MongoURI: 'mongodb://localhost/moneymeter?retryWrites=true&w=majority'
};

Step 6: Route for Authenticated users

• e.g. projects for logged-in user

• Create file ./routes/index.js

const express = require('express');
const router = express.Router();
const { ensureAuthenticated } = require('../config/auth');
router.get('/dashboard', ensureAuthenticated, (req, res) => {
    var user = {...req.user._doc};
    console.log(user);
    delete user["_id"]; delete user["password"]; delete user["date"]; delete user["__v"];
    res.json(user);
});
module.exports = router;

Step 7: Auth Routes

• e.g. Routes are localhost:5000/users/login, localhost:5000/users/register

• Create file ./routes/users.js

const express = require('express');
const router = express.Router();
const passport = require('passport');
const User = require('../models/User');
const bcrypt = require('bcryptjs');

router.post('/register', (req, res) => {
    const { name, email, password, password2 } = req.body;
    let errors = [];
    if (!name || !email || !password || !password2) {
        res.status(500).send({error: 'Please fill in all details'}); return;
    }
    if (password !== password2) {
        res.status(500).send({error: 'Password do not match'}); return;
    }
    if (password.length < 6) {
        res.status(500).send({error: 'Password should be at least 6 characters'}); return;
    }
    if (errors.length > 0) {
        res.status(500).send({errors}); return;
    } else {
        User.findOne({ email: email })
            .then(user => {
                if (user) {
                    res.status(500).send({error: 'User already registered'});
                } else {
                    const newUser = new User({ name, email, password })
                    bcrypt.genSalt(10, (error, salt) => bcrypt.hash(newUser.password, salt, (err, hash) => {
                        if(err) throw err;
                        newUser.password = hash;
                        newUser.save()
                        .then(user => { 
                            res.json({message: 'You are now registered and can log in'});
                        })
                        .catch(err => console.log(err));
                    }));
                }
            });
    }
});

router.post('/login', (req, res, next) => {
    passport.authenticate('local', {
        successRedirect: '/dashboard'
    })(req, res, next);
});

router.get('/logout', (req, res, next) => {
    req.logout();
    res.json({msg: "You've logged out."});
});

module.exports = router;

Step 8: App.js

const express = require('express');
const mongoose = require('mongoose');
const session = require('express-session');
const passport = require('passport');
const bodyParser = require('body-parser');

require('./config/passport')(passport);

const db = require('./config/keys').MongoURI;

mongoose
   .connect(db, { useNewUrlParser: true, useUnifiedTopology: true })
   .then(console.log(`MongoDB Connected`))
   .catch(error => console.log(error));

const app = express();

// Body Parser
app.use(express.urlencoded({ extended: false }));
app.use(bodyParser.json());

// Session
app.use(session({
   secret: 'MONEYMETER',
   resave: true,
   saveUninitialized: true,
}));

// Passport middleware
app.use(passport.initialize());
app.use(passport.session());

// Routes
app.use('/', require('./routes/index'));
app.use('/users', require('./routes/users'));

const PORT = process.env.PORT || 5000;

var server = app.listen(PORT, () => {
   console.log(`Listening at port::${PORT}`);
});