@intlayer/backend 3.0.0

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

@@ -0,0 +1,98 @@
+import * as projectAccessKeyService from './../services/projectAccessKey.service.mjs';
+import { ErrorHandler } from './../utils/errors/index.mjs';
+import { formatResponse } from './../utils/responseData.mjs';
+const addNewAccessKey = async (req, res, _next) => {
+  const { user, project } = res.locals;
+  if (!project) {
+    ErrorHandler.handleGenericErrorResponse(res, "PROJECT_NOT_FOUND");
+    return;
+  }
+  if (!user) {
+    ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_FOUND");
+    return;
+  }
+  try {
+    const newAccessKey = await projectAccessKeyService.addNewAccessKey(
+      req.body,
+      project._id,
+      user
+    );
+    const responseData = formatResponse({
+      data: newAccessKey
+    });
+    res.json(responseData);
+    return;
+  } catch (error) {
+    ErrorHandler.handleAppErrorResponse(res, error);
+    return;
+  }
+};
+const deleteAccessKey = async (req, res, _next) => {
+  const { user, project } = res.locals;
+  const { clientId } = req.body;
+  if (!project) {
+    ErrorHandler.handleGenericErrorResponse(res, "PROJECT_NOT_FOUND");
+    return;
+  }
+  if (!user) {
+    ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_FOUND");
+    return;
+  }
+  if (!clientId) {
+    ErrorHandler.handleGenericErrorResponse(res, "CLIENT_ID_NOT_FOUND");
+    return;
+  }
+  try {
+    const deletedAccessKey = await projectAccessKeyService.deleteAccessKey(
+      clientId,
+      project
+    );
+    if (!deletedAccessKey) {
+      ErrorHandler.handleGenericErrorResponse(res, "ACCESS_KEY_NOT_FOUND", {
+        clientId
+      });
+      return;
+    }
+    const responseData = formatResponse({
+      data: null
+    });
+    res.json(responseData);
+    return;
+  } catch (error) {
+    ErrorHandler.handleAppErrorResponse(res, error);
+    return;
+  }
+};
+const refreshAccessKey = async (req, res, _next) => {
+  const { user, project } = res.locals;
+  const { clientId } = req.body;
+  if (!project) {
+    ErrorHandler.handleGenericErrorResponse(res, "PROJECT_NOT_FOUND");
+  }
+  if (!user) {
+    ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_FOUND");
+  }
+  if (!clientId) {
+    ErrorHandler.handleGenericErrorResponse(res, "CLIENT_ID_NOT_FOUND");
+  }
+  try {
+    const newAccessKey = await projectAccessKeyService.refreshAccessKey(
+      clientId,
+      project._id
+    );
+    const responseData = formatResponse({
+      data: newAccessKey
+    });
+    res.json(responseData);
+    return;
+  } catch (error) {
+    ErrorHandler.handleAppErrorResponse(res, error);
+    return;
+  }
+};
+export {
+  addNewAccessKey,
+  deleteAccessKey,
+  refreshAccessKey
+};
+//# sourceMappingURL=projectAccessKey.controller.mjs.map

