Checking if a user exists with mongodb and passport.js? - node.js

Question

I am using mongoose and passport-local for my strategy. With Redux I dispatch an action to register a user and it works fine. After I register I want to use those same credentials to log the user in.
I have login working with JWT but it's not hitting any backend, only a users object. I'm wondering how I can use passport to authenticate with my mongo backend, give a success response, and then I can keep using my current setup to issue the JWT. I know I can probably rework this to be cleaner and use passport only but I have this working so far and I'd like to only connect it to a real database now that registerUser successfully uses.
./server/models/account.js
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var passportLocalMongoose = require('passport-local-mongoose');
var Account = new Schema({
username: String,
password: String
});
Account.plugin(passportLocalMongoose);
module.exports = mongoose.model('Account', Account);
./index.js (server entry point)
var bodyParser = require('body-parser')
// db
var db = require('./server/db'); // just db url
var mongoose = require('mongoose');
var passport = require('passport');
var LocalStrategy = require('passport-local').Strategy;
var Account = require('./server/models/account');
var app = new (require('express'))()
var port = 3000
// webpack stuff went here
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
app.use(passport.initialize());
app.get("/", function(req, res) {
res.sendFile(__dirname + '/client/index.html')
})
passport.use(new LocalStrategy(Account.authenticate()));
mongoose.connect(db.url);
app.use(require('./server/routes')); <------------------------------ file below
app.listen etc
./server/routes.js
var express = require('express'),
_ = require('lodash'),
config = require('./config'),
jwt = require('jsonwebtoken');
var app = module.exports = express.Router();
// XXX: This should be a database of users :).
var users = [{ <----------------------------dummy account
id: 1,
username: 'test',
password: 'test'
}];
function createToken(user) {
return jwt.sign(_.omit(user, 'password'), config.secret, { expiresIn: 60*60*5 });
}
function getUserScheme(req) {
var username;
var type;
var userSearch = {};
-- error stuff --
return {
username: username,
type: type,
userSearch: userSearch
}
}
app.post('/sessions/create', function(req, res) {
var userScheme = getUserScheme(req);
-- error stuff --
res.status(201).send({
id_token: createToken(user)
});
});
./client/actions/index.js - actions that get called to register/login (register works with mongo, login only works with a dummy object)
export function registerUser(creds) {
let config = {
method: 'POST',
headers: { 'Content-Type':'application/x-www-form-urlencoded' },
body: `username=${creds.username}&password=${creds.password}`
}
return dispatch => {
// dispatch(requestLogin(creds))
return fetch('http://localhost:3000/register', config)
.then((response) => {
if (!response.ok) { console.log("err"); }
else { dispatch(loginUser(creds)) }
}).catch(err => console.log("Error: ", err))
}
}
// Calls the API to get a token and
// dispatches actions along the way
export function loginUser(creds) {
let config = {
method: 'POST',
headers: { 'Content-Type':'application/x-www-form-urlencoded' },
body: `username=${creds.username}&password=${creds.password}`
}
return dispatch => {
// We dispatch requestLogin to kickoff the call to the API
// console.log(creds)
dispatch(requestLogin(creds))
return fetch('http://localhost:3000/sessions/create', config)
.then(response =>
response.json()
.then(user => ({ user, response }))
)
.then(({ user, response }) => {
if (!response.ok) {
// If there was a problem, we want to
// dispatch the error condition
dispatch(loginError(user.message))
return Promise.reject(user)
}
else {
// If login was successful, set the token in local storage
localStorage.setItem('id_token', user.id_token)
// Dispatch the success action
dispatch(receiveLogin(user))
}
}).catch(err => console.log("Error: ", err))
}
}

Answer 1

I guess you need something like:
export const passportJWT = function (passport) {
passport.use(new JwtStrategy({
jwtFromRequest: ExtractJwt.fromAuthHeader(),
secretOrKey: config.JwtSecret,
}, (jwtPayload, done) => {
Account.findOne({ username: jwtPayload.username}, (err, account) => {
if (err) return done(err, false);
if (user) {
return done(null, account);
}
return done(null, false);
});
}));
};
and
export const JWTAuthentication = (req, res, next) => {
passport.authenticate('jwt', { session: false })(req, res, next);
};
then use this middleware for the routes that needs JWT authentication.
like:
yourRouter.get('/login', JWTAuthentication, (req, res) => {
//if jwt authentication passed
//you can access user object as req.user
});