serializeUser and deserializeUser never called
My `server.js` file looks like this:

```
import Router from 'koa-router';
import error from './middleware/Error';
import TokenAuth from './middleware/TokenAuth';
import helmet from 'koa-helmet';
import passport from 'koa-passport';
import './config/Passport';
import convert from 'koa-convert';
const session = require('koa-generic-session')

const cors = require('kcors');

const app = new Koa();

app.use(parser({
  onerror: (error, ctx) =>{
    ctx.status = 422
    ctx.body =
      {
        message: "Unable to parse request body."
      }
  }
}));

app.use(cors({
  origin: 'http://localhost:4040'
}));

app.use(helmet());
app.use(logger());
app.use(error());

app.keys = ['the-session-secret'];
app.use(convert(session()));

app.use(passport.initialize());
app.use(passport.session());

const publicRouter = new Router({
  prefix: '/api'
});

publicRouter.use('/managers', managerRoutes.routes());

app.use(publicRouter.routes())
   .use(publicRouter.allowedMethods());

const privateRouter = new Router({
  prefix: '/admin'
});

privateRouter.use(TokenAuth);

privateRouter.use(adminRoutes.routes());

app.use(privateRouter.routes())
   .use(privateRouter.allowedMethods());

const authRouter = new Router({
  prefix: '/auth'
});

authRouter.use(authRoutes.routes());

app.use(authRouter.routes())
   .use(authRouter.allowedMethods());

app.listen(config.site.port);

export default app;
```
My `auth` route looks like this:

```
import jwt from 'jsonwebtoken';
import Router from 'koa-router';
import passport from 'koa-passport';

import { config } from '../config/config';

const router = new Router();

router.post('/', function(ctx, next) {
  return passport.authenticate('local', function(err, user, info, status) {
    if(user === false) {
      ctx.status = 401
      ctx.body = {error: 'Invalid Credentials provided'};
      return;
    }

    const opts = {
      expiresIn: config.token.expires
    };

    const response = user.toJSON();

    delete response.created_at;
    delete response.updated_at;
    delete response.password;
    delete response.salt;

    const token = jwt.sign(response, config.token.secret, opts);

    ctx.body = {token};
    ctx.status = 201;
  })(ctx, next)
})

export default router;

```

I am suspicious of the function that I am passing into `passport.authenticate` as I am not actually returning anything or I am not sure if I should be calling login.

My `passport.js` file looks like this:
```

import passport from 'koa-passport';
import User from '../models/User';
import Strategy from 'passport-local';

passport.serializeUser((user, done) => {
  console.log('in serializeUser');
  done(null, user.id);
});

passport.deserializeUser(async (id, done) => {
  try {
    console.log('in deserializeUser');
    const user = await User.findById(id);
    done(null, user);
  } catch(err) {
    done(err);
  }
});

passport.use('local', new Strategy({
  usernameField: 'username',
  passwordField: 'password'
}, async (username, password, done) => {
  try {
    const user = await User.where({
      username
    }).fetch();

    if (!user) {
      return done(null, false)
    }

    try {
      const isMatch = await user.validatePassword(password);

      if (!isMatch) {
        return done(null, false)
      }

      done(null, user)
    } catch (err) {
      done(err)
    }

  } catch (err) {
    return done(err)
  }
}));
```
Neither `serializeUser` nor `deserializeUser` are ever called and I do not understand why.

Is the function that I am passing into `passport.authenticate` wrong? 