Passport.serialize is getting the user, but ctx.isAuthenticated() always returns false
Here is my code:
```
// passport-init.js
import passport from 'koa-passport'
import { Strategy } from 'passport-local'

import {
  User,
  isValidPass,
  createHash
} from './UserSchema'

passport.serializeUser( (user, done) => {
  console.log(user)  // it returns the user
  done(null, user._id)
})

passport.deserializeUser( (id, done) => User.findById(id, done) )

// local login
passport.use(new Strategy(async (username, password, done) => {
  //
  let user = null
  try{
    user = await User.findOne({ username })
    if(!user || await !isValidPass(user.password, password)) user = null

    //
  } catch(e) {
    //
    console.log('Something happened while logging in: ', e)
  }

  // I always get the user
  return done(null,
    user
    ? user
    : false)
}))

// Signup
passport.use('signup', new Strategy({
  passReqToCallback : true,
  //
}, async (req, username, pass, done) => {
  let user = null
  let password = null
  let { email } = req.body

  try {
    user = await User.findOne({ username })
    email = await User.findOne({ email })
    password = await createHash(pass)

    // if error, then it means username/email already exists
    if(user || email) return done(null, false)

    user = await new User({
      username,
      email,
      password
    }).save()

    //
  } catch (e) {
    //
    console.log('Something happened while signing up: ', e)
  }

  // I always get the user
  return done(null,
    user
    ? user
    : false)
}))

```

And this is my authentication router

```
// auth.js
// ...
const routes = () => {
  const route = new Router()

  route.prefix('/auth')

  route.get('/login', ctx => {
    ctx.state = { title : 'Login', login : true, csrf: ctx.csrf }
    ctx.render('login')
  })
  route.get('/signup', ctx => {
    ctx.state = { title : 'Signup', signup : true, csrf: ctx.csrf }
    ctx.render('login')
  })

  // TODO: fix this later
  route.post('/login', passport.authenticate('local', {
    successRedirect: '/',
    failureRedirect: '/auth/login',
  }))

  // TODO: fix this later
  route.post('/signup', passport.authenticate('signup', {
    successRedirect: '/',
    failureRedirect: '/auth/signup',
  }))

  route.get('/logout', async ctx => {
    await ctx.logout()
    ctx.redirect('/')
  })

  return route
}
```
```
// index.js
const isAuthenticated = (ctx, next) => {
  console.log(ctx.isAuthenticated()) // always returns false
  console.log(ctx.state)  // gives me the state, but never gives me the user back
  if(ctx.isAuthenticated())
    return next() // this never gets called
  return ctx.redirect('/auth/login') // it always redirects me to login page
}

indexRoute.get('/', isAuthenticated, async (ctx, next) => {
  ctx.status = 200
  ctx.state = { title : 'Index', user : ctx.state.user }
  await ctx.render('index')
})
```
After transversing through the `/auth/login` route and entering the user and password properly, passport bounces me out, saying that I'm not authenticated, returning false when I call `ctx.isAuthenticated()`.

Anything I might be missing?