@intlayer/backend 3.1.0 → 3.2.0

package/dist/cjs/controllers/sessionAuth.controller.cjs

@@ -29,6 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var sessionAuth_controller_exports = {};
 __export(sessionAuth_controller_exports, {
   askResetPassword: () => askResetPassword,
+  checkIfUserHasPassword: () => checkIfUserHasPassword,
   getSessionInformation: () => getSessionInformation,
   githubCallback: () => githubCallback,
   githubLoginQuery: () => githubLoginQuery,
@@ -38,11 +39,14 @@ __export(sessionAuth_controller_exports, {
   loginEmailPassword: () => loginEmailPassword,
   registerEmailPassword: () => registerEmailPassword,
   resetPassword: () => resetPassword,
+  sendVerificationUpdate: () => sendVerificationUpdate,
   setCSRFToken: () => setCSRFToken,
   updatePassword: () => updatePassword,
-  validEmail: () => validEmail
+  validEmail: () => validEmail,
+  verifyEmailStatusSSE: () => verifyEmailStatusSSE
 });
 module.exports = __toCommonJS(sessionAuth_controller_exports);
+var import_crypto = __toESM(require("crypto"), 1);
 var import_logger = require('./../logger/index.cjs');
 var import_sessionAuth = require('./../routes/sessionAuth.routes.cjs');
 var import_email = require('./../services/email.service.cjs');
@@ -55,6 +59,7 @@ var import_organization = require('./../utils/mapper/organization.cjs');
 var import_project = require('./../utils/mapper/project.cjs');
 var import_user = require('./../utils/mapper/user.cjs');
 var import_responseData = require('./../utils/responseData.cjs');
+var import_express_intlayer = require("express-intlayer");
 var import_mongoose = require("mongoose");
 var import_uuid = require("uuid");
 const setCSRFToken = (req, res, _next) => {
@@ -67,10 +72,15 @@ const setCSRFToken = (req, res, _next) => {
 };
 const registerEmailPassword = async (req, res, _next) => {
   const { user } = res.locals;
+  const { callBack_url } = req.query;
   if (user) {
     import_errors.ErrorHandler.handleGenericErrorResponse(res, "USER_ALREADY_LOGGED_IN");
     return;
   }
+  if (callBack_url && !callBack_url.startsWith(process.env.CLIENT_URL ?? "")) {
+    import_errors.ErrorHandler.handleGenericErrorResponse(res, "CALLBACK_URL_NOT_VALID");
+    return;
+  }
   const userData = req.body;
   try {
     let user2 = await userService.getUserByEmail(userData.email);
@@ -78,22 +88,18 @@ const registerEmailPassword = async (req, res, _next) => {
       const emailProvider = user2.provider?.find(
         (provider) => provider.provider === "email"
       );
-      if (emailProvider) {
-        if (emailProvider.emailValidated) {
-          import_errors.ErrorHandler.handleGenericErrorResponse(
-            res,
-            "EMAIL_ALREADY_VALIDATED"
-          );
-          return;
-        } else {
-          user2 = await sessionAuthService.updateUserProvider(
-            user2._id,
-            "email",
-            {
-              secret: (0, import_uuid.v4)()
-            }
-          );
-        }
+      if (emailProvider?.emailValidated) {
+        import_errors.ErrorHandler.handleGenericErrorResponse(
+          res,
+          "EMAIL_ALREADY_REGISTERED"
+        );
+        return;
+      } else if (emailProvider) {
+        user2 = await sessionAuthService.updateUserProvider(user2._id, "email", {
+          provider: "email",
+          emailValidated: void 0,
+          secret: (0, import_uuid.v4)()
+        });
       } else {
         user2 = await sessionAuthService.addUserProvider(user2._id, {
           provider: "email",
@@ -102,7 +108,16 @@ const registerEmailPassword = async (req, res, _next) => {
         });
       }
     } else {
-      user2 = await userService.createUser(userData);
+      user2 = await userService.createUser({
+        ...userData,
+        provider: [
+          {
+            provider: "email",
+            emailValidated: void 0,
+            secret: (0, import_uuid.v4)()
+          }
+        ]
+      });
       import_logger.logger.info(`New registration: ${user2.name} - ${user2.email}`);
     }
     if (!user2) {
@@ -111,9 +126,30 @@ const registerEmailPassword = async (req, res, _next) => {
       });
       return;
     }
-    await sessionAuthService.setUserAuth(res, user2);
+    await (0, import_email.sendEmail)({
+      type: "validate",
+      to: user2.email,
+      username: user2.name ?? user2.email.split("@")[0],
+      validationLink: import_sessionAuth.sessionAuthRoutes.validEmail.url({
+        userId: String(user2._id),
+        secret: user2.provider?.find((provider) => provider.provider === "email")?.secret ?? "",
+        callBack_url
+      })
+    });
     const formattedUser = (0, import_user.mapUserToAPI)(user2);
-    const responseData = (0, import_responseData.formatResponse)({ data: formattedUser });
+    const responseData = (0, import_responseData.formatResponse)({
+      message: (0, import_express_intlayer.t)({
+        en: "User registered successfully",
+        fr: "Utilisateur enregistr\xE9 avec succ\xE8s",
+        es: "Usuario registrado con \xE9xito"
+      }),
+      description: (0, import_express_intlayer.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) {
@@ -142,7 +178,19 @@ const loginEmailPassword = async (req, res, _next) => {
     }
     await sessionAuthService.setUserAuth(res, loggedInUser);
     const formattedUser = (0, import_user.mapUserToAPI)(loggedInUser);
-    const responseData = (0, import_responseData.formatResponse)({ data: formattedUser });
+    const responseData = (0, import_responseData.formatResponse)({
+      message: (0, import_express_intlayer.t)({
+        en: "User logged in successfully",
+        fr: "Utilisateur connect\xE9 avec succ\xE8s",
+        es: "Usuario conectado con \xE9xito"
+      }),
+      description: (0, import_express_intlayer.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
+    });
     import_logger.logger.info(`Login: ${loggedInUser.email}`);
     res.json(responseData);
     return;
@@ -161,7 +209,19 @@ const logOut = async (_req, res, _next) => {
   sessionAuthService.clearOrganizationAuth(res);
   sessionAuthService.clearProjectAuth(res);
   import_logger.logger.info(`Logout: ${user.name} - ${user.email}`);
-  const responseData = (0, import_responseData.formatResponse)({ data: void 0 });
+  const responseData = (0, import_responseData.formatResponse)({
+    message: (0, import_express_intlayer.t)({
+      en: "User logged out successfully",
+      fr: "Utilisateur d\xE9connect\xE9 avec succ\xE8s",
+      es: "Usuario desconectado con \xE9xito"
+    }),
+    description: (0, import_express_intlayer.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) => {
@@ -171,20 +231,34 @@ const updatePassword = async (req, res, _next) => {
     import_errors.ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_DEFINED");
     return;
   }
-  try {
-    const { error } = await sessionAuthService.testUserPassword(
-      user.email,
-      oldPassword
+  const userEmailProvider = user.provider?.find(
+    (provider) => provider.provider === "email"
+  );
+  if (!userEmailProvider) {
+    import_errors.ErrorHandler.handleGenericErrorResponse(res, "USER_PROVIDER_NOT_FOUND", {
+      provider: "email"
+    });
+    return;
+  }
+  if (userEmailProvider.passwordHash && !oldPassword) {
+    import_errors.ErrorHandler.handleGenericErrorResponse(
+      res,
+      "USER_PREVIOUS_PASSWORD_NOT_PROVIDED"
     );
-    if (error) {
-      import_errors.ErrorHandler.handleGenericErrorResponse(res, "LOGIN_FAILED");
-      return;
+    return;
+  }
+  try {
+    if (oldPassword) {
+      const { error } = await sessionAuthService.testUserPassword(
+        user.email,
+        oldPassword
+      );
+      if (error) {
+        import_errors.ErrorHandler.handleGenericErrorResponse(res, "LOGIN_FAILED");
+        return;
+      }
     }
-    user = await sessionAuthService.changeUserPassword(
-      user._id,
-      oldPassword,
-      newPassword
-    );
+    user = await sessionAuthService.changeUserPassword(user._id, newPassword);
     if (!user || typeof user !== "object") {
       import_errors.ErrorHandler.handleGenericErrorResponse(res, "USER_DATA_NOT_FOUND");
       return;
@@ -193,7 +267,65 @@ const updatePassword = async (req, res, _next) => {
       `Password changed - User : Name : ${user.name}, id : ${String(user._id)}`
     );
     const formattedUser = (0, import_user.mapUserToAPI)(user);
-    const responseData = (0, import_responseData.formatResponse)({ data: formattedUser });
+    const responseData = (0, import_responseData.formatResponse)({
+      message: (0, import_express_intlayer.t)({
+        en: "Password changed successfully",
+        fr: "Mot de passe modifi\xE9 avec succ\xE8s",
+        es: "Contrase\xF1a cambiada con \xE9xito"
+      }),
+      description: (0, import_express_intlayer.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) {
+    import_errors.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) {
+    import_errors.ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_DEFINED");
+    return;
+  }
+  try {
+    const userProvider = user.provider?.find(
+      (provider) => provider.provider === "email"
+    );
+    const responseData = (0, import_responseData.formatResponse)({
+      data: {
+        hasPassword: Boolean(userProvider?.passwordHash)
+      }
+    });
     res.json(responseData);
     return;
   } catch (error) {
@@ -203,15 +335,11 @@ const updatePassword = async (req, res, _next) => {
 };
 const validEmail = async (req, res, _next) => {
   const { userId, secret } = req.params;
-  const { organization } = res.locals;
+  const callBack_url = `${req.query.callBack_url ?? `${process.env.CLIENT_URL}/auth/login`}?userId=${userId}`;
   if (!import_mongoose.Types.ObjectId.isValid(userId.toString())) {
     import_errors.ErrorHandler.handleGenericErrorResponse(res, "INVALID_USER_ID");
     return;
   }
-  if (!organization) {
-    import_errors.ErrorHandler.handleGenericErrorResponse(res, "ORGANIZATION_NOT_DEFINED");
-    return;
-  }
   const user = await userService.getUserById(userId);
   if (!user) {
     import_errors.ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_DEFINED", {
@@ -219,19 +347,63 @@ const validEmail = async (req, res, _next) => {
     });
     return;
   }
-  await sessionAuthService.activateUser(user._id, secret);
+  if (callBack_url && !callBack_url.startsWith(process.env.CLIENT_URL ?? "")) {
+    import_errors.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 import_errors.GenericError("USER_PROVIDER_SECRET_NOT_DEFINED", { userId });
+  }
+  if (!import_crypto.default.timingSafeEqual(Buffer.from(provider.secret), Buffer.from(secret))) {
+    throw new import_errors.GenericError("USER_PROVIDER_SECRET_NOT_VALID", { userId });
+  }
+  await sessionAuthService.updateUserProvider(userId, "email", {
+    secret: void 0,
+    emailValidated: /* @__PURE__ */ new Date()
+  });
   import_logger.logger.info(
     `User activated - User: Name: ${user.name}, id: ${String(user._id)}`
   );
+  sendVerificationUpdate(user);
+  await sessionAuthService.setUserAuth(res, user);
   await (0, import_email.sendEmail)({
     type: "welcome",
     to: user.email,
     username: user.name,
-    loginLink: import_sessionAuth.sessionAuthRoutes.loginEmailPassword.url
+    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) {
+    import_logger.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 formattedUser = (0, import_user.mapUserToAPI)(user);
-  const responseData = (0, import_responseData.formatResponse)({ data: formattedUser });
-  res.json(responseData);
 };
 const askResetPassword = async (req, res, _next) => {
   const { email } = req.body;
@@ -259,7 +431,19 @@ const askResetPassword = async (req, res, _next) => {
         )?.secret ?? ""
       })
     });
-    const responseData = (0, import_responseData.formatResponse)({ data: void 0 });
+    const responseData = (0, import_responseData.formatResponse)({
+      message: (0, import_express_intlayer.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: (0, import_express_intlayer.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) {
@@ -294,7 +478,19 @@ const resetPassword = async (req, res, _next) => {
       username: updatedUser.name
     });
     const formattedUser = (0, import_user.mapUserToAPI)(updatedUser);
-    const responseData = (0, import_responseData.formatResponse)({ data: formattedUser });
+    const responseData = (0, import_responseData.formatResponse)({
+      message: (0, import_express_intlayer.t)({
+        en: "Password reset successfully",
+        fr: "R\xE9initialisation du mot de passe r\xE9ussie",
+        es: "Restablecimiento de contrase\xF1a exitoso"
+      }),
+      description: (0, import_express_intlayer.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) {
@@ -310,15 +506,19 @@ const getSessionInformation = async (req, res, _next) => {
     if (sessionToken) {
       user = await userService.getUserBySession(sessionToken);
     }
-    if (!user) {
-      import_errors.ErrorHandler.handleGenericErrorResponse(res, "USER_NOT_DEFINED");
+    if (!user || !user?.session) {
+      const responseData2 = (0, import_responseData.formatResponse)({
+        data: {
+          session: null,
+          user: null,
+          organization: organization?._id ? (0, import_organization.mapOrganizationToAPI)(organization, isOrganizationAdmin) : null,
+          project: project?._id ? (0, import_project.mapProjectToAPI)(project, user, isProjectAdmin) : null
+        }
+      });
+      res.json(responseData2);
       return;
     }
     const session = user.session;
-    if (!session) {
-      import_errors.ErrorHandler.handleGenericErrorResponse(res, "SESSION_NOT_FOUND");
-      return;
-    }
     const formattedUser = {
       ...(0, import_user.mapUserToAPI)(user),
       role: "user"
@@ -345,11 +545,15 @@ const githubLoginQuery = (req, res, _next) => {
     import_errors.ErrorHandler.handleGenericErrorResponse(res, "USER_ALREADY_LOGGED_IN");
     return;
   }
+  if (origin && !origin.startsWith(process.env.CLIENT_URL ?? "")) {
+    import_errors.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}`
+    `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) => {
@@ -366,6 +570,10 @@ const githubCallback = async (req, res, _next) => {
     res.redirect(redirect_uri);
     return;
   }
+  if (redirect_uri && !redirect_uri.startsWith(process.env.CLIENT_URL ?? "")) {
+    import_errors.ErrorHandler.handleGenericErrorResponse(res, "CALLBACK_URL_NOT_VALID");
+    return;
+  }
   try {
     const tokenResponse = await fetch(
       "https://github.com/login/oauth/access_token",
@@ -463,7 +671,7 @@ const githubCallback = async (req, res, _next) => {
       type: "welcome",
       to: user.email,
       username: user.name,
-      loginLink: import_sessionAuth.sessionAuthRoutes.loginEmailPassword.url
+      loginLink: `${process.env.CLIENT_URL}/auth/login`
     });
     res.redirect(redirect_uri);
   } catch (error) {
@@ -480,6 +688,10 @@ const googleLoginQuery = (req, res, _next) => {
     res.redirect(origin);
     return;
   }
+  if (origin && !origin.startsWith(process.env.CLIENT_URL ?? "")) {
+    import_errors.ErrorHandler.handleGenericErrorResponse(res, "CALLBACK_URL_NOT_VALID");
+    return;
+  }
   const responseType = "code";
   const scope = [
     "https%3A//www.googleapis.com/auth/userinfo.email",
@@ -511,6 +723,10 @@ const googleCallback = async (req, res, _next) => {
     res.redirect(responseCode, redirect_uri);
     return;
   }
+  if (redirect_uri && !redirect_uri.startsWith(process.env.CLIENT_URL ?? "")) {
+    import_errors.ErrorHandler.handleGenericErrorResponse(res, "CALLBACK_URL_NOT_VALID");
+    return;
+  }
   try {
     const tokenResponse = await fetch("https://oauth2.googleapis.com/token", {
       method: "POST",
@@ -599,8 +815,9 @@ const googleCallback = async (req, res, _next) => {
       type: "welcome",
       to: user.email,
       username: user.name,
-      loginLink: import_sessionAuth.sessionAuthRoutes.loginEmailPassword.url
+      loginLink: `${process.env.CLIENT_URL}/auth/login`
     });
+    res.redirect(redirect_uri);
   } catch (error) {
     import_errors.ErrorHandler.handleAppErrorResponse(res, error);
     return;
@@ -609,6 +826,7 @@ const googleCallback = async (req, res, _next) => {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   askResetPassword,
+  checkIfUserHasPassword,
   getSessionInformation,
   githubCallback,
   githubLoginQuery,
@@ -618,8 +836,10 @@ const googleCallback = async (req, res, _next) => {
   loginEmailPassword,
   registerEmailPassword,
   resetPassword,
+  sendVerificationUpdate,
   setCSRFToken,
   updatePassword,
-  validEmail
+  validEmail,
+  verifyEmailStatusSSE
 });
 //# sourceMappingURL=sessionAuth.controller.cjs.map