package/dist/esm/controllers/projectAccessKey.controller.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/controllers/projectAccessKey.controller.ts"],"sourcesContent":["import type { ResponseWithInformation } from '@middlewares/sessionAuth.middleware';\nimport * as projectAccessKeyService from '@services/projectAccessKey.service';\nimport { AppError, ErrorHandler } from '@utils/errors';\nimport { type ResponseData, formatResponse } from '@utils/responseData';\nimport type { NextFunction, Request } from 'express';\nimport type { AccessKeyData, OAuth2Access } from '@/types/project.types';\n\nexport type AddNewAccessKeyBody = AccessKeyData;\nexport type AddNewAccessKeyResponse = ResponseData<OAuth2Access>;\n\n/**\n * Adds a new access key to a project.\n */\nexport const addNewAccessKey = async (\n  req: Request<AddNewAccessKeyBody>,\n  res: ResponseWithInformation<AddNewAccessKeyResponse>,\n  _next: NextFunction\n): Promise<void> => {\n  const { user, project } = res.locals;\n\n  if (!project) {\n    ErrorHandler.handleGenericErrorResponse(res, 'PROJECT_NOT_FOUND');\n    return;\n  }\n\n  if (!user) {\n    ErrorHandler.handleGenericErrorResponse(res, 'USER_NOT_FOUND');\n    return;\n  }\n\n  try {\n    const newAccessKey = await projectAccessKeyService.addNewAccessKey(\n      req.body,\n      project._id,\n      user\n    );\n\n    const responseData = formatResponse<OAuth2Access>({\n      data: newAccessKey,\n    });\n\n    res.json(responseData);\n    return;\n  } catch (error) {\n    ErrorHandler.handleAppErrorResponse(res, error as AppError);\n    return;\n  }\n};\n\nexport type DeleteAccessKeyBody = { clientId: string };\nexport type DeleteAccessKeyResponse = ResponseData<null>;\n\n/**\n * Deletes an access key from a project.\n */\nexport const deleteAccessKey = async (\n  req: Request,\n  res: ResponseWithInformation<AddNewAccessKeyResponse>,\n  _next: NextFunction\n): Promise<void> => {\n  const { user, project } = res.locals;\n  const { clientId } = req.body;\n\n  if (!project) {\n    ErrorHandler.handleGenericErrorResponse(res, 'PROJECT_NOT_FOUND');\n    return;\n  }\n\n  if (!user) {\n    ErrorHandler.handleGenericErrorResponse(res, 'USER_NOT_FOUND');\n    return;\n  }\n\n  if (!clientId) {\n    ErrorHandler.handleGenericErrorResponse(res, 'CLIENT_ID_NOT_FOUND');\n    return;\n  }\n\n  try {\n    const deletedAccessKey = await projectAccessKeyService.deleteAccessKey(\n      clientId,\n      project\n    );\n\n    if (!deletedAccessKey) {\n      ErrorHandler.handleGenericErrorResponse(res, 'ACCESS_KEY_NOT_FOUND', {\n        clientId,\n      });\n      return;\n    }\n\n    const responseData = formatResponse<null>({\n      data: null,\n    });\n\n    res.json(responseData);\n    return;\n  } catch (error) {\n    ErrorHandler.handleAppErrorResponse(res, error as AppError);\n    return;\n  }\n};\n\nexport type RefreshAccessKeyBody = { clientId: string };\nexport type RefreshAccessKeyResponse = ResponseData<OAuth2Access>;\n\n/**\n * Refreshes an access key from a project.\n */\nexport const refreshAccessKey = async (\n  req: Request<RefreshAccessKeyBody>,\n  res: ResponseWithInformation<RefreshAccessKeyResponse>,\n  _next: NextFunction\n): Promise<void> => {\n  const { user, project } = res.locals;\n  const { clientId } = req.body;\n\n  if (!project) {\n    ErrorHandler.handleGenericErrorResponse(res, 'PROJECT_NOT_FOUND');\n  }\n\n  if (!user) {\n    ErrorHandler.handleGenericErrorResponse(res, 'USER_NOT_FOUND');\n  }\n\n  if (!clientId) {\n    ErrorHandler.handleGenericErrorResponse(res, 'CLIENT_ID_NOT_FOUND');\n  }\n\n  try {\n    const newAccessKey = await projectAccessKeyService.refreshAccessKey(\n      clientId,\n      project!._id\n    );\n\n    const responseData = formatResponse<OAuth2Access>({\n      data: newAccessKey,\n    });\n\n    res.json(responseData);\n    return;\n  } catch (error) {\n    ErrorHandler.handleAppErrorResponse(res, error as AppError);\n    return;\n  }\n};\n"],"mappings":"AACA,YAAY,6BAA6B;AACzC,SAAmB,oBAAoB;AACvC,SAA4B,sBAAsB;AAU3C,MAAM,kBAAkB,OAC7B,KACA,KACA,UACkB;AAClB,QAAM,EAAE,MAAM,QAAQ,IAAI,IAAI;AAE9B,MAAI,CAAC,SAAS;AACZ,iBAAa,2BAA2B,KAAK,mBAAmB;AAChE;AAAA,EACF;AAEA,MAAI,CAAC,MAAM;AACT,iBAAa,2BAA2B,KAAK,gBAAgB;AAC7D;AAAA,EACF;AAEA,MAAI;AACF,UAAM,eAAe,MAAM,wBAAwB;AAAA,MACjD,IAAI;AAAA,MACJ,QAAQ;AAAA,MACR;AAAA,IACF;AAEA,UAAM,eAAe,eAA6B;AAAA,MAChD,MAAM;AAAA,IACR,CAAC;AAED,QAAI,KAAK,YAAY;AACrB;AAAA,EACF,SAAS,OAAO;AACd,iBAAa,uBAAuB,KAAK,KAAiB;AAC1D;AAAA,EACF;AACF;AAQO,MAAM,kBAAkB,OAC7B,KACA,KACA,UACkB;AAClB,QAAM,EAAE,MAAM,QAAQ,IAAI,IAAI;AAC9B,QAAM,EAAE,SAAS,IAAI,IAAI;AAEzB,MAAI,CAAC,SAAS;AACZ,iBAAa,2BAA2B,KAAK,mBAAmB;AAChE;AAAA,EACF;AAEA,MAAI,CAAC,MAAM;AACT,iBAAa,2BAA2B,KAAK,gBAAgB;AAC7D;AAAA,EACF;AAEA,MAAI,CAAC,UAAU;AACb,iBAAa,2BAA2B,KAAK,qBAAqB;AAClE;AAAA,EACF;AAEA,MAAI;AACF,UAAM,mBAAmB,MAAM,wBAAwB;AAAA,MACrD;AAAA,MACA;AAAA,IACF;AAEA,QAAI,CAAC,kBAAkB;AACrB,mBAAa,2BAA2B,KAAK,wBAAwB;AAAA,QACnE;AAAA,MACF,CAAC;AACD;AAAA,IACF;AAEA,UAAM,eAAe,eAAqB;AAAA,MACxC,MAAM;AAAA,IACR,CAAC;AAED,QAAI,KAAK,YAAY;AACrB;AAAA,EACF,SAAS,OAAO;AACd,iBAAa,uBAAuB,KAAK,KAAiB;AAC1D;AAAA,EACF;AACF;AAQO,MAAM,mBAAmB,OAC9B,KACA,KACA,UACkB;AAClB,QAAM,EAAE,MAAM,QAAQ,IAAI,IAAI;AAC9B,QAAM,EAAE,SAAS,IAAI,IAAI;AAEzB,MAAI,CAAC,SAAS;AACZ,iBAAa,2BAA2B,KAAK,mBAAmB;AAAA,EAClE;AAEA,MAAI,CAAC,MAAM;AACT,iBAAa,2BAA2B,KAAK,gBAAgB;AAAA,EAC/D;AAEA,MAAI,CAAC,UAAU;AACb,iBAAa,2BAA2B,KAAK,qBAAqB;AAAA,EACpE;AAEA,MAAI;AACF,UAAM,eAAe,MAAM,wBAAwB;AAAA,MACjD;AAAA,MACA,QAAS;AAAA,IACX;AAEA,UAAM,eAAe,eAA6B;AAAA,MAChD,MAAM;AAAA,IACR,CAAC;AAED,QAAI,KAAK,YAAY;AACrB;AAAA,EACF,SAAS,OAAO;AACd,iBAAa,uBAAuB,KAAK,KAAiB;AAC1D;AAAA,EACF;AACF;","names":[]}

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

