@things-factory/worksheet-base 4.3.794 → 4.3.797

package/server/graphql/resolvers/worksheet/picking/activate-batch-picking.ts

@@ -26,51 +26,81 @@ export async function activateBatchPicking(
 ): Promise<Worksheet> {
   try {
     const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-    const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
     const worksheet = await worksheetController.activateBatchPicking(worksheetNo)
     const worksheetDetails = worksheet.worksheetDetails
     const companyDomain: Domain = worksheet?.bizplace.company.domain
 
-    let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
-
-    // find for any existing marketplace store connections
-    const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-      where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
-      relations: ['marketplaceDistributors']
+    // Collect release good IDs from the controller result for post-commit processing
+    const orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+    const releaseGoodIds: string[] = orderInventories.reduce((data, orderInventory) => {
+      if (orderInventory?.releaseGood?.id && !data.includes(orderInventory.releaseGood.id)) {
+        data.push(orderInventory.releaseGood.id)
+      }
+      return data
+    }, [])
+
+    // Schedule all marketplace/LMD side effects to run AFTER the transaction commits.
+    // This prevents deadlocks caused by nested transactions competing for locks
+    // held by the outer @transaction decorator.
+    setImmediate(() => {
+      processPostActivationSideEffects(
+        domain,
+        user,
+        companyDomain,
+        worksheetNo,
+        worksheetDetails,
+        releaseGoodIds
+      ).catch(error => {
+        logger.error(`activate-batch-picking[postActivation]: ${worksheetNo}: ${error}`)
+      })
     })
 
-    const updateMarketplaceProductVariationStock = async (
-      worksheetDetails,
-      domain,
-      user,
-      marketplaceStores,
-      companyDomain
-    ) => {
+    return worksheet
+  } catch (error) {
+    logger.error(`activate-batch-picking[activateBatchPicking]: ${worksheetNo + ':' + error}`)
+    throw new Error('Something went wrong. Please contact support.')
+  }
+}
+
+/**
+ * Handles marketplace stock sync, MMS order packages, and LMD parcel creation.
+ * Runs outside the main activation transaction to prevent deadlocks.
+ */
+async function processPostActivationSideEffects(
+  domain: Domain,
+  user: User,
+  companyDomain: Domain,
+  worksheetNo: string,
+  worksheetDetails: any[],
+  releaseGoodIds: string[]
+) {
+  try {
+    // Find marketplace store connections
+    const marketplaceStores: MarketplaceStore[] = await getConnection()
+      .getRepository(MarketplaceStore)
+      .find({
+        where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+        relations: ['marketplaceDistributors']
+      })
+
+    // Update marketplace product variation stock
+    if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
       try {
         await getConnection().transaction(async (tx2: EntityManager) => {
-          let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+          const orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
           const ecommerceCtrl: EcommerceController = new EcommerceController(tx2, domain, user)
           await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
         })
       } catch (error) {
-        logger.error(`activate-batch-picking[activateBatchPicking]: ${worksheetNo + ':' + error}`)
+        logger.error(`activate-batch-picking[marketplaceStockUpdate]: ${worksheetNo}: ${error}`)
       }
     }
 
-    if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-      updateMarketplaceProductVariationStock(worksheetDetails, domain, user, marketplaceStores, companyDomain)
-    }
+    if (!releaseGoodIds.length) return
 
-    try {
-      let releaseGoods: ReleaseGood[] = []
-      let releaseGoodIds: ReleaseGood[] = orderInventories.reduce((data, orderInventory) => {
-        if (!data.find(x => x.id == orderInventory.releaseGood.id)) {
-          data.push(orderInventory.releaseGood.id)
-        }
-        return data
-      }, [])
-
-      releaseGoods = await tx.getRepository(ReleaseGood).find({
+    // Load release goods and process marketplace order packages
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const releaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
         where: { id: In(releaseGoodIds) },
         relations: [
           'domain',
@@ -88,48 +118,43 @@ export async function activateBatchPicking(
         ]
       })
 
-      if (releaseGoods?.length) {
-        for (const releaseGood of releaseGoods) {
-          const orderSource = releaseGood?.source
-          const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-            where: { orderNo: releaseGood.refNo, domain: companyDomain },
-            relations: ['marketplaceStore']
-          })
-
-          switch (orderSource) {
-            case ApplicationType.MMS:
-              if (marketplaceStores?.length) {
-                if (marketplaceOrder) {
-                  const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
-                  await ecommerceCtrl.createOrderPackage(
-                    tx,
-                    marketplaceOrder,
-                    companyDomain,
-                    marketplaceStore,
-                    releaseGood
-                  )
-                }
-              }
-              break
-            default:
-              break
+      if (!releaseGoods?.length) return
+
+      // Batch load marketplace orders for MMS release goods (avoids N+1 queries)
+      const mmsReleaseGoods = releaseGoods.filter(rg => rg?.source === ApplicationType.MMS)
+
+      if (mmsReleaseGoods.length && marketplaceStores?.length) {
+        const refNos = mmsReleaseGoods.map(rg => rg.refNo).filter(Boolean)
+        const marketplaceOrders: MarketplaceOrder[] = refNos.length
+          ? await tx.getRepository(MarketplaceOrder).find({
+              where: { orderNo: In(refNos), domain: companyDomain },
+              relations: ['marketplaceStore']
+            })
+          : []
+
+        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+        for (const releaseGood of mmsReleaseGoods) {
+          try {
+            const marketplaceOrder = marketplaceOrders.find(mo => mo.orderNo === releaseGood.refNo)
+            if (marketplaceOrder) {
+              const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+              await ecommerceCtrl.createOrderPackage(tx, marketplaceOrder, companyDomain, marketplaceStore, releaseGood)
+            }
+          } catch (error) {
+            logger.error(`activate-batch-picking[mmsOrderPackage]: ${worksheetNo}: ${error}`)
           }
         }
-        // Process LMD orders
-        processLmdOrders(releaseGoods, domain, companyDomain, user)
       }
-    } catch (e) {
-      logger.error(e)
-    }
 
-    return worksheet
+      // Process LMD orders
+      processLmdOrders(releaseGoods, domain, companyDomain, user)
+    })
   } catch (error) {
-    logger.error(`activate-batch-picking[activateBatchPicking]: ${worksheetNo + ':' + error}`)
-    throw new Error('Something went wrong. Please contact support.')
+    logger.error(`activate-batch-picking[postActivation]: ${worksheetNo}: ${error}`)
   }
 }
 
