chore: make all DB update/create operations atomic (#59)

alcaprar · Jul 26, 2024 · 4f372a1 · 4f372a1
1 parent a398420
commit 4f372a1
Show file tree

Hide file tree

Showing 9 changed files with 218 additions and 167 deletions.
diff --git a/backend/.tmp/dev.data.db b/backend/.tmp/dev.data.db
diff --git a/backend/src/api/client/controllers/client.ts b/backend/src/api/client/controllers/client.ts
@@ -9,39 +9,43 @@ export default factories.createCoreController('api::client.client', {
         const { data } = ctx.request.body
         const shopId = data.shop;
 
-        const clientEntity = await strapi.entityService.create('api::client.client', {
-            data: data
-        })
 
-        // If there is already a sale open we should create the order for this new client
-        const now = new Date();
-        const saleOpenNow = await strapi.db.query('api::sale.sale').findOne({
-            where: { shop: shopId, startDate: { $lt: now }, endDate: { $gt: now } },
-            orderBy: { endDate: 'desc' }
-        });
-
-        if (saleOpenNow != null) {
-            let orderEntity = await strapi.entityService.create('api::order.order', {
-                data: {
-                    sale: saleOpenNow.id,
-                    client: clientEntity.id
-                }
+        return await strapi.db.transaction(async ({ trx, rollback, commit, onCommit, onRollback }) => {
+            const clientEntity = await strapi.entityService.create('api::client.client', {
+                data: data
             })
 
-            let productsSaleEntity = await strapi.db.query('api::product-sale.product-sale').findMany({
-                where: { sale: saleOpenNow.id }
+            // If there is already a sale open we should create the order for this new client
+            const now = new Date();
+            const saleOpenNow = await strapi.db.query('api::sale.sale').findOne({
+                where: { shop: shopId, startDate: { $lt: now }, endDate: { $gt: now } },
+                orderBy: { endDate: 'desc' }
             });
-            for (let productSale of productsSaleEntity) {
-                await strapi.entityService.create('api::order-item.order-item', {
+
+            if (saleOpenNow != null) {
+                let orderEntity = await strapi.entityService.create('api::order.order', {
                     data: {
-                        product_sale: productSale.id,
-                        quantity: 0,
-                        order: orderEntity.id
+                        sale: saleOpenNow.id,
+                        client: clientEntity.id
                     }
                 })
+
+                let productsSaleEntity = await strapi.db.query('api::product-sale.product-sale').findMany({
+                    where: { sale: saleOpenNow.id }
+                });
+                for (let productSale of productsSaleEntity) {
+                    await strapi.entityService.create('api::order-item.order-item', {
+                        data: {
+                            product_sale: productSale.id,
+                            quantity: 0,
+                            order: orderEntity.id
+                        }
+                    })
+                }
             }
-        }
 
-        return { data: clientEntity }
+            await commit();
+            return { data: clientEntity }
+        })
     }
 })
diff --git a/backend/src/api/order-item/controllers/order-item.ts b/backend/src/api/order-item/controllers/order-item.ts
@@ -14,36 +14,41 @@ export default factories.createCoreController('api::order-item.order-item', {
       })
     }
 
-    const orderItemEntity = await strapi.db
-      .query('api::order-item.order-item')
-      .findOne({ where: { id: orderItemId }, populate: ['product_sale'] })
-    strapi.log.info('orderItemEntity', orderItemEntity)
 
-    if (orderItemEntity.product_sale.current_available == 0) {
-      return ctx.badRequest('current_available is 0', {
-        product_sale: orderItemEntity.product_sale
-      })
-    }
+    return await strapi.db.transaction(async ({ trx, rollback, commit, onCommit, onRollback }) => {
+      const orderItemEntity = await strapi.db
+        .query('api::order-item.order-item')
+        .findOne({ where: { id: orderItemId }, populate: ['product_sale'] })
+      strapi.log.info('orderItemEntity', orderItemEntity)
 
-    let orderItem = await strapi.entityService.update('api::order-item.order-item', orderItemId, {
-      data: {
-        quantity: orderItemEntity.quantity + 1
+      if (orderItemEntity.product_sale.current_available == 0) {
+        return ctx.badRequest('current_available is 0', {
+          product_sale: orderItemEntity.product_sale
+        })
       }
-    })
-    let productSale = await strapi.entityService.update(
-      'api::product-sale.product-sale',
-      orderItemEntity.product_sale.id,
-      {
+
+      let orderItem = await strapi.entityService.update('api::order-item.order-item', orderItemId, {
         data: {
-          current_available: orderItemEntity.product_sale.current_available - 1
+          quantity: orderItemEntity.quantity + 1
         }
-      }
-    )
+      })
+      let productSale = await strapi.entityService.update(
+        'api::product-sale.product-sale',
+        orderItemEntity.product_sale.id,
+        {
+          data: {
+            current_available: orderItemEntity.product_sale.current_available - 1
+          }
+        }
+      )
 
-    return {
-      orderItem,
-      productSale
-    }
+      await commit();
+
+      return {
+        orderItem,
+        productSale
+      }
+    })
   },
 
   async decrement(ctx, next) {
@@ -55,35 +60,39 @@ export default factories.createCoreController('api::order-item.order-item', {
       })
     }
 
-    const orderItemEntity = await strapi.db
-      .query('api::order-item.order-item')
-      .findOne({ where: { id: orderItemId }, populate: ['product_sale'] })
-    strapi.log.info('orderItemEntity', orderItemEntity)
+    return await strapi.db.transaction(async ({ trx, rollback, commit, onCommit, onRollback }) => {
+      const orderItemEntity = await strapi.db
+        .query('api::order-item.order-item')
+        .findOne({ where: { id: orderItemId }, populate: ['product_sale'] })
+      strapi.log.info('orderItemEntity', orderItemEntity)
 
-    if (orderItemEntity.quantity == 0) {
-      return ctx.badRequest('quantity is already 0', {
-        order_item: orderItemEntity
-      })
-    }
-
-    let orderItem = await strapi.entityService.update('api::order-item.order-item', orderItemId, {
-      data: {
-        quantity: orderItemEntity.quantity - 1
+      if (orderItemEntity.quantity == 0) {
+        return ctx.badRequest('quantity is already 0', {
+          order_item: orderItemEntity
+        })
       }
-    })
-    let productSale = await strapi.entityService.update(
-      'api::product-sale.product-sale',
-      orderItemEntity.product_sale.id,
-      {
+
+      let orderItem = await strapi.entityService.update('api::order-item.order-item', orderItemId, {
         data: {
-          current_available: orderItemEntity.product_sale.current_available + 1
+          quantity: orderItemEntity.quantity - 1
         }
-      }
-    )
+      })
+      let productSale = await strapi.entityService.update(
+        'api::product-sale.product-sale',
+        orderItemEntity.product_sale.id,
+        {
+          data: {
+            current_available: orderItemEntity.product_sale.current_available + 1
+          }
+        }
+      )
 
-    return {
-      orderItem,
-      productSale
-    }
+      await commit();
+
+      return {
+        orderItem,
+        productSale
+      }
+    })
   }
 })
diff --git a/backend/src/api/order/controllers/order.ts b/backend/src/api/order/controllers/order.ts
@@ -29,13 +29,18 @@ export default factories.createCoreController('api::order.order', {
     }
     let notes = JSON.parse(ctx.request.body).notes || ''
 
-    let order = await strapi.entityService.update('api::order.order', order_id, {
-      data: {
-        notes
-      }
-    })
 
-    return order
+    return await strapi.db.transaction(async ({ trx, rollback, commit, onCommit, onRollback }) => {
+      let order = await strapi.entityService.update('api::order.order', order_id, {
+        data: {
+          notes
+        }
+      })
+
+      await commit();
+
+      return order
+    })
   },
   async confirm(ctx, next) {
     strapi.log.info('confirm', ctx.params)
@@ -44,12 +49,16 @@ export default factories.createCoreController('api::order.order', {
       return ctx.badRequest('Missing or invalid id', { orderId })
     }
 
-    let order = await strapi.entityService.update('api::order.order', orderId, {
-      data: {
-        last_confirmed_at: new Date()
-      }
-    })
+    return await strapi.db.transaction(async ({ trx, rollback, commit, onCommit, onRollback }) => {
+      let order = await strapi.entityService.update('api::order.order', orderId, {
+        data: {
+          last_confirmed_at: new Date()
+        }
+      })
+
+      await commit();
 
-    return order
+      return order
+    })
   }
 })
diff --git a/backend/src/api/product-sale/controllers/product-sale.ts b/backend/src/api/product-sale/controllers/product-sale.ts
@@ -10,37 +10,46 @@ export default factories.createCoreController('api::product-sale.product-sale',
         const { data } = ctx.request.body;
         const amountInMinor = data.amount_in_minor;
 
-        let productSale = await strapi.entityService.update('api::product-sale.product-sale', productSaleId, {
-            data: {
-                amount_in_minor: amountInMinor
-            }
-        })
+        return await strapi.db.transaction(async ({ trx, rollback, commit, onCommit, onRollback }) => {
+            let productSale = await strapi.entityService.update('api::product-sale.product-sale', productSaleId, {
+                data: {
+                    amount_in_minor: amountInMinor
+                }
+            })
+
+            await commit();
 
-        return productSale
+            return productSale
+        })
     },
     async updateTotalAvailable(ctx) {
         let productSaleId = ctx.params.id;
         const { data } = ctx.request.body;
         const newTotalAvailable = data.total_available;
 
-        strapi.log.info(`[controllers][product-sale][updateTotalAvailability] productSaleId '${productSaleId}' newTotalAvailable: '${newTotalAvailable}'`);
-        let productSaleEntity = await strapi.db.query('api::product-sale.product-sale').findOne({
-            where: { id: productSaleId }
-        });
-        strapi.log.info('[controllers][product-sale][updateTotalAvailability] productSaleEntity', productSaleEntity);
-
-        const delta = productSaleEntity.total_available - newTotalAvailable;
-        if (newTotalAvailable < productSaleEntity.total_available && (delta) < productSaleEntity.current_available) {
-            return ctx.badRequest('The product will get to a negative available_quantity')
-        }
-
-        const productSaleEntityUpdated = await strapi.entityService.update('api::product-sale.product-sale', productSaleId, {
-            data: {
-                total_available: newTotalAvailable,
-                current_available: productSaleEntity.current_available - delta
+
+        return await strapi.db.transaction(async ({ trx, rollback, commit, onCommit, onRollback }) => {
+            strapi.log.info(`[controllers][product-sale][updateTotalAvailability] productSaleId '${productSaleId}' newTotalAvailable: '${newTotalAvailable}'`);
+            let productSaleEntity = await strapi.db.query('api::product-sale.product-sale').findOne({
+                where: { id: productSaleId }
+            });
+            strapi.log.info('[controllers][product-sale][updateTotalAvailability] productSaleEntity', productSaleEntity);
+
+            const delta = productSaleEntity.total_available - newTotalAvailable;
+            if (newTotalAvailable < productSaleEntity.total_available && (delta) < productSaleEntity.current_available) {
+                return ctx.badRequest('The product will get to a negative available_quantity')
             }
-        })
 
-        return productSaleEntityUpdated
+            const productSaleEntityUpdated = await strapi.entityService.update('api::product-sale.product-sale', productSaleId, {
+                data: {
+                    total_available: newTotalAvailable,
+                    current_available: productSaleEntity.current_available - delta
+                }
+            })
+
+            await commit()
+
+            return productSaleEntityUpdated
+        })
     }
 })
diff --git a/backend/src/api/product/controllers/product.ts b/backend/src/api/product/controllers/product.ts
@@ -8,10 +8,16 @@ export default factories.createCoreController('api::product.product', {
   async create(ctx) {
     const { data } = ctx.request.body
 
-    const response = await strapi.entityService.create('api::product.product', {
-      data: data
+
+    return await strapi.db.transaction(async ({ trx, rollback, commit, onCommit, onRollback }) => {
+      const response = await strapi.entityService.create('api::product.product', {
+        data: data
+      })
+
+      await commit();
+
+      return { response }
     })
 
-    return { response }
   }
 })