Salut à tous,

C'est avec beaucoup de désespoir que je me retrouve ici.

Voilà, j'utilise la pile MERN pour un site e-commerce.

J'ai décidé d'utiliser les cookies avec express-session pour garder l'état de l'utilisateur actuellement connecté. Tous mes tests passent très bien en local, c'est-à-dire que lorsque l'utilisateur se connecte avec les bons identifiants, il est renvoyé vers la page d'accueil depuis laquelle j'effectue une autre requête vers le back pour déterminer s'il est effectivement connecté.

Mais seulement après le déploiement sur Vercel et le rendu, cela ne passe plus. Lorsqu'il se connecte, la requête que j'effectue pour déterminer son statut ne fait que me renvoyer une 403. Déjà plus de 5 jours que j'essaie de régler cela, mais rien.

Aussi, je rencontre le même problème avec une requête les OAuth telles que Google et Facebook, mais je préfère d'abord commencer par ceci.

Merci d'avance pour vos réponses.

Le lien des differents domaines : 
https://oubuntu-frontend-ori.onrender.com/


mon fichier d'entrer App.ts

/* eslint-disable @typescript-eslint/no-unused-vars */
/* eslint-disable comma-dangle */
/* eslint-disable no-console */
import path, { join } from 'path';
import * as url from 'url';

import passport from 'passport';
import expresssession from 'express-session';
import express from 'express';
import AdminJS from 'adminjs';
import { buildAuthenticatedRouter } from '@adminjs/express';
import dotenv from 'dotenv';
import cors from 'cors';
import cookieParser from 'cookie-parser';
import mongoose from 'mongoose';
import { Database, Resource } from '@adminjs/mongoose';

import provider from './admin/auth-provider.js';
import options from './admin/options.js';
import initializeDb from './db/index.js';
import errLogger from './middleware/errLogger.js';
import errorHandlerMiddleware from './middleware/errorMiddleware.js';
import offersRoute from './routes/offersRoute.js';
import productsRoute from './routes/productRoute.js';
import usersRoute from './routes/userRoute.js';
import authRoute from './routes/authRoute.js';
import rootRouter from './routes/root.js';
import { corsOptions } from './config/corsCongif.js';
import { logger } from './middleware/logger.js';
import groupsRoute from './routes/group.route.js';
import { configurePassport } from './config/passport.js';
import { deleteAllDocuments } from './utils/deleteMany.js';
import User from './models/userModel.js';
import Product from './models/productsModel.js';
import Offer from './models/offerModel.js';
import Group from './models/groupe.model.js';
import GroupeMember from './models/groupMenber.entity.js';
import ProductQuantityGroupe from './models/productQuantityGroupeModel.entity.js';
import categoriesRoutes from './routes/categoriesRoutes.js';
import dbConnection from './config/dbConnection.js';

dotenv.config();

const PORT = process.env.PORT || 3500;
const secretKey = process.env.EXPRESS_SESSION_KEY as string;
const CLIENT_DOMAIN = process.env.CLIENT_DOMAIN as string;
const app = express();
const isProduction = process.env.NODE_ENV === 'production';

//

// other imports

const __dirname = url.fileURLToPath(new URL('.', import.meta.url));

AdminJS.registerAdapter({ Database, Resource });

