Remove transactions from delete organization, workspace, user

backend/src/helpers/organization.ts

@@ -1,4 +1,4 @@
-import mongoose, { Types, mongo } from "mongoose";
+import { Types } from "mongoose";
 import { 
   Bot, 
   BotKey,
@@ -55,7 +55,7 @@ import {
 import {
   createBotOrg
 } from "./botOrg";
-import { InternalServerError, ResourceNotFoundError } from "../utils/errors";
+import { ResourceNotFoundError } from "../utils/errors";
 
 /**
  * Create an organization with name [name]
@@ -111,78 +111,47 @@ export const createOrganization = async ({
  * @returns 
  */
 export const deleteOrganization = async ({
-  organizationId,
+  organizationId
-  existingSession
 }: {
   organizationId: Types.ObjectId;
-  existingSession?: mongo.ClientSession;
 }) => {
 
-  let session;
-  
-  if (existingSession) {
-    session = existingSession;
-  } else {
-    session = await mongoose.startSession(); 
-    session.startTransaction();
-  }
-
-  try {
   const organization = await Organization.findByIdAndDelete(
-      organizationId,
+    organizationId
-      {
-        session
-      }
   );
 
   if (!organization) throw ResourceNotFoundError();
   
   await MembershipOrg.deleteMany({
     organization: organization._id
-    }, {
-      session
   });
   
   await BotOrg.deleteMany({
     organization: organization._id
-    }, {
-      session
   });
   
   await SSOConfig.deleteMany({
     organization: organization._id
-    }, {
-      session
   });
   
   await Role.deleteMany({
     organization: organization._id
-    }, {
-      session
   });
 
   await IncidentContactOrg.deleteMany({
     organization: organization._id
-    }, {
-      session
   });
   
   await GitRisks.deleteMany({
     organization: organization._id
-    }, {
-      session
   });
   
   await GitAppInstallationSession.deleteMany({
     organization: organization._id
-    }, {
-      session
   });
   
   await GitAppOrganizationInstallation.deleteMany({
     organization: organization._id
-    }, {
-      session
   });
 
   const workspaceIds = await Workspace.distinct("_id", {
@@ -191,208 +160,156 @@ export const deleteOrganization = async ({
   
   await Workspace.deleteMany({
     organization: organization._id
-    }, {
-      session
   });
   
   await Membership.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await Key.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
   
   await Bot.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
   
   await BotKey.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await SecretBlindIndexData.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
   
   await Secret.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
   
   await SecretVersion.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await SecretSnapshot.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
   
   await SecretImport.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await Folder.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await FolderVersion.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await Webhook.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await TrustedIP.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
   
   await Tag.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await IntegrationAuth.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await Integration.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await ServiceToken.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await ServiceTokenData.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await ServiceTokenDataV3.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
   
   await ServiceTokenDataV3Key.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await AuditLog.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await Log.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await Action.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await SecretApprovalPolicy.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
 
   await SecretApprovalRequest.deleteMany({
     workspace: {
       $in: workspaceIds
     }
-    }, {
-      session
   });
   
   if (organization.customerId) {
@@ -403,19 +320,6 @@ export const deleteOrganization = async ({
   }
     
   return organization;
-  } catch (err) {
-    if (!existingSession) {
-      await session.abortTransaction();
-    }
-    throw InternalServerError({
-      message: "Failed to delete organization"
-    });
-  } finally {
-    if (!existingSession) {
-      await session.commitTransaction();
-      session.endSession();
-    }
-  }
 }
 
 /**

backend/src/helpers/user.ts

@@ -1,4 +1,4 @@
-import mongoose, { Types, mongo } from "mongoose";
+import { Types } from "mongoose";
 import {
   APIKeyData, 
   BackupPrivateKey,
@@ -222,26 +222,12 @@ const checkDeleteUserConditions = async ({
  * @returns {User} user - deleted user
  */
 export const deleteUser = async ({
-  userId,
+  userId
-  existingSession
 }: {
   userId: Types.ObjectId;
-	existingSession?: mongo.ClientSession;
 }) => {
 
-  let session;
+  const user = await User.findByIdAndDelete(userId);
-  
-  if (existingSession) {
-    session = existingSession;
-  } else {
-    session = await mongoose.startSession();
-    session.startTransaction();
-  }
-
-  try {
-    const user = await User.findByIdAndDelete(userId, {
-      session
-    });
   
   if (!user) throw ResourceNotFoundError();
 
@@ -251,32 +237,22 @@ export const deleteUser = async ({
   
   await UserAction.deleteMany({
     user: user._id
-    }, {
-      session
   });
 
   await BackupPrivateKey.deleteMany({
     user: user._id
-    }, {
-      session
   });
 
   await APIKeyData.deleteMany({
     user: user._id
-    }, {
-      session
   });
 
   await Action.deleteMany({
     user: user._id
-    }, {
-      session
   }); 
   
   await Log.deleteMany({
     user: user._id
-    }, {
-      session
   });
 
   await TokenVersion.deleteMany({
@@ -285,14 +261,10 @@ export const deleteUser = async ({
 
   await Key.deleteMany({
     receiver: user._id
-    }, {
-      session
   });
 
   const membershipOrgs = await MembershipOrg.find({
     user: userId
-    }, null, {
-      session
   });
 
   // delete organizations where user is only member
@@ -305,16 +277,13 @@ export const deleteUser = async ({
       // organization only has 1 member (the current user)
 
       await deleteOrganization({
-          organizationId: membershipOrg.organization,
+        organizationId: membershipOrg.organization
-          existingSession: session
       });
     }
   }
 
   const memberships = await Membership.find({
     user: userId
-    }, null, {
-      session
   });
 
   // delete workspaces where user is only member
@@ -327,36 +296,18 @@ export const deleteUser = async ({
       // workspace only has 1 member (the current user) -> delete workspace
 
       await deleteWorkspace({
-          workspaceId: membership.workspace,
+        workspaceId: membership.workspace
-          existingSession: session
       });
     }
   }
   
   await MembershipOrg.deleteMany({
     user: userId
-    }, {
-      session
   });
   
   await Membership.deleteMany({
     user: userId
-    }, {
-      session
   });
 
   return user;
-  } catch (err) {
-    if (!existingSession) {
-      await session.abortTransaction();
-    }
-    throw InternalServerError({
-      message: "Failed to delete account"
-    })
-  } finally {
-    if (!existingSession) {
-      await session.commitTransaction();
-      session.endSession();
-    }
-  }
 }

backend/src/helpers/workspace.ts

@@ -1,4 +1,4 @@
-import mongoose, { Types, mongo } from "mongoose";
+import { Types } from "mongoose";
 import {
 	Bot,
 	BotKey,
@@ -34,7 +34,6 @@ import { createBot } from "../helpers/bot";
 import { EELicenseService } from "../ee/services";
 import { SecretService } from "../services";
 import {
-	InternalServerError,
 	ResourceNotFoundError
 } from "../utils/errors";
 
@@ -102,189 +101,113 @@ export const createWorkspace = async ({
  * @param {String} obj.id - id of workspace to delete
  */
 export const deleteWorkspace = async ({ 
-	workspaceId,
+	workspaceId
-	existingSession
 }: { 
 	workspaceId: Types.ObjectId;
-	existingSession?: mongo.ClientSession;
 }) => {
-
+	const workspace = await Workspace.findByIdAndDelete(workspaceId);
-	let session;
-
-	if (existingSession) {
-		session = existingSession;
-	} else {
-		session = await mongoose.startSession();
-		session.startTransaction();
-	}
-	
-	try {
-		const workspace = await Workspace.findByIdAndDelete(workspaceId, { session });
 	
 	if (!workspace) throw ResourceNotFoundError();
 	
 	await Membership.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 	
 	await Key.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 	
 	await Bot.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await BotKey.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await SecretBlindIndexData.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await Secret.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 	
 	await SecretVersion.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await SecretSnapshot.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await SecretImport.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await Folder.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await FolderVersion.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await Webhook.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await TrustedIP.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await Tag.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await IntegrationAuth.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await Integration.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await ServiceToken.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await ServiceTokenData.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await ServiceTokenDataV3.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await ServiceTokenDataV3Key.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await AuditLog.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await Log.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await Action.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await SecretApprovalPolicy.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 
 	await SecretApprovalRequest.deleteMany({
 		workspace: workspace._id
-		}, {
-			session
 	});
 	
 	return workspace;
-	} catch (err) {
-		if (!existingSession) {
-			await session.abortTransaction();
-		}
-		throw InternalServerError({
-			message: "Failed to delete organization"
-		});
-	} finally {
-		if (!existingSession) {
-			await session.commitTransaction();
-			session.endSession();
-		}
-	}
 };