difference between 'done' and 'next' in node.js callbacks

Question

in the passport [configure authentication] documentation, it has a rather scary-looking function that uses the mysterious function \"done.\'

passport.use(new         


        

Answer 1

next() will get the control flow to the next middleware, if there is.

In Passport.js, Calling done() will make the flow jump back into passport.authenticate(). It's passed the error, user and additional info object (if defined).

In other cases, done() will take the control flow to the next function after the function it was used in.

Answer 2

Is this the difference between the two frameworks, express and passport?

No they are different in the purpose for which they are used for. Express is used as a application framework on node.js where as passport just handles the authentication part of a web application.

about next()

next() is part of connect which inturn is an express dependency. The purpose of calling next() is to trigger the next middle ware in express stack.

To understand the next() concept in an easier way, you could look at a sample app built on express here.

as you can see in the line pointed the application uses a route level middleware to check whether the user is logged in or not.

app.get('/account', ensureAuthenticated, function(req, res){

Here ensureAuthenticated is the middleware which is defined at bottom like

function ensureAuthenticated(req, res, next) {
  if (req.isAuthenticated()) { return next(); }
  res.redirect('/login')
}

as you can see if the user is authenticated the function invokes next() and passes control to the next layer in route handler written above, else it redirects to another route even without invoking the next()

about done()

done() on the other hand is used to trigger the return url handlers that we write for passport authentication. To understand more on how done works you could look at the code samples at passport here and check the section titled Custom Callback

app.get('/login', function(req, res, next) {
  passport.authenticate('local', function(err, user, info) {
    if (err) { return next(err); }
    if (!user) { return res.redirect('/login'); }
    req.logIn(user, function(err) {
      if (err) { return next(err); }
      return res.redirect('/users/' + user.username);
    });
  })(req, res, next);
});

Here the second parameter to passport.authenticate is the definition of done() that you are going to call from the passport strategy.

note

Here going through the sample codes in the two links I provided above have helped alot in understanding its behavior than the docs. I would suggest you to do the same.

Answer 3

passport's done() wants you to pass in an error (or null) for the first param and a user object as the 2nd param.

express's next() wants an error in the first param or to be called with no parameter at all if there wasn't an error. you could also pass the name of a route to redirect control to in the first parameter but this isn't very common

Answer 4

Let's back up because I think you may have some confusion.

Express is a web application framework. It's responsible for directing users to resources, in a very broad sense.

Passport is a authentication framework. It's responsible for making sure that users are allowed to access said resources.

In both frameworks there is a idea of middleware. Middleware is basically generalized control flow. For example, in some Express framework you could say:

1. Make sure parameter x is valid when requesting route /user/:x

   • if valid, then next() --> which means go to next middleware function()

2. Make sure the user has a session, etc

3. And when all middleware has been executed, then we execute the application

For example,

router.get('/', function(req, res) { // when the '/' route is requested
    res.render('index', { title: 'Express' }); // send index.html
});

In Passport, they also use the idea of middleware, however, instead of next(), they use done() and it's a little more complex. See this page for more info
http://toon.io/understanding-passportjs-authentication-flow/