@@ -0,0 +1,570 @@
+import { logger } from './../logger/index.mjs';
+import { sessionAuthRoutes } 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 { mapUserToAPI } from './../utils/mapper/user.mjs';
+import { formatResponse } from './../utils/responseData.mjs';
+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;
+  if (user) {
+    ErrorHandler.handleGenericErrorResponse(res, "USER_ALREADY_LOGGED_IN");
+    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) {
+        if (emailProvider.emailValidated) {
+          ErrorHandler.handleGenericErrorResponse(
+            res,
+            "EMAIL_ALREADY_VALIDATED"
+          );
+          return;
+        } else {
+          user2 = await sessionAuthService.updateUserProvider(
+            user2._id,
+            "email",
+            {
+              secret: uuidv4()
+            }
+          );
+        }
+      } else {
+        user2 = await sessionAuthService.addUserProvider(user2._id, {
+          provider: "email",
+          emailValidated: void 0,
+          secret: uuidv4()
+        });
+      }
+    } else {
+      user2 = await userService.createUser(userData);
+      logger.info(`New registration: ${user2.name} - ${user2.email}`);
+    }
+    if (!user2) {
+      ErrorHandler.handleGenericErrorResponse(res, "USER_CREATION_FAILED", {
+        email: userData.email
+      });
+      return;
+    }
+    await sessionAuthService.setUserAuth(res, user2);
+    const formattedUser = mapUserToAPI(user2);
+    const responseData = formatResponse({ 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({ 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_FOUND");
+    return;
+  }
+  await sessionAuthService.clearUserAuth(res);
+  sessionAuthService.clearOrganizationAuth(res);
+  sessionAuthService.clearProjectAuth(res);
+  logger.info(`Logout: ${user.name} - ${user.email}`);
+  const responseData = formatResponse({ 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_FOUND");
+    return;
+  }
+  try {
+    const { error } = await sessionAuthService.testUserPassword(
+      user.email,
+      oldPassword
+    );
+    if (error) {
+      ErrorHandler.handleGenericErrorResponse(res, "LOGIN_FAILED");
+      return;
+    }
+    user = await sessionAuthService.changeUserPassword(
+      user._id,
+      oldPassword,
+      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({ data: formattedUser });
+    res.json(responseData);
+    return;
+  } catch (error) {
+    ErrorHandler.handleAppErrorResponse(res, error);
+    return;
+  }
+};
+const validEmail = async (req, res, _next) => {
+  const { userId, secret } = req.params;
+  const { organization } = res.locals;
+  if (!Types.ObjectId.isValid(userId.toString())) {
+    ErrorHandler.handleGenericErrorResponse(res, "INVALID_USER_ID");
+    return;
+  }
+  if (!organization) {
+    ErrorHandler.handleGenericErrorResponse(res, "ORGANIZATION_NOT_FOUND");
+    return;
+  }
+  const user = await userService.getUserById(userId);
+  if (!user) {
+    ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_FOUND", { userId });
+    return;
+  }
+  await sessionAuthService.activateUser(user._id, secret);
+  logger.info(
+    `User activated - User: Name: ${user.name}, id: ${String(user._id)}`
+  );
+  await sendEmail({
+    type: "welcome",
+    to: user.email,
+    username: user.name,
+    loginLink: sessionAuthRoutes.loginEmailPassword.url
+  });
+  const formattedUser = mapUserToAPI(user);
+  const responseData = formatResponse({ data: formattedUser });
+  res.json(responseData);
+};
+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: sessionAuthRoutes.resetPassword.url({
+        userId: String(updatedUser._id),
+        secret: updatedUser.provider?.find(
+          (provider) => provider.provider === "email"
+        )?.secret ?? ""
+      })
+    });
+    const responseData = formatResponse({ data: void 0 });
+    res.json(responseData);
+    return;
+  } catch (error) {
+    ErrorHandler.handleAppErrorResponse(res, error);
+    return;
+  }
+};
+const resetPassword = async (req, res, _next) => {
+  const { secret, userId } = req.params;
+  const password = req.body.password;
+  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({ 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 } = res.locals;
+  try {
+    if (sessionToken) {
+      user = await userService.getUserBySession(sessionToken);
+    }
+    if (!user) {
+      ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_FOUND");
+      return;
+    }
+    const session = user.session;
+    if (!session) {
+      ErrorHandler.handleGenericErrorResponse(res, "SESSION_NOT_FOUND");
+      return;
+    }
+    const formattedUser = {
+      ...mapUserToAPI(user),
+      role: "user"
+    };
+    const responseData = formatResponse({
+      data: { session, user: formattedUser, organization, project }
+    });
+    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;
+  }
+  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}`
+  );
+};
+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;
+  }
+  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: sessionAuthRoutes.loginEmailPassword.url
+    });
+    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;
+  }
+  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;
+  }
+  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: sessionAuthRoutes.loginEmailPassword.url
+    });
+  } catch (error) {
+    ErrorHandler.handleAppErrorResponse(res, error);
+    return;
+  }
+};
+export {
+  askResetPassword,
+  getSessionInformation,
+  githubCallback,
+  githubLoginQuery,
+  googleCallback,
+  googleLoginQuery,
+  logOut,
+  loginEmailPassword,
+  registerEmailPassword,
+  resetPassword,
+  setCSRFToken,
+  updatePassword,
+  validEmail
+};
+//# sourceMappingURL=sessionAuth.controller.mjs.map