discord.js authentication

[juanppdev]

I would like to know how I can incorporate discord authentication in KeystoneJS, I have tried several times but I have not been able to do it, how can I do it?

[dcousens]

Why don't you share what you have attempted so far?

[juanppdev]

@dcousens I have this, but don't work

// schema.ts
import { list } from '@keystone-6/core';
import { text, select, timestamp, password } from '@keystone-6/core/fields';
import { Role } from './types';
import { isAdmin } from './access';

export const lists = {
User: list({
fields: {
password: password({ validation: { isRequired: false } }), // Campo requerido por KeystoneJS Auth
discordId: text({ validation: { isRequired: true }, isIndexed: 'unique' }),
username: text({ validation: { isRequired: true } }),
tag: text({ validation: { isRequired: true } }),
email: text({ validation: { isRequired: true }, isIndexed: 'unique' }),
role: select({
type: 'enum',
options: [
{ label: 'User', value: 'user' },
{ label: 'Admin', value: 'admin' },
],
defaultValue: 'user',
}),
createdAt: timestamp({
defaultValue: { kind: 'now' },
}),
},
access: {
operation: {
query: () => true,
create: isAdmin,
update: isAdmin,
delete: isAdmin,
},
},
}),
};

// keystone.ts:
import { config } from '@keystone-6/core';
import { lists } from './schema';
import { withAuth } from './auth';
import passport from 'passport';
import { Strategy as DiscordStrategy } from 'passport-discord';
import session from 'express-session';

export default config(
withAuth({
db: {
provider: 'postgresql',
url: process.env.DATABASE_URL || 'postgress://your-url',
},
lists,
session: {
maxAge: 60 * 60 * 24 * 30, // 30 días
secret: process.env.SESSION_SECRET || '',
},
server: {
extendExpressApp: (app, context) => {
// Configurar sesiones de Express para Passport
app.use(
session({
secret: process.env.SESSION_SECRET || 'supersecretkey',
resave: false,
saveUninitialized: false,
})
);

    // Inicializar Passport
    app.use(passport.initialize());
    app.use(passport.session());

    // Configurar estrategia de Passport con Discord
    passport.use(
      new DiscordStrategy(
        {
          clientID: process.env.DISCORD_CLIENT_ID || '1333100123219165265',
          clientSecret: process.env.DISCORD_CLIENT_SECRET || 'TejBSacyUWAGXp4fNMTiIOH-5CpUfHS4',
          callbackURL: process.env.DISCORD_CALLBACK_URL || 'http://localhost:3000/auth/discord/callback',
          scope: ['identify', 'email'],
        },
        async (accessToken, refreshToken, profile, done) => {
          try {
            const user = await context.sudo().db.User.findOne({
              where: { discordId: profile.id },
            });

            if (!user) {
              const newUser = await context.sudo().db.User.createOne({
                data: {
                  discordId: profile.id,
                  username: profile.username,
                  tag: profile.discriminator,
                  email: profile.email,
                  role: 'user',
                  password: '', // Keystone necesita este campo, pero no se usará
                },
              });
              return done(null, newUser);
            }

            return done(null, user);
          } catch (error) {
            return done(error as Error, undefined);
          }
        }
      )
    );

    // **NUEVO: Serializar y deserializar usuario**
    passport.serializeUser((user: any, done) => {
      done(null, user.id); // Guardamos solo el ID del usuario en la sesión
    });

    passport.deserializeUser(async (id: string, done) => {
      try {
        const user = await context.sudo().db.User.findOne({
          where: { id },
        });

        if (!user) {
          return done(new Error('Usuario no encontrado'));
        }

        done(null, user);
      } catch (error) {
        done(error, null);
      }
    });

    // Ruta para iniciar sesión con Discord
    app.get('/auth/discord', passport.authenticate('discord'));

    // Ruta de callback de Discord
    app.get(
      '/auth/discord/callback',
      passport.authenticate('discord', { failureRedirect: '/login' }),
      (req, res) => {
        res.redirect('/dashboard'); // Redirige al dashboard tras la autenticación
      }
    );

    // Ruta para cerrar sesión
    app.get('/logout', (req, res) => {
      req.logout((err) => {
        if (err) {
          console.error('Error al cerrar sesión:', err);
        }
        res.redirect('/');
      });
    });
  },
},

})
);

// auth.ts
import { createAuth } from '@keystone-6/auth';
import passport from 'passport';
import { Strategy as DiscordStrategy } from 'passport-discord';
import { User } from './types';

const discordAuth = createAuth({
listKey: 'User',
identityField: 'discordId',
secretField: 'password', // Keystone requiere un campo de contraseña
sessionData: 'role',
passwordField: 'password', // Necesario aunque no lo usemos
initializeDatabase: async (keystone) => {
passport.use(
new DiscordStrategy(
{
clientID: process.env.DISCORD_CLIENT_ID || '',
clientSecret: process.env.DISCORD_CLIENT_SECRET || '',
callbackURL: process.env.DISCORD_CALLBACK_URL || '',
scope: ['identify', 'email'],
},
async (accessToken, refreshToken, profile, done) => {
try {
const context = keystone.createContext({ sudo: true });

        let user = await context.query.User.findOne({
          where: { discordId: profile.id },
        });

        if (!user) {
          user = await context.query.User.createOne({
            data: {
              discordId: profile.id,
              username: profile.username,
              tag: profile.discriminator,
              email: profile.email,
              role: 'user',
              password: '', // Se puede dejar vacío, ya que no se usará
            },
          });
        }

        return done(null, user);
      } catch (error) {
        return done(error as Error, undefined);
      }
    }
  )
);

},
});

export const { withAuth } = discordAuth;

// access.ts
import { Session } from '@keystone-6/core/types';

export const isAdmin = ({ session }: { session: Session }) => {
return session?.data.role === 'admin';
};

[juanppdev]

I also get this error:

Error: @prisma/client did not initialize yet. Please run "prisma generate" and try to import it again.
at new PrismaClient (D:\Proyectos\Dashboard\KeystoneJS\node_modules@keystone-6\core\node_modules.prisma\client\default.js:43:11)
at Object.getKeystone (D:\Proyectos\Dashboard\KeystoneJS\node_modules@keystone-6\core\dist\createSystem-7fbfea14.cjs.dev.js:4575:31)
at D:\Proyectos\Dashboard\KeystoneJS\node_modules@keystone-6\core\scripts\cli\dist\keystone-6-core-scripts-cli.cjs.dev.js:1109:33
at process.processTicksAndRejections (node:internal/process/task_queues:105:5)
at async initKeystone (D:\Proyectos\Dashboard\KeystoneJS\node_modules@keystone-6\core\scripts\cli\dist\keystone-6-core-scripts-cli.cjs.dev.js:1035:9)

[juanppdev]

@dcousens Can you help me?

[marekryb]

Hi @juanppdev ,

How about you start with passport github example? Just change passport-github2 package to passport-discord and all occurrences of github to discord? Base oauth code should be exactly the same.

[juanppdev]

Pefect, i look this