Continue merge user

backend/src/ee/services/license/licence-fns.ts

@@ -26,8 +26,8 @@ export const getDefaultOnPremFeatures = (): TFeatureSet => ({
   auditLogsRetentionDays: 0,
   samlSSO: true,
   scim: true,
-  ldap: false,
-  groups: false,
+  ldap: true,
+  groups: true,
   status: null,
   trial_end: null,
   has_used_trial: true,

backend/src/ee/services/saml-config/saml-config-service.ts

@@ -23,6 +23,7 @@ import { AuthMethod, AuthTokenType } from "@app/services/auth/auth-type";
 import { TOrgBotDALFactory } from "@app/services/org/org-bot-dal";
 import { TOrgDALFactory } from "@app/services/org/org-dal";
 import { TUserDALFactory } from "@app/services/user/user-dal";
+import { TUserAliasDALFactory } from "@app/services/user-alias/user-alias-dal";
 
 import { TLicenseServiceFactory } from "../license/license-service";
 import { OrgPermissionActions, OrgPermissionSubjects } from "../permission/org-permission";
@@ -33,6 +34,7 @@ import { TCreateSamlCfgDTO, TGetSamlCfgDTO, TSamlLoginDTO, TUpdateSamlCfgDTO } f
 type TSamlConfigServiceFactoryDep = {
   samlConfigDAL: TSamlConfigDALFactory;
   userDAL: Pick<TUserDALFactory, "create" | "findOne" | "transaction" | "updateById">;
+  userAliasDAL: Pick<TUserAliasDALFactory, "create" | "findOne">;
   orgDAL: Pick<
     TOrgDALFactory,
     "createMembership" | "updateMembershipById" | "findMembership" | "findOrgById" | "findOne" | "updateById"
@@ -360,6 +362,7 @@ export const samlConfigServiceFactory = ({
           {
             username,
             email,
+            isEmailVerified: false,
             firstName,
             lastName,
             authMethods: [AuthMethod.EMAIL],
@@ -382,6 +385,7 @@ export const samlConfigServiceFactory = ({
         authTokenType: AuthTokenType.PROVIDER_TOKEN,
         userId: user.id,
         username: user.username,
+        ...(user.email && { email: user.email }),
         firstName,
         lastName,
         organizationName: organization.name,

backend/src/server/routes/index.ts

@@ -86,6 +86,7 @@ import { orgDALFactory } from "@app/services/org/org-dal";
 import { orgRoleDALFactory } from "@app/services/org/org-role-dal";
 import { orgRoleServiceFactory } from "@app/services/org/org-role-service";
 import { orgServiceFactory } from "@app/services/org/org-service";
+import { orgMembershipDALFactory } from "@app/services/org-membership/org-membership-dal";
 import { projectDALFactory } from "@app/services/project/project-dal";
 import { projectQueueFactory } from "@app/services/project/project-queue";
 import { projectServiceFactory } from "@app/services/project/project-service";
@@ -153,6 +154,7 @@ export const registerRoutes = async (
   const authDAL = authDALFactory(db);
   const authTokenDAL = tokenDALFactory(db);
   const orgDAL = orgDALFactory(db);
+  const orgMembershipDAL = orgMembershipDALFactory(db);
   const orgBotDAL = orgBotDALFactory(db);
   const incidentContactDAL = incidentContactDALFactory(db);
   const orgRoleDAL = orgRoleDALFactory(db);
@@ -328,7 +330,14 @@ export const registerRoutes = async (
   });
 
   const tokenService = tokenServiceFactory({ tokenDAL: authTokenDAL, userDAL });
-  const userService = userServiceFactory({ userDAL, tokenService, smtpService });
+  const userService = userServiceFactory({
+    userDAL,
+    userAliasDAL,
+    orgDAL,
+    orgMembershipDAL,
+    tokenService,
+    smtpService
+  });
   const loginService = authLoginServiceFactory({ userDAL, smtpService, tokenService, orgDAL, tokenDAL: authTokenDAL });
   const passwordService = authPaswordServiceFactory({
     tokenService,

backend/src/server/routes/v2/user-router.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 
 import { AuthTokenSessionsSchema, OrganizationsSchema, UserEncryptionKeysSchema, UsersSchema } from "@app/db/schemas";
 import { ApiKeysSchema } from "@app/db/schemas/api-keys";
+import { getConfig } from "@app/lib/config/env";
 import { authRateLimit, readLimit, writeLimit } from "@app/server/config/rateLimiter";
 import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
 import { AuthMethod, AuthMode } from "@app/services/auth/auth-type";
@@ -68,6 +69,38 @@ export const registerUserRouter = async (server: FastifyZodProvider) => {
     }
   });
 
+  server.route({
+    method: "POST",
+    url: "/me/users/merge-user",
+    config: {
+      rateLimit: writeLimit
+    },
+    schema: {
+      body: z.object({
+        username: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          user: UsersSchema
+        })
+      }
+    },
+    preHandler: verifyAuth([AuthMode.JWT]),
+    handler: async (req, res) => {
+      const appCfg = getConfig();
+      const user = await server.services.user.mergeUsers(req.permission.id, req.body.username);
+      void res.cookie("jid", "", {
+        httpOnly: true,
+        path: "/",
+        sameSite: "strict",
+        secure: appCfg.HTTPS_ENABLED
+      });
+      return {
+        user
+      };
+    }
+  });
+
   server.route({
     method: "PATCH",
     url: "/me/mfa",

backend/src/services/auth-token/auth-token-service.ts

@@ -30,13 +30,14 @@ export const getTokenConfig = (tokenType: TokenType) => {
     case TokenType.TOKEN_EMAIL_VERIFICATION: {
       // generate random 6-digit code
       const token = String(crypto.randomInt(10 ** 5, 10 ** 6 - 1));
+      const triesLeft = 3;
       const expiresAt = new Date(new Date().getTime() + 86400000);
-      return { token, expiresAt };
+      return { token, triesLeft, expiresAt };
     }
     case TokenType.TOKEN_EMAIL_MFA: {
       // generate random 6-digit code
       const token = String(crypto.randomInt(10 ** 5, 10 ** 6 - 1));
-      const triesLeft = 5;
+      const triesLeft = 3;
       const expiresAt = new Date(new Date().getTime() + 300000);
       return { token, triesLeft, expiresAt };
     }

backend/src/services/org-membership/org-membership-dal.ts

@@ -0,0 +1,13 @@
+import { TDbClient } from "@app/db";
+import { TableName } from "@app/db/schemas";
+import { ormify } from "@app/lib/knex";
+
+export type TOrgMembershipDALFactory = ReturnType<typeof orgMembershipDALFactory>;
+
+export const orgMembershipDALFactory = (db: TDbClient) => {
+  const orgMembershipOrm = ormify(db, TableName.OrgMembership);
+
+  return {
+    ...orgMembershipOrm
+  };
+};

backend/src/services/user/user-service.ts

@@ -1,20 +1,34 @@
 import { BadRequestError } from "@app/lib/errors";
 import { TAuthTokenServiceFactory } from "@app/services/auth-token/auth-token-service";
 import { TokenType } from "@app/services/auth-token/auth-token-types";
+import { TOrgDALFactory } from "@app/services/org/org-dal";
+import { TOrgMembershipDALFactory } from "@app/services/org-membership/org-membership-dal";
 import { SmtpTemplates, TSmtpService } from "@app/services/smtp/smtp-service";
+import { TUserAliasDALFactory } from "@app/services/user-alias/user-alias-dal";
 
 import { AuthMethod } from "../auth/auth-type";
 import { TUserDALFactory } from "./user-dal";
 
+// TODO: Pick all of these
 type TUserServiceFactoryDep = {
   userDAL: TUserDALFactory;
+  userAliasDAL: TUserAliasDALFactory;
+  orgDAL: TOrgDALFactory;
+  orgMembershipDAL: TOrgMembershipDALFactory;
   tokenService: TAuthTokenServiceFactory;
   smtpService: TSmtpService;
 };
 
 export type TUserServiceFactory = ReturnType<typeof userServiceFactory>;
 
-export const userServiceFactory = ({ userDAL, tokenService, smtpService }: TUserServiceFactoryDep) => {
+export const userServiceFactory = ({
+  userDAL,
+  userAliasDAL,
+  // orgDAL,
+  orgMembershipDAL,
+  tokenService,
+  smtpService
+}: TUserServiceFactoryDep) => {
   const sendEmailVerificationCode = async (userId: string) => {
     console.log("sendEmailVerificationCode userId: ", userId);
     const user = await userDAL.findById(userId);
@@ -78,6 +92,68 @@ export const userServiceFactory = ({ userDAL, tokenService, smtpService }: TUser
     return users;
   };
 
+  /**
+   * Merges two users with the same email. Specifically:
+   * - Deletes the current user with id [userId] and transfers any resources to the user with username [username]
+   * @param userId
+   * @param username
+   */
+  const mergeUsers = async (userId: string, username: string) => {
+    const targetUser = await userDAL.transaction(async (tx) => {
+      const myUser = await userDAL.findById(userId, tx);
+      if (!myUser || !myUser.isEmailVerified) throw new BadRequestError({});
+
+      const mergeUser = await userDAL.findOne(
+        {
+          username
+        },
+        tx
+      );
+      if (!mergeUser || !mergeUser.isEmailVerified) throw new BadRequestError({});
+
+      if (myUser.email !== mergeUser.email) throw new BadRequestError({});
+
+      const mergeUserOrgMembershipSet = new Set(
+        (await orgMembershipDAL.find({ userId: mergeUser.id }, { tx })).map((m) => m.orgId)
+      );
+      const myOrgMemberships = (await orgMembershipDAL.find({ userId: myUser.id }, { tx })).filter(
+        (m) => !mergeUserOrgMembershipSet.has(m.orgId)
+      );
+
+      const userAliases = await userAliasDAL.find(
+        {
+          userId: myUser.id
+        },
+        { tx }
+      );
+      await userDAL.deleteById(myUser.id, tx);
+
+      if (myOrgMemberships.length) {
+        await orgMembershipDAL.insertMany(
+          myOrgMemberships.map((orgMembership) => ({
+            ...orgMembership,
+            userId: mergeUser.id
+          })),
+          tx
+        );
+      }
+
+      if (userAliases.length) {
+        await userAliasDAL.insertMany(
+          userAliases.map((userAlias) => ({
+            ...userAlias,
+            userId: mergeUser.id
+          })),
+          tx
+        );
+      }
+
+      return mergeUser;
+    });
+
+    return targetUser;
+  };
+
   const toggleUserMfa = async (userId: string, isMfaEnabled: boolean) => {
     const user = await userDAL.findById(userId);
 
@@ -143,6 +219,7 @@ export const userServiceFactory = ({ userDAL, tokenService, smtpService }: TUser
     sendEmailVerificationCode,
     verifyEmailVerificationCode,
     listUsersWithSameEmail,
+    mergeUsers,
     toggleUserMfa,
     updateUserName,
     updateAuthMethods,