const start = async () => {
  const mongoDB = await initializeDb();
  // await dbConnection();

  const admin = new AdminJS({
    ...options,
    databases: [mongoDB.db],
  });

  if (process.env.NODE_ENV === 'production') {
    await admin.initialize();
  } else {
    admin.watch();
  }

  const router = buildAuthenticatedRouter(
    admin,
    {
      cookiePassword: process.env.COOKIE_SECRET,
      cookieName: 'adminjs',
      provider,
    },
    null,
    {
      secret: process.env.COOKIE_SECRET,
      saveUninitialized: true,
      resave: true,
    }
  );
  // server files
  // app.use(express.static(path.join(__dirname, 'public', 'images')));

  app.use(admin.options.rootPath, router);
  configurePassport();

  // deleteAllDocuments(User);
  // logger middleware
  app.use(logger);
  // cookie-parser to manage secure cookie
  app.use(cookieParser());

  // cors
  app.use(cors(corsOptions));

  // session authentication configuration
  const sessionMiddleware = expresssession({
    secret: secretKey,
    resave: true,
    saveUninitialized: true,
    cookie: {
      maxAge: 1000 * 60 * 60 * 10,
      // TODO : change
      secure: !!isProduction,
      sameSite: isProduction ? 'none' : 'lax',
      domain: !isProduction ? 'localhost' : '.orender.com ',
      httpOnly: true,
    },
    name: 'oubuntu_cookie',
  });
  app.use(express.json());
  app.use(express.urlencoded({ extended: true }));
  app.use(sessionMiddleware);
  app.use(passport.initialize());
  app.use(passport.session());
  // static files
  app.use((req, res, next) => {
    res.header('Access-Control-Allow-Credentials', 'true');
    res.header('Access-Control-Allow-Methods', 'GET, PUT, POST, DELETE, OPTIONS');

    if (req.method === 'OPTIONS') {
      res.sendStatus(200);
    } else {
      next();
    }
  });
  app.use('/', express.static(join(process.cwd(), 'src', 'public')));

  // root router
  app.use('/', rootRouter);

  // auth routes
  app.use('/api/auth', authRoute);

  // users Route
  app.use('/api/users', usersRoute);
  app.use('/api/products', productsRoute);
  app.use('/api/offers', offersRoute);
  app.use('/api/groups', groupsRoute);
  app.use('/api/categories', categoriesRoutes);

  // Catch-all routes
  app.all('/*', (req, res) => {
    res.status(404);

    if (req.accepts('html')) {
      // nothing
    } else if (req.accepts('json')) {
      res.json({ message: 'Not Found !' });
    } else {
      res.type('text').send('Not Found');
    }
  });

  // custom error handler
  app.use(errLogger);
  app.use(errorHandlerMiddleware);

  // listener
  mongoose.connection.once('open', () => {
    console.log('Connected to MongoDB');
  });
  app.listen(PORT, () => {
    console.log('Server is running on : ', `http://localhost:${PORT}`);
    console.log(`AdminJS started on http://localhost:${PORT}${admin.options.rootPath}`);
  });

  mongoose.connection.on('error', (err) => {
    console.log(`MongoDB connection error: ${err.message}`);
  });
};

start();

// les controller

/**
   * @desc auhenticate a user with email and password
   * @route POST /auth/login
   * @access public
   * @param req
   * @param res
   * @returns
   */
  static async login(req: Request, res: Response) {
    const { email, password } = req.body;

    if (!email || !password) {
      return res.status(400).json({ status: 'error', message: 'All fields are required!' });
    }

    // check if the user exist
    const checkUser = await User.findOne({ email });
    // console.log('checkUser', checkUser);
    if (!checkUser) {
      return res.status(401).json({ message: 'Unauthorized ! ', status: 'error' });
    }

    // check if the password match
    const matchPassword = await bcrypt.compare(password, checkUser.password);
    // console.log('findUser', matchPassword, checkUser, password);

    // the password doesn't match
    if (!matchPassword) {
      return res.status(401).json({ message: 'Unauthorized', status: 'error' });
    }

    req.session.user = checkUser;
    req.session.userId = checkUser._id.toString();

    delete checkUser.password;
    console.log('user : ', req.session.id);

    return res.json({
      status: 'success',
      data: checkUser,
      message: 'successfully logged in',
    });
  }

  static async getUserStatus(req: Request, res: Response) {
    const { user: userSession, userId } = req.session;
    const { user } = req;

    console.log('user with get status : ', req.user);

    if (req.user) {
      return res.json({
        status: 'success',
        message: 'Logged in',
        data: user,
      });
    }
    console.log('user service : ', userId, userSession);
    if (!userId && !userSession) {
      return res.status(403).json({ message: 'Not logged in', status: 'error' });
    }

    delete (userSession as UserTypes).password;

    return res.json({
      status: 'success',
      message: 'Logged in',
      data: userSession,
    });
  }
l'instance axios utilise

-
Edité par IvanSilatsa 29 février 2024 à 19:58:37