-//triger create parcel for lmd orders
+// Trigger create parcel for LMD orders
 async function processLmdOrders(releaseGoods: ReleaseGood[], domain: Domain, companyDomain: Domain, user: User) {
   // Filter only those that need processing
   const validReleaseGoods = releaseGoods.filter(

package/server/graphql/resolvers/worksheet/picking-worksheet.ts

@@ -106,6 +106,48 @@ export async function pickingWorksheet(domain: Domain, orderNo: String, location
       .andWhere('"T_INV"."status" != :t_invstatus', { t_invstatus: ORDER_INVENTORY_STATUS.CANCELLED })
       .getMany()
 
+    const inventoryIds = worksheetDetails
+      .map((wd: WorksheetDetail) => wd.targetInventory?.inventory?.id)
+      .filter((id): id is string => id != null)
+    const inventoryIdsWithMissing = new Set<string>()
+    if (inventoryIds.length > 0) {
+      const rows = await tx
+        .getRepository(InventoryChange)
+        .createQueryBuilder('ic')
+        .select('DISTINCT ic.inventory_id', 'inventoryId')
+        .where('ic.inventory_id IN (:...ids)', { ids: inventoryIds })
+        .andWhere('ic.status = :status', { status: 'PENDING' })
+        .andWhere('ic.transaction_type = :transactionType', { transactionType: 'MISSING' })
+        .getRawMany()
+      rows.forEach((r: { inventoryId: string }) => inventoryIdsWithMissing.add(r.inventoryId))
+    }
+
+    const worksheetDetailInfos = worksheetDetails.map((pickingWSD: WorksheetDetail) => {
+      const targetInventory: OrderInventory = pickingWSD.targetInventory
+      const inventory: Inventory = targetInventory.inventory
+      return {
+        name: pickingWSD.name,
+        palletId: inventory?.palletId,
+        cartonId: inventory?.cartonId,
+        batchId: inventory?.batchId,
+        batchIdRef: inventory?.batchIdRef,
+        product: inventory?.product,
+        qty: inventory?.qty,
+        binLocation: targetInventory?.binLocation || '',
+        releaseQty: targetInventory.releaseQty,
+        pickedQty: targetInventory.pickedQty,
+        status: pickingWSD.status,
+        description: pickingWSD.description,
+        targetName: targetInventory.name,
+        packingType: inventory?.packingType,
+        packingSize: inventory?.packingSize,
+        expirationDate: inventory?.expirationDate,
+        location: inventory?.location,
+        relatedOrderInv: targetInventory,
+        hasMissingInventoryChanges: inventory?.id ? inventoryIdsWithMissing.has(inventory.id) : false
+      }
+    })
+
     return {
       worksheetInfo: {
         worksheet,
@@ -123,40 +165,7 @@ export async function pickingWorksheet(domain: Domain, orderNo: String, location
         customerCompanyDomainId: releaseGood.bizplace?.company?.domain?.id,
         releaseGood
       },
-      worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
-        const targetInventory: OrderInventory = pickingWSD.targetInventory
-        const inventory: Inventory = targetInventory.inventory
-
-        const inventoryChangesCount: number = await tx.getRepository(InventoryChange).count({
-          where: {
-            inventory: inventory.id,
-            status: 'PENDING',
-            transactionType: 'MISSING'
-          }
-        })
-
-        return {
-          name: pickingWSD.name,
-          palletId: inventory?.palletId,
-          cartonId: inventory?.cartonId,
-          batchId: inventory?.batchId,
-          batchIdRef: inventory?.batchIdRef,
-          product: inventory?.product,
-          qty: inventory?.qty,
-          binLocation: targetInventory?.binLocation || '',
-          releaseQty: targetInventory.releaseQty,
-          pickedQty: targetInventory.pickedQty,
-          status: pickingWSD.status,
-          description: pickingWSD.description,
-          targetName: targetInventory.name,
-          packingType: inventory?.packingType,
-          packingSize: inventory?.packingSize,
-          expirationDate: inventory?.expirationDate,
-          location: inventory?.location,
-          relatedOrderInv: targetInventory,
-          hasMissingInventoryChanges: inventoryChangesCount > 0 ? true : false
-        }
-      })
+      worksheetDetailInfos
     }
   }
 }