@intlayer/backend 5.6.0 → 5.7.0

package/dist/esm/controllers/sessionAuth.controller.mjs

@@ -1,790 +0,0 @@
-import crypto from "crypto";
-import { logger } from "./../logger/index.mjs";
-import { getSessionAuthRoutes } from "./../routes/sessionAuth.routes.mjs";
-import { sendEmail } from "./../services/email.service.mjs";
-import * as sessionAuthService from "./../services/sessionAuth.service.mjs";
-import * as userService from "./../services/user.service.mjs";
-import { generateToken } from "./../utils/CSRF.mjs";
-import { ErrorHandler, GenericError } from "./../utils/errors/index.mjs";
-import { HttpStatusCodes } from "./../utils/httpStatusCodes.mjs";
-import { mapOrganizationToAPI } from "./../utils/mapper/organization.mjs";
-import { mapProjectToAPI } from "./../utils/mapper/project.mjs";
-import { mapUserToAPI } from "./../utils/mapper/user.mjs";
-import { formatResponse } from "./../utils/responseData.mjs";
-import { t } from "express-intlayer";
-import { Types } from "mongoose";
-import { v4 as uuidv4 } from "uuid";
-const setCSRFToken = (req, res, _next) => {
-  const csrf_token = generateToken(req, res);
-  const responseData = formatResponse({
-    data: { csrf_token }
-  });
-  res.locals.csrf_token = csrf_token;
-  res.json(responseData);
-};
-const registerEmailPassword = async (req, res, _next) => {
-  const { user } = res.locals;
-  const { callBack_url } = req.query;
-  if (user) {
-    ErrorHandler.handleGenericErrorResponse(res, "USER_ALREADY_LOGGED_IN");
-    return;
-  }
-  if (callBack_url && !callBack_url.startsWith(process.env.CLIENT_URL ?? "")) {
-    ErrorHandler.handleGenericErrorResponse(res, "CALLBACK_URL_NOT_VALID");
-    return;
-  }
-  const userData = req.body;
-  try {
-    let user2 = await userService.getUserByEmail(userData.email);
-    if (user2) {
-      const emailProvider = user2.provider?.find(
-        (provider) => provider.provider === "email"
-      );
-      if (emailProvider?.emailValidated) {
-        ErrorHandler.handleGenericErrorResponse(
-          res,
-          "EMAIL_ALREADY_REGISTERED"
-        );
-        return;
-      } else if (emailProvider) {
-        user2 = await sessionAuthService.updateUserProvider(user2._id, "email", {
-          provider: "email",
-          emailValidated: void 0,
-          secret: uuidv4()
-        });
-      } else {
-        user2 = await sessionAuthService.addUserProvider(user2._id, {
-          provider: "email",
-          emailValidated: void 0,
-          secret: uuidv4()
-        });
-      }
-    } else {
-      user2 = await userService.createUser({
-        ...userData,
-        provider: [
-          {
-            provider: "email",
-            emailValidated: void 0,
-            secret: uuidv4()
-          }
-        ]
-      });
-      logger.info(`New registration: ${user2.name} - ${user2.email}`);
-    }
-    if (!user2) {
-      ErrorHandler.handleGenericErrorResponse(res, "USER_CREATION_FAILED", {
-        email: userData.email
-      });
-      return;
-    }
-    await sendEmail({
-      type: "validate",
-      to: user2.email,
-      username: user2.name ?? user2.email.split("@")[0],
-      validationLink: getSessionAuthRoutes().validEmail.url({
-        userId: String(user2._id),
-        secret: user2.provider?.find((provider) => provider.provider === "email")?.secret ?? "",
-        callBack_url
-      })
-    });
-    const formattedUser = mapUserToAPI(user2);
-    const responseData = formatResponse({
-      message: t({
-        en: "User registered successfully",
-        fr: "Utilisateur enregistr\xE9 avec succ\xE8s",
-        es: "Usuario registrado con \xE9xito"
-      }),
-      description: t({
-        en: "Your user has been registered successfully. Please check your email to validate your account.",
-        fr: "Votre utilisateur a \xE9t\xE9 enregistr\xE9 avec succ\xE8s. Veuillez v\xE9rifier votre e-mail pour valider votre compte.",
-        es: "Su usuario ha sido registrado con \xE9xito. Por favor, revise su correo electr\xF3nico para validar su cuenta."
-      }),
-      data: formattedUser
-    });
-    res.json(responseData);
-    return;
-  } catch (error) {
-    ErrorHandler.handleAppErrorResponse(res, error);
-    return;
-  }
-};
-const loginEmailPassword = async (req, res, _next) => {
-  const { user } = res.locals;
-  if (user) {
-    ErrorHandler.handleGenericErrorResponse(res, "USER_ALREADY_LOGGED_IN");
-    return;
-  }
-  const { email, password } = req.body;
-  try {
-    const { user: loggedInUser, error } = await sessionAuthService.testUserPassword(email, password);
-    if (error) {
-      if (!user) {
-        ErrorHandler.handleGenericErrorResponse(res, "LOGIN_FAILED");
-        return;
-      }
-    }
-    if (!loggedInUser) {
-      ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_FOUND");
-      return;
-    }
-    await sessionAuthService.setUserAuth(res, loggedInUser);
-    const formattedUser = mapUserToAPI(loggedInUser);
-    const responseData = formatResponse({
-      message: t({
-        en: "User logged in successfully",
-        fr: "Utilisateur connect\xE9 avec succ\xE8s",
-        es: "Usuario conectado con \xE9xito"
-      }),
-      description: t({
-        en: "Your user has been logged in successfully",
-        fr: "Votre utilisateur a \xE9t\xE9 connect\xE9 avec succ\xE8s",
-        es: "Su usuario ha sido conectado con \xE9xito"
-      }),
-      data: formattedUser
-    });
-    logger.info(`Login: ${loggedInUser.email}`);
-    res.json(responseData);
-    return;
-  } catch (error) {
-    ErrorHandler.handleAppErrorResponse(res, error);
-    return;
-  }
-};
-const logOut = async (_req, res, _next) => {
-  const { user } = res.locals;
-  if (!user) {
-    ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_DEFINED");
-    return;
-  }
-  await sessionAuthService.clearUserAuth(res);
-  sessionAuthService.clearOrganizationAuth(res);
-  sessionAuthService.clearProjectAuth(res);
-  logger.info(`Logout: ${user.name} - ${user.email}`);
-  const responseData = formatResponse({
-    message: t({
-      en: "User logged out successfully",
-      fr: "Utilisateur d\xE9connect\xE9 avec succ\xE8s",
-      es: "Usuario desconectado con \xE9xito"
-    }),
-    description: t({
-      en: "Your user has been logged out successfully",
-      fr: "Votre utilisateur a \xE9t\xE9 d\xE9connect\xE9 avec succ\xE8s",
-      es: "Su usuario ha sido desconectado con \xE9xito"
-    }),
-    data: void 0
-  });
-  res.json(responseData);
-};
-const updatePassword = async (req, res, _next) => {
-  const { oldPassword, newPassword } = req.body;
-  let { user } = res.locals;
-  if (!user) {
-    ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_DEFINED");
-    return;
-  }
-  const userEmailProvider = user.provider?.find(
-    (provider) => provider.provider === "email"
-  );
-  if (!userEmailProvider) {
-    ErrorHandler.handleGenericErrorResponse(res, "USER_PROVIDER_NOT_FOUND", {
-      provider: "email"
-    });
-    return;
-  }
-  if (userEmailProvider.passwordHash && !oldPassword) {
-    ErrorHandler.handleGenericErrorResponse(
-      res,
-      "USER_PREVIOUS_PASSWORD_NOT_PROVIDED"
-    );
-    return;
-  }
-  try {
-    if (oldPassword) {
-      const { error } = await sessionAuthService.testUserPassword(
-        user.email,
-        oldPassword
-      );
-      if (error) {
-        ErrorHandler.handleGenericErrorResponse(res, "LOGIN_FAILED");
-        return;
-      }
-    }
-    user = await sessionAuthService.changeUserPassword(user._id, newPassword);
-    if (!user || typeof user !== "object") {
-      ErrorHandler.handleGenericErrorResponse(res, "USER_DATA_NOT_FOUND");
-      return;
-    }
-    logger.info(
-      `Password changed - User : Name : ${user.name}, id : ${String(user._id)}`
-    );
-    const formattedUser = mapUserToAPI(user);
-    const responseData = formatResponse({
-      message: t({
-        en: "Password changed successfully",
-        fr: "Mot de passe modifi\xE9 avec succ\xE8s",
-        es: "Contrase\xF1a cambiada con \xE9xito"
-      }),
-      description: t({
-        en: "Your password has been changed successfully",
-        fr: "Votre mot de passe a \xE9t\xE9 modifi\xE9 avec succ\xE8s",
-        es: "Su contrase\xF1a ha sido cambiada con \xE9xito"
-      }),
-      data: formattedUser
-    });
-    res.json(responseData);
-    return;
-  } catch (error) {
-    ErrorHandler.handleAppErrorResponse(res, error);
-    return;
-  }
-};
-let clients = [];
-const sendVerificationUpdate = (user) => {
-  const filteredClients = clients.filter(
-    (client) => String(client.userId) === String(user._id)
-  );
-  for (const client of filteredClients) {
-    const provider = user.provider?.find(
-      (provider2) => provider2.provider === "email"
-    );
-    if (provider?.emailValidated) {
-      client.res.write(
-        `data: ${JSON.stringify({ userId: user._id, status: "verified" })}
-
-`
-      );
-      continue;
-    }
-    client.res.write(
-      `data: ${JSON.stringify({ userId: user._id, status: "waiting" })}
-
-`
-    );
-  }
-};
-const checkIfUserHasPassword = async (_req, res, _next) => {
-  const { user } = res.locals;
-  if (!user) {
-    ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_DEFINED");
-    return;
-  }
-  try {
-    const userProvider = user.provider?.find(
-      (provider) => provider.provider === "email"
-    );
-    const responseData = formatResponse({
-      data: {
-        hasPassword: Boolean(userProvider?.passwordHash)
-      }
-    });
-    res.json(responseData);
-    return;
-  } catch (error) {
-    ErrorHandler.handleAppErrorResponse(res, error);
-    return;
-  }
-};
-const validEmail = async (req, res, _next) => {
-  const { userId, secret } = req.params;
-  const callBack_url = `${req.query.callBack_url ?? `${process.env.CLIENT_URL}/auth/login`}?userId=${userId}`;
-  if (!Types.ObjectId.isValid(userId.toString())) {
-    ErrorHandler.handleGenericErrorResponse(res, "INVALID_USER_ID");
-    return;
-  }
-  const user = await userService.getUserById(userId);
-  if (!user) {
-    ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_DEFINED", {
-      userId
-    });
-    return;
-  }
-  if (callBack_url && !callBack_url.startsWith(process.env.CLIENT_URL ?? "")) {
-    ErrorHandler.handleGenericErrorResponse(res, "CALLBACK_URL_NOT_VALID");
-    return;
-  }
-  const provider = user.provider?.find(
-    (provider2) => provider2.provider === "email"
-  );
-  if (provider?.emailValidated) {
-    res.redirect(callBack_url);
-  }
-  if (!provider?.secret) {
-    throw new GenericError("USER_PROVIDER_SECRET_NOT_DEFINED", { userId });
-  }
-  if (!crypto.timingSafeEqual(Buffer.from(provider.secret), Buffer.from(secret))) {
-    throw new GenericError("USER_PROVIDER_SECRET_NOT_VALID", { userId });
-  }
-  await sessionAuthService.updateUserProvider(userId, "email", {
-    secret: void 0,
-    emailValidated: /* @__PURE__ */ new Date()
-  });
-  logger.info(
-    `User activated - User: Name: ${user.name}, id: ${String(user._id)}`
-  );
-  sendVerificationUpdate(user);
-  await sessionAuthService.setUserAuth(res, user);
-  await sendEmail({
-    type: "welcome",
-    to: user.email,
-    username: user.name,
-    loginLink: callBack_url
-  });
-  res.redirect(callBack_url);
-};
-const verifyEmailStatusSSE = async (req, res) => {
-  res.setHeader("Content-Type", "text/event-stream;charset=utf-8");
-  res.setHeader("Cache-Control", "no-cache, no-transform");
-  res.setHeader("Connection", "keep-alive");
-  res.setHeader("X-Accel-Buffering", "no");
-  res.write(":\n\n");
-  res.flushHeaders();
-  const { userId } = req.params;
-  const clientId = Date.now();
-  const user = await userService.getUserById(userId);
-  if (!user) {
-    logger.error(`User not found - User ID: ${userId}`);
-    res.write(`data: ${JSON.stringify({ userId, status: "error" })}
-
-`);
-    res.end();
-    return;
-  }
-  const newClient = { id: clientId, userId, res };
-  clients.push(newClient);
-  sendVerificationUpdate(user);
-  req.on("close", () => {
-    clients = clients.filter((client) => client.id !== clientId);
-  });
-};
-const askResetPassword = async (req, res, _next) => {
-  const { email } = req.body;
-  if (!email) {
-    ErrorHandler.handleGenericErrorResponse(res, "EMAIL_NOT_PROVIDED");
-    return;
-  }
-  try {
-    const updatedUser = await sessionAuthService.requestPasswordReset(email);
-    if (!updatedUser) {
-      ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_FOUND", { email });
-      return;
-    }
-    logger.info(
-      `Ask changing password - User: Name: ${updatedUser.name}, id: ${String(updatedUser._id)}`
-    );
-    await sendEmail({
-      type: "resetPassword",
-      to: updatedUser.email,
-      username: updatedUser.name,
-      resetLink: `${process.env.CLIENT_URL}/auth/password/reset/${String(updatedUser._id)}/${updatedUser.provider?.find((provider) => provider.provider === "email")?.secret ?? ""}`
-    });
-    const responseData = formatResponse({
-      message: t({
-        en: "Password reset request sent successfully",
-        fr: "Demande de r\xE9initialisation de mot de passe envoy\xE9e avec succ\xE8s",
-        es: "Solicitud de restablecimiento de contrase\xF1a enviada con \xE9xito"
-      }),
-      description: t({
-        en: "Your password reset request has been sent successfully. Please check your email to reset your password.",
-        fr: "Votre demande de r\xE9initialisation de mot de passe a \xE9t\xE9 envoy\xE9e avec succ\xE8s. Veuillez v\xE9rifier votre e-mail pour r\xE9initialiser votre mot de passe.",
-        es: "Su solicitud de restablecimiento de contrase\xF1a ha sido enviada con \xE9xito. Por favor, revise su correo electr\xF3nico para restablecer su contrase\xF1a."
-      }),
-      data: void 0
-    });
-    res.json(responseData);
-    return;
-  } catch (error) {
-    ErrorHandler.handleAppErrorResponse(res, error);
-    return;
-  }
-};
-const definePassword = async (req, res, _next) => {
-  const { secret, userId, password } = req.body;
-  const userIdString = String(userId);
-  if (!userId || !userIdString || !Types.ObjectId.isValid(userIdString)) {
-    ErrorHandler.handleGenericErrorResponse(res, "INVALID_USER_ID", { userId });
-    return;
-  }
-  if (!secret) {
-    ErrorHandler.handleGenericErrorResponse(res, "SECRET_NOT_PROVIDED");
-    return;
-  }
-  try {
-    const updatedUser = await sessionAuthService.resetUserPassword(
-      userId,
-      secret,
-      password
-    );
-    logger.info(
-      `Password changed - User: Name: ${updatedUser.name}, id: ${String(updatedUser._id)}`
-    );
-    await sendEmail({
-      type: "passwordChangeConfirmation",
-      to: updatedUser.email,
-      username: updatedUser.name
-    });
-    const formattedUser = mapUserToAPI(updatedUser);
-    const responseData = formatResponse({
-      message: t({
-        en: "Password reset successfully",
-        fr: "R\xE9initialisation du mot de passe r\xE9ussie",
-        es: "Restablecimiento de contrase\xF1a exitoso"
-      }),
-      description: t({
-        en: "Your password has been reset successfully. You can now log in with your new password",
-        fr: "Votre mot de passe a \xE9t\xE9 r\xE9initialis\xE9 avec succ\xE8s. Vous pouvez maintenant vous connecter avec votre nouveau mot de passe",
-        es: "Su contrase\xF1a ha sido restablecida con \xE9xito. Ahora puede iniciar sesi\xF3n con su nueva contrase\xF1a"
-      }),
-      data: formattedUser
-    });
-    res.json(responseData);
-    return;
-  } catch (error) {
-    ErrorHandler.handleAppErrorResponse(res, error);
-    return;
-  }
-};
-const getSessionInformation = async (req, res, _next) => {
-  const { session_token: sessionToken } = req.query;
-  let { user } = res.locals;
-  const { organization, project, isOrganizationAdmin, isProjectAdmin } = res.locals;
-  try {
-    if (sessionToken) {
-      user = await userService.getUserBySession(sessionToken);
-    }
-    if (!user || !user?.session) {
-      const responseData2 = formatResponse({
-        data: {
-          session: null,
-          user: null,
-          organization: organization?._id ? mapOrganizationToAPI(organization, isOrganizationAdmin) : null,
-          project: project?._id ? mapProjectToAPI(project, user, isProjectAdmin) : null
-        }
-      });
-      res.json(responseData2);
-      return;
-    }
-    const session = user.session;
-    const formattedUser = {
-      ...mapUserToAPI(user),
-      role: "user"
-    };
-    const responseData = formatResponse({
-      data: {
-        session,
-        user: formattedUser,
-        organization: organization?._id ? mapOrganizationToAPI(organization, isOrganizationAdmin) : null,
-        project: project?._id ? mapProjectToAPI(project, user, isProjectAdmin) : null
-      }
-    });
-    res.json(responseData);
-    return;
-  } catch (error) {
-    ErrorHandler.handleAppErrorResponse(res, error);
-    return;
-  }
-};
-const githubLoginQuery = (req, res, _next) => {
-  const { origin } = req.query;
-  const { user } = res.locals;
-  if (user) {
-    ErrorHandler.handleGenericErrorResponse(res, "USER_ALREADY_LOGGED_IN");
-    return;
-  }
-  if (origin && !origin.startsWith(process.env.CLIENT_URL ?? "")) {
-    ErrorHandler.handleGenericErrorResponse(res, "CALLBACK_URL_NOT_VALID");
-    return;
-  }
-  const encodedOrigin = encodeURIComponent(origin);
-  const redirectURI = `${process.env.BACKEND_URL}/api/auth/callback/github?redirect_uri=${encodedOrigin}`;
-  const encodedRedirectURI = encodeURIComponent(redirectURI);
-  res.redirect(
-    `https://github.com/login/oauth/authorize?client_id=${process.env.GITHUB_CLIENT_ID}&redirect_uri=${encodedRedirectURI}&scope=user:email`
-  );
-};
-const githubCallback = async (req, res, _next) => {
-  const { code, redirect_uri } = req.query;
-  if (!code) {
-    const errorMessage = "Code not provided";
-    logger.error(errorMessage);
-    res.redirect(redirect_uri);
-    return;
-  }
-  if (!redirect_uri) {
-    const errorMessage = "Redirect URI not provided";
-    logger.error(errorMessage);
-    res.redirect(redirect_uri);
-    return;
-  }
-  if (redirect_uri && !redirect_uri.startsWith(process.env.CLIENT_URL ?? "")) {
-    ErrorHandler.handleGenericErrorResponse(res, "CALLBACK_URL_NOT_VALID");
-    return;
-  }
-  try {
-    const tokenResponse = await fetch(
-      "https://github.com/login/oauth/access_token",
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json"
-        },
-        body: JSON.stringify({
-          client_id: process.env.GITHUB_CLIENT_ID,
-          client_secret: process.env.GITHUB_CLIENT_SECRET,
-          code
-        })
-      }
-    );
-    const tokenData = await tokenResponse.json();
-    const userResponse = await fetch("https://api.github.com/user", {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${tokenData.access_token}`,
-        Accept: "application/vnd.github.v3+json"
-      }
-    });
-    if (!userResponse.ok) {
-      throw new GenericError("GITHUB_FETCH_USER_DATA_FAILED", { userResponse });
-    }
-    const userData = await userResponse.json();
-    const emailResponse = await fetch("https://api.github.com/user/emails", {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${tokenData.access_token}`,
-        Accept: "application/vnd.github.v3+json"
-      }
-    });
-    if (!emailResponse.ok) {
-      throw new GenericError("GIT_HUB_FETCH_USER_EMAIL_FAILED", {
-        emailResponse
-      });
-    }
-    const emails = await emailResponse.json();
-    const primaryEmail = emails.find((email) => email.primary)?.email;
-    if (!primaryEmail) {
-      const errorMessage = "Primary email not found";
-      logger.error(errorMessage);
-      const responseCode = HttpStatusCodes.NOT_FOUND_404;
-      res.redirect(responseCode, redirect_uri);
-      return;
-    }
-    let existingUser = await userService.getUserByEmail(primaryEmail);
-    if (existingUser) {
-      const existingProvider = await sessionAuthService.getUserProvider(
-        existingUser._id,
-        "github"
-      );
-      if (existingProvider?.providerAccountId !== userData.id) {
-        const updatedUser2 = await sessionAuthService.updateUserProvider(
-          existingUser._id,
-          "github",
-          {
-            providerAccountId: userData.id
-          }
-        );
-        logger.info(
-          `GitHub login provider updated - User: Name: ${updatedUser2.name}, id: ${String(updatedUser2._id)}`
-        );
-        if (updatedUser2) {
-          existingUser = updatedUser2;
-        }
-      }
-      const updatedUser = await userService.updateUserById(existingUser._id, {
-        name: existingUser.name ?? userData.name
-      });
-      await sessionAuthService.setUserAuth(res, updatedUser);
-      res.redirect(redirect_uri);
-      return;
-    }
-    const userInformation = {
-      name: userData.name,
-      email: primaryEmail
-    };
-    const userProvider = {
-      provider: "github",
-      providerAccountId: userData.id
-    };
-    const user = await userService.createUser({
-      ...userInformation,
-      provider: [userProvider]
-    });
-    await sessionAuthService.setUserAuth(res, user);
-    logger.info(
-      `GitHub login - User: Name: ${user.name}, id: ${String(user._id)}`
-    );
-    await sendEmail({
-      type: "welcome",
-      to: user.email,
-      username: user.name,
-      loginLink: `${process.env.CLIENT_URL}/auth/login`
-    });
-    res.redirect(redirect_uri);
-  } catch (error) {
-    ErrorHandler.handleAppErrorResponse(res, error);
-    return;
-  }
-};
-const googleLoginQuery = (req, res, _next) => {
-  const { origin } = req.query;
-  const { user } = res.locals;
-  if (user) {
-    const errorMessage = `User already logged in - ${user?.email}`;
-    logger.error(errorMessage);
-    res.redirect(origin);
-    return;
-  }
-  if (origin && !origin.startsWith(process.env.CLIENT_URL ?? "")) {
-    ErrorHandler.handleGenericErrorResponse(res, "CALLBACK_URL_NOT_VALID");
-    return;
-  }
-  const responseType = "code";
-  const scope = [
-    "https%3A//www.googleapis.com/auth/userinfo.email",
-    "https%3A//www.googleapis.com/auth/userinfo.profile"
-  ].join(" ");
-  const includeGrantedScopes = "false";
-  const encodedOrigin = encodeURIComponent(origin);
-  const state = JSON.stringify({ redirect_uri: encodedOrigin });
-  const redirectURI = `${process.env.BACKEND_URL}/api/auth/callback/google`;
-  res.redirect(
-    `https://accounts.google.com/o/oauth2/v2/auth?client_id=${process.env.GOOGLE_CLIENT_ID}&redirect_uri=${redirectURI}&response_type=${responseType}&scope=${scope}&include_granted_scopes=${includeGrantedScopes}&state=${state}`
-  );
-};
-const googleCallback = async (req, res, _next) => {
-  const { code, state } = req.query;
-  const decodedState = decodeURIComponent(state);
-  const { redirect_uri } = JSON.parse(decodedState);
-  if (!code) {
-    const errorMessage = "code not provided";
-    logger.error(errorMessage);
-    const responseCode = HttpStatusCodes.BAD_REQUEST_400;
-    res.redirect(responseCode, redirect_uri);
-    return;
-  }
-  if (!redirect_uri) {
-    const errorMessage = "Redirect URI not provided";
-    logger.error(errorMessage);
-    const responseCode = HttpStatusCodes.BAD_REQUEST_400;
-    res.redirect(responseCode, redirect_uri);
-    return;
-  }
-  if (redirect_uri && !redirect_uri.startsWith(process.env.CLIENT_URL ?? "")) {
-    ErrorHandler.handleGenericErrorResponse(res, "CALLBACK_URL_NOT_VALID");
-    return;
-  }
-  try {
-    const tokenResponse = await fetch("https://oauth2.googleapis.com/token", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: new URLSearchParams({
-        code,
-        redirect_uri: `${process.env.BACKEND_URL}/api/auth/callback/google`,
-        client_id: process.env.GOOGLE_CLIENT_ID,
-        client_secret: process.env.GOOGLE_CLIENT_SECRET,
-        grant_type: "authorization_code"
-      })
-    });
-    const responseData = await tokenResponse.json();
-    const { access_token: accessToken } = responseData;
-    if (!accessToken) {
-      const errorMessage = "Failed to fetch access_token";
-      logger.error(errorMessage);
-      const responseCode = HttpStatusCodes.INTERNAL_SERVER_ERROR_500;
-      res.redirect(responseCode, redirect_uri);
-      return;
-    }
-    const userResponse = await fetch(
-      "https://www.googleapis.com/oauth2/v3/userinfo",
-      {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${accessToken}`
-        }
-      }
-    );
-    const userData = await userResponse.json();
-    if (!userData.email) {
-      const errorMessage = "Failed to fetch user data from Google";
-      logger.error(errorMessage);
-      const responseCode = HttpStatusCodes.INTERNAL_SERVER_ERROR_500;
-      res.redirect(responseCode, redirect_uri);
-      return;
-    }
-    let existingUser = await userService.getUserByEmail(userData.email);
-    if (existingUser) {
-      const existingProvider = await sessionAuthService.getUserProvider(
-        existingUser._id,
-        "google"
-      );
-      if (existingProvider?.providerAccountId !== userData.sub) {
-        const updatedUser2 = await sessionAuthService.updateUserProvider(
-          existingUser._id,
-          "google",
-          {
-            providerAccountId: userData.id
-          }
-        );
-        logger.info(
-          `Google login provider updated - User: Name: ${updatedUser2.name}, id: ${String(updatedUser2._id)}`
-        );
-        if (updatedUser2) {
-          existingUser = updatedUser2;
-        }
-      }
-      const updatedUser = await userService.updateUserById(existingUser._id, {
-        name: existingUser.name ?? userData.name
-      });
-      await sessionAuthService.setUserAuth(res, updatedUser);
-      res.redirect(redirect_uri);
-      return;
-    }
-    const userInformation = {
-      name: userData.name,
-      email: userData.email
-    };
-    const userProvider = {
-      provider: "google",
-      providerAccountId: userData.id
-    };
-    const user = await userService.createUser({
-      ...userInformation,
-      provider: [userProvider]
-    });
-    await sessionAuthService.setUserAuth(res, user);
-    logger.info(
-      `Google login - User: Name: ${user.name}, id: ${String(user._id)}`
-    );
-    await sendEmail({
-      type: "welcome",
-      to: user.email,
-      username: user.name,
-      loginLink: `${process.env.CLIENT_URL}/auth/login`
-    });
-    res.redirect(redirect_uri);
-  } catch (error) {
-    ErrorHandler.handleAppErrorResponse(res, error);
-    return;
-  }
-};
-export {
-  askResetPassword,
-  checkIfUserHasPassword,
-  definePassword,
-  getSessionInformation,
-  githubCallback,
-  githubLoginQuery,
-  googleCallback,
-  googleLoginQuery,
-  logOut,
-  loginEmailPassword,
-  registerEmailPassword,
-  sendVerificationUpdate,
-  setCSRFToken,
-  updatePassword,
-  validEmail,
-  verifyEmailStatusSSE
-};
-//# sourceMappingURL=sessionAuth.controller.mjs.map