Add transaction commits and rollbacks

CrowdDotDev · Aug 6, 2024 · e063f18 · e063f18
1 parent a32f30b
commit e063f18
Showing 1 changed file with 144 additions and 74 deletions.
diff --git a/backend/src/database/repositories/member/memberIdentityRepository.ts b/backend/src/database/repositories/member/memberIdentityRepository.ts
@@ -14,11 +14,22 @@ import SequelizeRepository from '../sequelizeRepository'
 class MemberIdentityRepository {
   static async list(memberId: string, options: IRepositoryOptions) {
     const transaction = await SequelizeRepository.createTransaction(options)
-    const txOptions = { ...options, transaction }
-    const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
+    try {
+      const txOptions = { ...options, transaction }
+      const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
 
-    // List all member identities
-    return fetchMemberIdentities(qx, memberId)
+      // List all member identities
+      const list = await fetchMemberIdentities(qx, memberId)
+
+      await SequelizeRepository.commitTransaction(transaction)
+
+      return list
+    } catch (err) {
+      if (transaction) {
+        await SequelizeRepository.rollbackTransaction(transaction)
+      }
+      throw err
+    }
   }
 
   static async create(
@@ -28,36 +39,58 @@ class MemberIdentityRepository {
     options: IRepositoryOptions,
   ) {
     const transaction = await SequelizeRepository.createTransaction(options)
-    const txOptions = { ...options, transaction }
-    const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
-
-    // Check if identity already exists
-    const existingIdentities = await checkIdentityExistance(qx, data.value, data.platform)
-    if (existingIdentities.length > 0) {
-      throw new Error409(
-        options.language,
-        'errors.alreadyExists',
-        // @ts-ignore
-        JSON.stringify({
-          memberId: existingIdentities[0].memberId,
-        }),
-      )
-    }
+    try {
+      const txOptions = { ...options, transaction }
+      const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
 
-    // Create member identity
-    await createMemberIdentity(qx, tenantId, memberId, data)
+      // Check if identity already exists
+      const existingIdentities = await checkIdentityExistance(qx, data.value, data.platform)
+      if (existingIdentities.length > 0) {
+        throw new Error409(
+          options.language,
+          'errors.alreadyExists',
+          // @ts-ignore
+          JSON.stringify({
+            memberId: existingIdentities[0].memberId,
+          }),
+        )
+      }
 
-    // List all member identities
-    return fetchMemberIdentities(qx, memberId)
+      // Create member identity
+      await createMemberIdentity(qx, tenantId, memberId, data)
+
+      // List all member identities
+      const list = await fetchMemberIdentities(qx, memberId)
+
+      await SequelizeRepository.commitTransaction(transaction)
+
+      return list
+    } catch (err) {
+      if (transaction) {
+        await SequelizeRepository.rollbackTransaction(transaction)
+      }
+      throw err
+    }
   }
 
   static async findById(memberId: string, id: string, options: IRepositoryOptions) {
     const transaction = await SequelizeRepository.createTransaction(options)
-    const txOptions = { ...options, transaction }
-    const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
+    try {
+      const txOptions = { ...options, transaction }
+      const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
+
+      // Create member identity
+      const record = await findMemberIdentityById(qx, memberId, id)
+
+      await SequelizeRepository.commitTransaction(transaction)
 
-    // Create member identity
-    return findMemberIdentityById(qx, memberId, id)
+      return record
+    } catch (err) {
+      if (transaction) {
+        await SequelizeRepository.rollbackTransaction(transaction)
+      }
+      throw err
+    }
   }
 
   static async createMultiple(
@@ -67,32 +100,47 @@ class MemberIdentityRepository {
     options: IRepositoryOptions,
   ) {
     const transaction = await SequelizeRepository.createTransaction(options)
-    const txOptions = { ...options, transaction }
-    const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
+    try {
+      const txOptions = { ...options, transaction }
+      const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
+
+      // Check if any of the identities already exist
+      for (const identity of data) {
+        const existingIdentities = await checkIdentityExistance(
+          qx,
+          identity.value,
+          identity.platform,
+        )
 
-    // Check if any of the identities already exist
-    for (const identity of data) {
-      const existingIdentities = await checkIdentityExistance(qx, identity.value, identity.platform)
+        if (existingIdentities.length > 0) {
+          throw new Error409(
+            options.language,
+            'errors.alreadyExists',
+            // @ts-ignore
+            JSON.stringify({
+              memberId: existingIdentities[0].memberId,
+            }),
+          )
+        }
+      }
 
-      if (existingIdentities.length > 0) {
-        throw new Error409(
-          options.language,
-          'errors.alreadyExists',
-          // @ts-ignore
-          JSON.stringify({
-            memberId: existingIdentities[0].memberId,
-          }),
-        )
+      // Create member identities
+      for (const identity of data) {
+        await createMemberIdentity(qx, tenantId, memberId, identity)
       }
-    }
 
-    // Create member identities
-    for (const identity of data) {
-      await createMemberIdentity(qx, tenantId, memberId, identity)
-    }
+      // List all member identities
+      const list = await fetchMemberIdentities(qx, memberId)
+
+      await SequelizeRepository.commitTransaction(transaction)
 
-    // List all member identities
-    return fetchMemberIdentities(qx, memberId)
+      return list
+    } catch (err) {
+      if (transaction) {
+        await SequelizeRepository.rollbackTransaction(transaction)
+      }
+      throw err
+    }
   }
 
   static async update(
@@ -102,40 +150,62 @@ class MemberIdentityRepository {
     options: IRepositoryOptions,
   ) {
     const transaction = await SequelizeRepository.createTransaction(options)
-    const txOptions = { ...options, transaction }
-    const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
-
-    // Check if identity already exists
-    const existingIdentities = await checkIdentityExistance(qx, data.value, data.platform)
-    const filteredExistingIdentities = existingIdentities.filter((i) => i.id !== id)
-    if (filteredExistingIdentities.length > 0) {
-      throw new Error409(
-        options.language,
-        'errors.alreadyExists',
-        // @ts-ignore
-        JSON.stringify({
-          memberId: filteredExistingIdentities[0].memberId,
-        }),
-      )
-    }
+    try {
+      const txOptions = { ...options, transaction }
+      const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
+
+      // Check if identity already exists
+      const existingIdentities = await checkIdentityExistance(qx, data.value, data.platform)
+      const filteredExistingIdentities = existingIdentities.filter((i) => i.id !== id)
+      if (filteredExistingIdentities.length > 0) {
+        throw new Error409(
+          options.language,
+          'errors.alreadyExists',
+          // @ts-ignore
+          JSON.stringify({
+            memberId: filteredExistingIdentities[0].memberId,
+          }),
+        )
+      }
+
+      // Update member identity with new data
+      await updateMemberIdentity(qx, memberId, id, data)
 
-    // Update member identity with new data
-    await updateMemberIdentity(qx, memberId, id, data)
+      // List all member identities
+      const list = await fetchMemberIdentities(qx, memberId)
 
-    // List all member identities
-    return fetchMemberIdentities(qx, memberId)
+      await SequelizeRepository.commitTransaction(transaction)
+
+      return list
+    } catch (err) {
+      if (transaction) {
+        await SequelizeRepository.rollbackTransaction(transaction)
+      }
+      throw err
+    }
   }
 
   static async delete(id: string, memberId: string, options: IRepositoryOptions) {
     const transaction = await SequelizeRepository.createTransaction(options)
-    const txOptions = { ...options, transaction }
-    const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
+    try {
+      const txOptions = { ...options, transaction }
+      const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
+
+      // Delete member identity
+      await deleteMemberIdentity(qx, memberId, id)
 
-    // Delete member identity
-    await deleteMemberIdentity(qx, memberId, id)
+      // List all member identities
+      const list = await fetchMemberIdentities(qx, memberId)
 
-    // List all member identities
-    return fetchMemberIdentities(qx, memberId)
+      await SequelizeRepository.commitTransaction(transaction)
+
+      return list
+    } catch (err) {
+      if (transaction) {
+        await SequelizeRepository.rollbackTransaction(transaction)
+      }
+      throw err
+    }
   }
 }