password.js + express +阿波罗服务器，req.user未定义

Question

我试图通过sequelize在数据库中记录会话，以使其无服务器，但是req.user始终是未定义的，我尝试了在Internet上找到的每本手册，但我不明白为什么它不起作用。 / p>

我尝试过passport.js手册，快递手册，github要点。

通过成功的身份验证成功创建了数据库中的记录，但是当我尝试命中/graphql端点时，它不会用用户填充req.user。

req.user应该基于存储在数据库中的会话哈希来恢复。

#!/usr/bin/env node
import express from 'express';
import session from 'express-session';
import { ApolloServer } from 'apollo-server-express';
import { typeDefs, resolvers } from './graphql';
import orm from './orm';
import compose from './dataloader/status.dataloader';
import passport from 'passport';
import { Strategy as GitHubStrategy } from 'passport-github';
import cors from 'cors';

const app = express();

const server = new ApolloServer({
    typeDefs,
    resolvers,
    context: ({ req }) => {
        const user = req.user;
        console.log({ user });
        return {
            user,
            orm,
            dataloader: compose(orm),
        };
    },
});

passport.use(
    new GitHubStrategy(
        {
            clientID: process.env.GITHUB_CLIENT_ID,
            clientSecret: process.env.GITHUB_CLIENT_SECRET,
            callbackURL: `/auth/github/callback`,
        },
        async (accessToken, refreshToken, profile, done) => {
            const { provider, id: externalId, profileUrl, username, displayName, photos } = profile;
            const photo = photos && photos[0] && photos[0].value;

            const user = await orm.User.findOne({
                include: [
                    {
                        attributes: [],
                        model: orm.UserProvider,
                        where: {
                            provider,
                            externalId,
                        },
                    },
                ],
                raw: true,
            }).then(async (v) => {
                if (null !== v) {
                    return v;
                }

                v = await orm.User.create({
                    displayName,
                    photo,
                });

                await orm.UserProvider.create({
                    provider,
                    internalId: v.id,
                    externalId,
                    username,
                    profileUrl,
                });

                return v;
            })

            const session = await orm.UserSession.create({
                internalId: user.id,
                hash: accessToken,
            });

            return done(null, session);
        }
    )
);

passport.serializeUser(({ hash }, done) => {
    console.log({ hash });
    done(null, hash);
});
passport.deserializeUser(async (hash, done) => {
    console.log({ hash });
    const user = await orm.User.findOne({
        include: [
            {
                attributes: [],
                model: orm.UserSession,
                where: {
                    hash,
                },
            },
        ],
        raw: true,
    });

    done(null, user);
});

app.use(
    cors({
        origin: "*",
        methods: "GET,POST",
        preflightContinue: false,
        optionsSuccessStatus: 204,
        credentials: true,
    })
);

app.use(session({ secret: 'test' }));
app.use(passport.initialize());
app.use(passport.session());

app.get(
    '/auth/github',
    passport.authenticate('github', { session: true })
);
app.get(
    '/auth/github/callback',
    passport.authenticate('github', { session: true }),
    (req, res) => res.redirect('/')
);
app.use('/graphql', passport.authenticate('session', { session: true }));
// (req, res, next) => {
//     debugger;
//     // passport.
//     console.log({
//         req,
//         session: JSON.stringify(req.session, ',', 4),
//         cookie: JSON.stringify(req.cookie),
//         user: req.user,
//     });

//     return next();
// });

server.applyMiddleware({ app, path: '/graphql' });
app
    .listen(process.env.PORT, () => {
        console.log(`GraphQL ready on: http://localhost:${process.env.PORT}/graphql`);
    });