feat: almost done with most ts stuff

backend/src/services/org/org-fns.ts

@@ -1,122 +1,59 @@
 import { AccessScope } from "@app/db/schemas";
+import { TUserGroupMembershipDALFactory } from "@app/ee/services/group/user-group-membership-dal";
 import { TLicenseServiceFactory } from "@app/ee/services/license/license-service";
 import { BadRequestError } from "@app/lib/errors";
 import { TOrgDALFactory } from "@app/services/org/org-dal";
 import { TProjectKeyDALFactory } from "@app/services/project-key/project-key-dal";
-import { TProjectMembershipDALFactory } from "@app/services/project-membership/project-membership-dal";
 import { TUserAliasDALFactory } from "@app/services/user-alias/user-alias-dal";
 
+import { TMembershipRoleDALFactory } from "../membership/membership-role-dal";
 import { TMembershipUserDALFactory } from "../membership-user/membership-user-dal";
 
-type TDeleteOrgMembership = {
-  orgMembershipId: string;
-  orgId: string;
-  orgDAL: Pick<TOrgDALFactory, "findMembership" | "deleteMembershipById" | "transaction">;
-  projectMembershipDAL: Pick<TProjectMembershipDALFactory, "findProjectMembershipsByUserId">;
-  membershipUserDAL: Pick<TMembershipUserDALFactory, "delete">;
-  projectKeyDAL: Pick<TProjectKeyDALFactory, "find" | "delete">;
-  userAliasDAL: Pick<TUserAliasDALFactory, "delete">;
-  licenseService: Pick<TLicenseServiceFactory, "updateSubscriptionOrgMemberCount">;
-  userId?: string;
-};
-
 type TDeleteOrgMemberships = {
   orgMembershipIds: string[];
   orgId: string;
-  orgDAL: Pick<TOrgDALFactory, "findMembership" | "deleteMembershipsById" | "transaction">;
-  projectMembershipDAL: Pick<TProjectMembershipDALFactory, "findProjectMembershipsByUserIds">;
-  membershipUserDAL: Pick<TMembershipUserDALFactory, "delete">;
+  orgDAL: Pick<TOrgDALFactory, "transaction">;
+  userGroupMembershipDAL: Pick<TUserGroupMembershipDALFactory, "delete">;
+  membershipUserDAL: Pick<TMembershipUserDALFactory, "delete" | "find">;
+  membershipRoleDAL: Pick<TMembershipRoleDALFactory, "delete">;
   projectKeyDAL: Pick<TProjectKeyDALFactory, "find" | "delete">;
   userAliasDAL: Pick<TUserAliasDALFactory, "delete">;
   licenseService: Pick<TLicenseServiceFactory, "updateSubscriptionOrgMemberCount">;
   userId?: string;
 };
 
