Node.js passport configuration

passport.js

//https://scotch.io/tutorials/easy-node-authentication-setup-and-local
class PassportConfiguration {
    constructor(passport) {
        var LocalStrategy = require('passport-local').Strategy;
        var FacebookStrategy = require('passport-facebook').Strategy;
        var UserDA = require('../data').UserDA;
        var config = require('./config.json');

        passport.serializeUser((user, done) => {
            done(null, user.id);
        });
        passport.deserializeUser((id, done) => {
            UserDA.getUserById(id, (err, user) => {
                done(err, user);
            });
        });

        passport.use('local-signup', new LocalStrategy({
            usernameField: 'email',
            passwordField: 'password',
            passReqToCallback: true
        },
        (req, email, password, done) => {       
            UserDA.getByLocalEmail(email, (err, user) => {
                if (err) {
                    return done(err);
                }
                if (user) {                    
                    return done(null, false, "User already exists");
                }
                UserDA.createLocalUser(req.body, (err, newUser) => {
                    if (err) {
                        throw err;
                    }
                    return done(null, newUser);
                });
            });
        }));

        passport.use('local-login', new LocalStrategy({
            usernameField: 'email',
            passwordField: 'password',
            passReqToCallback: true
        },
        (req, email, password, done) => {          
            UserDA.getByLocalEmail(email, (err, user) => {
                if (err) {
                    return done(err);
                }
                if (!user) {
                    return done(null, false, 'Email or Password invalid');
                }

                var validatePassword = UserDA.validateUserPassword(password, user.local.password);                

                if(validatePassword){
                    return done(null, user);
                }

                return done(null, false, 'Email or Password invalid');
            });
        }));

        passport.use(new FacebookStrategy({
            clientID: config.facebook.clientID,
            clientSecret: config.facebook.clientSecret,
            callbackURL: config.facebook.callbackURL,
            profileFields: ['email']
        }, (token, refreshToken, profile, done) => {
            console.log("facebook...", token, refreshToken, profile);
            process.nextTick(() => {
                UserDA.getByFacebookId(profile.id, (err, user) => {
                    if (err) {
                        return done(err);
                    }
                    if (user) {
                        return done(null, user);
                    }
                    UserDA.createFacebookUser(profile.id, token, profile.emails[0].value, profile.displayName, (err, newUser) => {
                        if (err) {
                            throw err;
                        }
                        return done(null, newUser);
                    });
                })
            });
        }));
    }
}

module.exports = (passport) => {
    new PassportConfiguration(passport);
}

user.js

var bcrypt = require('bcryptjs');
class UserDA {
    constructor() {
        var mongoose = require('mongoose');
        var Schema = mongoose.Schema;
        var ObjectId = Schema.ObjectId;

        var UserSchema = new Schema({            
            firstName: String,
            lastName: String,
            phone: String,
            local: {
                email: String,
                password: String
            },
            facebook: {
                id: String,
                token: String,
                email: String,
                name: String
            }
        }, {
            collection: 'user'
        });

        this.model = mongoose.model('User', UserSchema);
    }

    getUserById(id, done) {
        this.model.findOne({ _id: id }, (err, doc) => {
            if(err){
                return done(err);
            }
            if(doc){
                doc.local.password = undefined;
            }
            return done(null, doc);
        });
    }

    getByLocalEmail(email, done) {
        this.model.findOne({ 'local.email': email }, (err, doc) => {
            return done(err, doc);
        });
    }

    createLocalUser(user, done) {
        var salt = bcrypt.genSaltSync(10);
        var hash = bcrypt.hashSync(user.password, salt);
        var newUser = new this.model({
            firstName: user.firstName,
            lastName: user.lastName,
            phone: user.phone,
            local: {
                email: user.email,
                password: hash
            }
        });
        newUser.save((err) => {
            newUser.local.password = undefined;
            return done(err, newUser);
        });
    }

    validateUserPassword(password, hash){
        return bcrypt.compareSync(password, hash);
    }

    getByFacebookId(id, done) {
        this.model.findOne({ 'facebook.id': id }, (err, doc) => {
            return done(err, doc);
        });
    }

    createFacebookUser(id, token, email, name, done) {
        var newUser = new this.model({
            facebook: {
                id: id,
                token: token,
                email: email,
                name: name
            }
        });
        newUser.save((err) => {
            return done(err, newUser);
        });
    }

    getAllUsers(done) {
        this.model.find({}, (err, docs) => {
            return done(err, docs);
        });
    }
}

module.exports = new UserDA();