-export const deleteOrgMembershipFn = async ({
-  orgMembershipId,
-  orgId,
-  orgDAL,
-  projectMembershipDAL,
-  projectKeyDAL,
-  userAliasDAL,
-  licenseService,
-  userId,
-  membershipUserDAL
-}: TDeleteOrgMembership) => {
-  const deletedMembership = await orgDAL.transaction(async (tx) => {
-    const orgMembership = await orgDAL.deleteMembershipById(orgMembershipId, orgId, tx);
-
-    if (userId && orgMembership.actorUserId === userId) {
-      // scott: this is temporary, we will add a leave org endpoint with proper handling to ensure org isn't abandoned/broken
-      throw new BadRequestError({ message: "You cannot remove yourself from an organization" });
-    }
-
-    const deletedUserId = orgMembership.actorUserId;
-    if (!deletedUserId) {
-      await licenseService.updateSubscriptionOrgMemberCount(orgId);
-      return orgMembership;
-    }
-
-    await userAliasDAL.delete(
-      {
-        userId: deletedUserId,
-        orgId
-      },
-      tx
-    );
-
-    // Get all the project memberships of the user in the organization
-    const projectMemberships = await projectMembershipDAL.findProjectMembershipsByUserId(orgId, deletedUserId);
-
-    // Delete all the project memberships of the user in the organization
-    await membershipUserDAL.delete(
-      {
-        scope: AccessScope.Project,
-        $in: {
-          id: projectMemberships.map((membership) => membership.id)
-        }
-      },
-      tx
-    );
-
-    // Get all the project keys of the user in the organization
-    const projectKeys = await projectKeyDAL.find({
-      $in: {
-        projectId: projectMemberships.map((membership) => membership.projectId)
-      },
-      receiverId: deletedUserId
-    });
-
-    // Delete all the project keys of the user in the organization
-    await projectKeyDAL.delete(
-      {
-        $in: {
-          id: projectKeys.map((key) => key.id)
-        }
-      },
-      tx
-    );
-
-    await licenseService.updateSubscriptionOrgMemberCount(orgId);
-    return orgMembership;
-  });
-
-  return deletedMembership;
-};
-
 export const deleteOrgMembershipsFn = async ({
   orgMembershipIds,
   orgId,
   orgDAL,
-  projectMembershipDAL,
   projectKeyDAL,
   userAliasDAL,
   licenseService,
   userId,
-  membershipUserDAL
+  membershipUserDAL,
+  userGroupMembershipDAL,
+  membershipRoleDAL
 }: TDeleteOrgMemberships) => {
   const deletedMemberships = await orgDAL.transaction(async (tx) => {
-    const orgMemberships = await orgDAL.deleteMembershipsById(orgMembershipIds, orgId, tx);
+    await membershipRoleDAL.delete(
+      {
+        $in: {
+          membershipId: orgMembershipIds
+        }
+      },
+      tx
+    );
+
+    const orgMemberships = await membershipUserDAL.delete(
+      {
+        scopeOrgId: orgId,
+        scope: AccessScope.Organization,
+        $in: {
+          id: orgMembershipIds
+        }
+      },
+      tx
+    );
 
     const membershipUserIds = orgMemberships
       .filter((member) => Boolean(member.actorUserId))
@@ -143,32 +80,44 @@ export const deleteOrgMembershipsFn = async ({
     );
 
     // Get all the project memberships of the users in the organization
-    const projectMemberships = await projectMembershipDAL.findProjectMembershipsByUserIds(orgId, membershipUserIds);
 
     // Delete all the project memberships of the users in the organization
-    await membershipUserDAL.delete(
+    const otherMemberships = await membershipUserDAL.delete(
       {
-        scope: AccessScope.Project,
+        scopeOrgId: orgId,
         $in: {
-          id: projectMemberships.map((membership) => membership.id)
+          actorUserId: membershipUserIds
         }
       },
       tx
     );
 
-    // Get all the project keys of the user in the organization
-    const projectKeys = await projectKeyDAL.find({
-      $in: {
-        projectId: projectMemberships.map((membership) => membership.projectId),
-        receiverId: membershipUserIds
-      }
+    const orgGroups = await membershipUserDAL.find({
+      scopeOrgId: orgId,
+      $notNull: ["actorGroupId"]
     });
 
+    const groupIds = orgGroups.filter((el) => el.actorGroupId).map((el) => el.actorGroupId as string);
+
+    await userGroupMembershipDAL.delete(
+      {
+        $in: {
+          userId: membershipUserIds,
+          groupId: groupIds
+        }
+      },
+      tx
+    );
+    const projectIds = otherMemberships
+      .filter((el) => el.scope === AccessScope.Project && el.scopeProjectId)
+      .map((el) => el.scopeProjectId as string);
+
     // Delete all the project keys of the user in the organization
     await projectKeyDAL.delete(
       {
         $in: {
-          id: projectKeys.map((key) => key.id)
+          projectId: projectIds,
+          receiverId: membershipUserIds
         }
       },
       tx