@things-factory/operato-hub 4.3.821 → 4.3.823

package/server/graphql/resolvers/synchronization/powrup-get-airway-bill.ts

@@ -7,87 +7,140 @@ import { ORDER_STATUS, OrderPackage } from '@things-factory/sales-base'
 
 const { PerformanceObserver, performance } = require('node:perf_hooks')
 
+// Stable key for pg_try_advisory_lock — keeps two concurrent invocations of this
+// resolver from contending on the same order_packages rows.
+const ADVISORY_LOCK_KEY = 'powrup-get-airway-bill'
+
 export const powrupGetAirwayBillResolver = {
   async powrupGetAirwayBill(_: void, { }, context: any): Promise<void> {
+    // We deliberately do NOT wrap the resolver in a transaction. The previous
+    // implementation held a single long transaction across up to 100 external
+    // PowrupAPI HTTP calls, keeping row locks on every UPDATE'd order_packages
+    // row until the loop finished — minutes of contention against the packing
+    // UI, sellercraft updates, and any other path that touches those rows.
+    //
+    // Instead we use a single QueryRunner connection for the duration of the
+    // resolver, acquire a session-level advisory lock so concurrent runs skip
+    // early, and let each UPDATE auto-commit on its own (row lock held only for
+    // the duration of that single statement).
+    const queryRunner = getConnection().createQueryRunner()
+    let connected = false
+
     try {
-      await getConnection().transaction(async tx => {
-        try {
-          const powrup: Powrup = await tx
-            .getRepository(Powrup)
-            .findOne({ where: { platform: Platform.POWRUP, active: true } })
+      await queryRunner.connect()
+      connected = true
 
-          let orderPackageQb = await tx
-            .getRepository(OrderPackage)
-            .createQueryBuilder('opk')
-            .innerJoinAndSelect('opk.releaseGood', 'rg')
-            .innerJoinAndSelect('opk.domain', 'domain')
-            .innerJoinAndSelect('opk.bizplace', 'bizplace')
-            .innerJoinAndSelect('opk.creator', 'creator')
-            .where(`rg.source = :source`, { source: ApplicationType.POWRUP })
-            .andWhere(`rg.type = :rgType`, { rgType: 'b2c' })
-            .andWhere(`rg.ref_order_id NOTNULL`)
-            .andWhere(`(rg.lmd_option = false or rg.lmd_option ISNULL)`)
-            .andWhere(`rg.status NOT IN (:...status) `, {
-              status: [ORDER_STATUS.PACKING, ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL, ORDER_STATUS.DONE]
-            })
-            .andWhere(`opk.airway_bill ISNULL`)
-            .orderBy(`rg.created_at`)
-            .limit(100)
+      const lockResult: { acquired: boolean }[] = await queryRunner.query(
+        `SELECT pg_try_advisory_lock(hashtextextended($1, 0)) AS acquired`,
+        [ADVISORY_LOCK_KEY]
+      )
+      if (!lockResult?.[0]?.acquired) {
+        logger.info(`powrupGetAirwayBill: another instance is running, skipping`)
+        return
+      }
 
-          let orderPackagesWithoutAirwayBill: OrderPackage[] = await orderPackageQb.getMany()
+      try {
+        const manager = queryRunner.manager
 
-          if (orderPackagesWithoutAirwayBill?.length > 0) {
-            for (let i = 0; i < orderPackagesWithoutAirwayBill.length; i++) {
-              const orderPackage: OrderPackage = orderPackagesWithoutAirwayBill[i]
-              performance.mark(`start:${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`)
-              try {
-                const {
-                  trackingNo,
-                  transporter,
-                  printLabels
-                }: { trackingNo: string; transporter: string; printLabels: any[] } = await PowrupAPI.fetchDocument(
-                  powrup,
-                  {
-                    context: { state: { domain: null, user: null } },
-                    refOrderId: orderPackage.releaseGood.refOrderId,
-                    packageId: orderPackage.packageId
-                  }
-                )
-                performance.mark(`end:${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`)
-                let updateInfo: any
-                if (printLabels?.length) {
-                  printLabels.map(pl => {
-                    updateInfo = { ...updateInfo, airwayBill: pl.awbUrl }
-                  })
+        const powrup: Powrup = await manager.findOne(Powrup, {
+          where: { platform: Platform.POWRUP, active: true }
+        })
 
-                  updateInfo = {
-                    ...updateInfo,
-                    trackingNo: trackingNo,
-                    transporter: transporter
-                  }
+        const orderPackagesWithoutAirwayBill: OrderPackage[] = await manager
+          .createQueryBuilder(OrderPackage, 'opk')
+          .innerJoinAndSelect('opk.releaseGood', 'rg')
+          .innerJoinAndSelect('opk.domain', 'domain')
+          .innerJoinAndSelect('opk.bizplace', 'bizplace')
+          .innerJoinAndSelect('opk.creator', 'creator')
+          .where(`rg.source = :source`, { source: ApplicationType.POWRUP })
+          .andWhere(`rg.type = :rgType`, { rgType: 'b2c' })
+          .andWhere(`rg.ref_order_id NOTNULL`)
+          .andWhere(`(rg.lmd_option = false or rg.lmd_option ISNULL)`)
+          .andWhere(`rg.status NOT IN (:...status) `, {
+            status: [ORDER_STATUS.PACKING, ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL, ORDER_STATUS.DONE]
+          })
+          .andWhere(`opk.airway_bill ISNULL`)
+          .orderBy(`rg.created_at`)
+          .limit(100)
+          .getMany()
 
-                  await tx.getRepository(OrderPackage).update({ id: orderPackage.id }, { ...updateInfo })
+        if (orderPackagesWithoutAirwayBill?.length > 0) {
+          for (let i = 0; i < orderPackagesWithoutAirwayBill.length; i++) {
+            const orderPackage: OrderPackage = orderPackagesWithoutAirwayBill[i]
+            performance.mark(`start:${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`)
+            try {
+              const {
+                trackingNo,
+                transporter,
+                printLabels
+              }: { trackingNo: string; transporter: string; printLabels: any[] } = await PowrupAPI.fetchDocument(
+                powrup,
+                {
+                  context: { state: { domain: null, user: null } },
+                  refOrderId: orderPackage.releaseGood.refOrderId,
+                  packageId: orderPackage.packageId
                 }
-              } catch (e) {
-                performance.mark(`end:${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`)
-                logger.error(`powrupGetAirwayBill[GetAirwayBill][Order Package ID: ${orderPackage.id}]: ${e}`)
-                continue
-              } finally {
-                let perf = performance.measure(
-                  `powrupGetAirwayBill: ${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`,
-                  `start:${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`,
-                  `end:${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`
-                )
-                console.info(perf.toJSON())
+              )
+              performance.mark(`end:${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`)
+
+              if (printLabels?.length) {
+                let updateInfo: any
+                printLabels.map(pl => {
+                  updateInfo = { ...updateInfo, airwayBill: pl.awbUrl }
+                })
+
+                updateInfo = {
+                  ...updateInfo,
+                  trackingNo: trackingNo,
+                  transporter: transporter
+                }
+
+                // Auto-commit single-statement UPDATE on the QueryRunner's connection.
+                // Row lock held only for this UPDATE, not across the API call above.
+                await manager.update(OrderPackage, { id: orderPackage.id }, updateInfo)
               }
+            } catch (e) {
+              performance.mark(`end:${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`)
+              logger.error(`powrupGetAirwayBill[GetAirwayBill][Order Package ID: ${orderPackage.id}]: ${e}`)
+              continue
+            } finally {
+              let perf = performance.measure(
+                `powrupGetAirwayBill: ${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`,
+                `start:${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`,
+                `end:${orderPackage.releaseGood.refOrderId} - ${orderPackage.packageId}`
+              )
+              console.info(perf.toJSON())
             }
           }
-        } catch (e) {
-          logger.error(`powrupGetAirwayBill[GetAirwayBill]: ${e}`)
         }
-      })
+      } catch (e) {
+        logger.error(`powrupGetAirwayBill[GetAirwayBill]: ${e}`)
+      } finally {
+        // Release the advisory lock so the next scheduled invocation can proceed.
+        // Wrapped in try/catch because release must not mask the original error.
+        try {
+          await queryRunner.query(`SELECT pg_advisory_unlock(hashtextextended($1, 0))`, [ADVISORY_LOCK_KEY])
+        } catch (releaseErr) {
+          logger.error(`powrupGetAirwayBill[AdvisoryUnlock]: ${releaseErr}`)
+        }
+      }
     } catch (e) {
       logger.error(`powrupGetAirwayBill[MainError]: ${e}`)
+    } finally {
+      // Defensive: clear any session-level advisory locks still held on this
+      // connection before returning it to the pool. Guards against the lock
+      // leaking if pg_advisory_unlock above failed (DB blip, statement timeout)
+      // and the pool then hands this connection to a future invocation.
+      // Skip when connect() itself failed — querying an unconnected QueryRunner
+      // would just throw with nothing to actually clean up.
+      if (connected) {
+        try {
+          await queryRunner.query(`SELECT pg_advisory_unlock_all()`)
+        } catch (unlockAllErr) {
+          logger.error(`powrupGetAirwayBill[AdvisoryUnlockAll]: ${unlockAllErr}`)
+        }
+      }
+      await queryRunner.release()
     }
   }
 }

package/server/graphql/resolvers/synchronization/powrup-get-tracking-no.ts

@@ -5,60 +5,100 @@ import { logger } from '@things-factory/env'
 import { Platform, Powrup, PowrupAPI } from '@things-factory/integration-powrup'
 import { ORDER_STATUS, OrderPackage } from '@things-factory/sales-base'
 
+const ADVISORY_LOCK_KEY = 'powrup-get-tracking-no'
+
 export const powrupGetTrackingNoResolver = {
   async powrupGetTrackingNo(_: void, { }, context: any): Promise<void> {
+    // Same fix as powrupGetAirwayBill: avoid wrapping the resolver in a long
+    // transaction across an external API call. Use a single QueryRunner with a
+    // session-level advisory lock for concurrency safety, and let each UPDATE
+    // auto-commit on its own.
+    const queryRunner = getConnection().createQueryRunner()
+    let connected = false
+
     try {
-      await getConnection().transaction(async tx => {
-        try {
-          const powrup: Powrup = await tx
-            .getRepository(Powrup)
-            .findOne({ where: { platform: Platform.POWRUP, active: true } })
+      await queryRunner.connect()
+      connected = true
+
+      const lockResult: { acquired: boolean }[] = await queryRunner.query(
+        `SELECT pg_try_advisory_lock(hashtextextended($1, 0)) AS acquired`,
+        [ADVISORY_LOCK_KEY]
+      )
+      if (!lockResult?.[0]?.acquired) {
+        logger.info(`powrupGetTrackingNo: another instance is running, skipping`)
+        return
+      }
 
-          let orderPackageQb = await tx
-            .getRepository(OrderPackage)
-            .createQueryBuilder('opk')
-            .innerJoinAndSelect('opk.releaseGood', 'rg')
-            .innerJoinAndSelect('opk.domain', 'domain')
-            .innerJoinAndSelect('opk.bizplace', 'bizplace')
-            .innerJoinAndSelect('opk.creator', 'creator')
-            .where(`rg.source = :source`, { source: ApplicationType.POWRUP })
-            .andWhere(`rg.type = :rgType`, { rgType: 'b2c' })
-            .andWhere(`rg.ref_order_id NOTNULL`)
-            .andWhere(`rg.status NOT IN(:...status) `, {
-              status: [ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]
-            })
-            .andWhere(`opk.tracking_no IS NULL`)
-            .andWhere(`opk.airway_bill NOTNULL`)
-            .andWhere(`opk.package_id NOTNULL`)
-            .limit(500)
+      try {
+        const manager = queryRunner.manager
 
-          let orderPackagesWithoutTrackingNo: OrderPackage[] = await orderPackageQb.getMany()
+        const powrup: Powrup = await manager.findOne(Powrup, {
+          where: { platform: Platform.POWRUP, active: true }
+        })
 
-          if (orderPackagesWithoutTrackingNo?.length > 0) {
-            // Combine all package id into packageIds
-            let orderPackageIds: any = orderPackagesWithoutTrackingNo.map(op => op.packageId)
+        const orderPackagesWithoutTrackingNo: OrderPackage[] = await manager
+          .createQueryBuilder(OrderPackage, 'opk')
+          .innerJoinAndSelect('opk.releaseGood', 'rg')
+          .innerJoinAndSelect('opk.domain', 'domain')
+          .innerJoinAndSelect('opk.bizplace', 'bizplace')
+          .innerJoinAndSelect('opk.creator', 'creator')
+          .where(`rg.source = :source`, { source: ApplicationType.POWRUP })
+          .andWhere(`rg.type = :rgType`, { rgType: 'b2c' })
+          .andWhere(`rg.ref_order_id NOTNULL`)
+          .andWhere(`rg.status NOT IN(:...status) `, {
+            status: [ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]
+          })
+          .andWhere(`opk.tracking_no IS NULL`)
+          .andWhere(`opk.airway_bill NOTNULL`)
+          .andWhere(`opk.package_id NOTNULL`)
+          .limit(500)
+          .getMany()
 
-            // Call API with multiple package ids in one call
-            const trackingNos: any = await PowrupAPI.getTrackingNo(powrup, {
-              context: { state: { domain: null, user: null } },
-              packageIds: orderPackageIds
-            })
+        if (orderPackagesWithoutTrackingNo?.length > 0) {
+          // Batch the API call for all package IDs in one shot.
+          const orderPackageIds: any = orderPackagesWithoutTrackingNo.map(op => op.packageId)
+          const trackingNos: any = await PowrupAPI.getTrackingNo(powrup, {
+            context: { state: { domain: null, user: null } },
+            packageIds: orderPackageIds
+          })
 
-            if (trackingNos?.length) {
-              await Promise.all(
-                trackingNos.map(async tn => {
-                  const { packageId, trackingNo } = tn
-                  await tx.getRepository(OrderPackage).update({ packageId: packageId }, { trackingNo: trackingNo })
-                })
-              )
+          if (trackingNos?.length) {
+            // Run UPDATEs sequentially as auto-commits. Parallel saves on the same
+            // QueryRunner connection are not safe (single connection), and parallel
+            // saves across separate connections gain little because the rows are
+            // independent and each UPDATE is fast.
+            for (const tn of trackingNos) {
+              const { packageId, trackingNo } = tn
+              await manager.update(OrderPackage, { packageId }, { trackingNo })
             }
           }
-        } catch (e) {
-          logger.error(`powrupGetTrackingNo[GetTrackingNo]: ${e}`)
         }
-      })
+      } catch (e) {
+        logger.error(`powrupGetTrackingNo[GetTrackingNo]: ${e}`)
+      } finally {
+        try {
+          await queryRunner.query(`SELECT pg_advisory_unlock(hashtextextended($1, 0))`, [ADVISORY_LOCK_KEY])
+        } catch (releaseErr) {
+          logger.error(`powrupGetTrackingNo[AdvisoryUnlock]: ${releaseErr}`)
+        }
+      }
     } catch (e) {
       logger.error(`powrupGetTrackingNo[MainError]: ${e}`)
+    } finally {
+      // Defensive: clear any session-level advisory locks still held on this
+      // connection before returning it to the pool. Guards against the lock
+      // leaking if pg_advisory_unlock above failed (DB blip, statement timeout)
+      // and the pool then hands this connection to a future invocation.
+      // Skip when connect() itself failed — querying an unconnected QueryRunner
+      // would just throw with nothing to actually clean up.
+      if (connected) {
+        try {
+          await queryRunner.query(`SELECT pg_advisory_unlock_all()`)
+        } catch (unlockAllErr) {
+          logger.error(`powrupGetTrackingNo[AdvisoryUnlockAll]: ${unlockAllErr}`)
+        }
+      }
+      await queryRunner.release()
     }
   }
 }

package/server/graphql/types/synchronization/index.ts

@@ -21,8 +21,11 @@ export const Mutation = /* GraphQL */ `
   sellercraftPackMarketplaceOrder: Boolean @transaction
   sellercraftInitiateShipment: Boolean @transaction
   powrupPackOrder: Boolean @transaction
-  powrupGetTrackingNo: Boolean @transaction
-  powrupGetAirwayBill: Boolean @transaction
+  # Intentionally NOT @transaction — these resolvers manage their own QueryRunner
+  # to avoid holding row locks on order_packages across external Powrup API calls.
+  # See powrup-get-airway-bill.ts and powrup-get-tracking-no.ts for the rationale.
+  powrupGetTrackingNo: Boolean
+  powrupGetAirwayBill: Boolean
   powrupInitiateShipment: Boolean @transaction
   getLmdAwb: Boolean @transaction
   createDatShipments: Boolean @transaction

package/server/routers/api/restful-apis/v1/utils/params.ts

@@ -513,6 +513,7 @@ export const params = {
     'orderInventories.batchId',
     'orderInventories.warehouseCode',
     'orderInventories.refItemId',
+    'orderInventories.remark',
     'remark',
     'billTo',
     'billTo.billingAddress',

package/server/routers/xilnex-router.ts

@@ -12,6 +12,7 @@ import {
   AccountWebhookOrder,
   Xilnex
 } from '@things-factory/integration-accounting'
+import { webhookHandler, WebhookEventsEnum } from '@things-factory/integration-base'
 // import { createPayloadLog, PayloadType } from '@things-factory/integration-base'
 import { Product, ProductBundle, ProductDetail } from '@things-factory/product-base'
 import {
@@ -545,27 +546,41 @@ xilnexRouter.post('/webhook-xilnex-transfer-note', async (context, next) => {
               })
             )
 
+            let result
             if (errorList.length > 0) {
-              context.throw(404, errorList.join(', '))
+              // Insufficient stock: persist the order as a DraftReleaseGood so it is
+              // not lost. Once stock arrives, the draft can be released via the
+              // existing draft-to-release flow.
+              logger.warn(
+                `xilnex-router[${releaseGood.orderSourceType}][insufficient-stock]: refNo=${releaseGood.refNo} creating DraftReleaseGood; details=${errorList.join(', ')}`
+              )
+              result = await createDraftReleaseGood(
+                releaseGood,
+                massagedData.orderProducts,
+                customerBizplace,
+                warehouseDomain,
+                context,
+                tx
+              )
+            } else {
+              const assignedOrderProducts = await assignToInventory(
+                massagedData.orderProducts,
+                customerBizplace,
+                warehouseDomain,
+                context,
+                tx
+              )
+
+              result = await createReleaseGood(
+                releaseGood,
+                assignedOrderProducts,
+                customerBizplace,
+                warehouseDomain,
+                context,
+                tx
+              )
             }
 
-            let assignedOrderProducts = await assignToInventory(
-              massagedData.orderProducts,
-              customerBizplace,
-              warehouseDomain,
-              context,
-              tx
-            )
-
-            let result = await createReleaseGood(
-              releaseGood,
-              assignedOrderProducts,
-              customerBizplace,
-              warehouseDomain,
-              context,
-              tx
-            )
-
             let addReleaseGood = {
               id: result.id,
               name: result.name,
@@ -889,27 +904,41 @@ xilnexRouter.post('/webhook-xilnex-stock-request', async (context, next) => {
               })
             )
 
+            let result
             if (errorList.length > 0) {
-              context.throw(404, errorList.join(', '))
+              // Insufficient stock: persist the order as a DraftReleaseGood so it is
+              // not lost. Once stock arrives, the draft can be released via the
+              // existing draft-to-release flow.
+              logger.warn(
+                `xilnex-router[${releaseGood.orderSourceType}][insufficient-stock]: refNo=${releaseGood.refNo} creating DraftReleaseGood; details=${errorList.join(', ')}`
+              )
+              result = await createDraftReleaseGood(
+                releaseGood,
+                massagedData.orderProducts,
+                customerBizplace,
+                warehouseDomain,
+                context,
+                tx
+              )
+            } else {
+              const assignedOrderProducts = await assignToInventory(
+                massagedData.orderProducts,
+                customerBizplace,
+                warehouseDomain,
+                context,
+                tx
+              )
+
+              result = await createReleaseGood(
+                releaseGood,
+                assignedOrderProducts,
+                customerBizplace,
+                warehouseDomain,
+                context,
+                tx
+              )
             }
 
-            let assignedOrderProducts = await assignToInventory(
-              massagedData.orderProducts,
-              customerBizplace,
-              warehouseDomain,
-              context,
-              tx
-            )
-
-            let result = await createReleaseGood(
-              releaseGood,
-              assignedOrderProducts,
-              customerBizplace,
-              warehouseDomain,
-              context,
-              tx
-            )
-
             let addReleaseGood = {
               id: result.id,
               name: result.name,
@@ -1072,12 +1101,21 @@ xilnexRouter.post('/webhook-xilnex-stock-request', async (context, next) => {
 })
 
 async function checkExistingOrder(releaseGood, bizplace, checkDuplicationValidation = true, context, tx) {
-  const { domain }: { domain: Domain } = context.state
+  // Use the warehouse domain set on the releaseGood (caller passes warehouseDomain explicitly)
+  // so dedupe is consistent with the domain that ReleaseGood / DraftReleaseGood are saved under.
+  const domain: Domain = releaseGood.domain
   const refNo: string = releaseGood.refNo
   const refNo2: string = releaseGood.refNo2
   const refNo3: string = releaseGood.refNo3
 
   if (checkDuplicationValidation) {
+    // Acquire a transaction-scoped advisory lock keyed on the dedupe tuple. Serializes
+    // concurrent webhook deliveries for the same (domain, refNo, refNo2, refNo3) so the
+    // SELECT-then-INSERT pattern below can't race two duplicates through. The lock is
+    // automatically released when the transaction commits or rolls back.
+    const lockKey = `xilnex-dedupe:${domain.id}:${refNo || ''}:${refNo2 || ''}:${refNo3 || ''}`
+    await tx.query(`SELECT pg_advisory_xact_lock(hashtextextended($1, 0))`, [lockKey])
+
     const foundDraftReleaseGood: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).findOne({
       where: {
         domain,
@@ -1770,3 +1808,93 @@ async function createReleaseGood(
     throw error
   }
 }
+
+// Inline draft creation that mirrors createReleaseGood's domain handling: takes warehouseDomain
+// explicitly instead of relying on context.state.domain. A simplified parallel of
+// createDraftReleaseGoodFunction in @things-factory/sales-base — kept tight (no LMD / shipping
+// order / attachments / country normalization) because none apply to the Xilnex webhook path.
+async function createDraftReleaseGood(
+  releaseGood: any,
+  orderProducts: OrderProduct[],
+  bizplace: Bizplace,
+  domain: Domain,
+  context: any,
+  tx: EntityManager
+): Promise<DraftReleaseGood> {
+  const { user }: { user: any } = context.state
+
+  if (orderProducts.length <= 0) {
+    throw new ValidationError({
+      errorCode: 'ITEM_NOT_FOUND',
+      message: 'no order items found',
+      detail: JSON.stringify(releaseGood)
+    })
+  }
+
+  // Resolve DRO number under the warehouse domain
+  const droNoSetting: Setting = await tx.getRepository(Setting).findOne({
+    where: { domain, name: ORDER_NUMBER_SETTING_KEY.DRO_NUMBER_RULE }
+  })
+
+  const orderNo: string = droNoSetting
+    ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.DRO_NUMBER, seed: {} })
+    : OrderNoGenerator.draftReleaseGood()
+
+  const newDraftReleaseGood = {
+    name: orderNo,
+    domain,
+    bizplace,
+    refNo: releaseGood.refNo,
+    refNo2: releaseGood.refNo2 || null,
+    refNo3: releaseGood.refNo3 || null,
+    collectionOrderNo: releaseGood.collectionOrderNo,
+    type: releaseGood?.type ? releaseGood.type : 'b2b',
+    courierOption: releaseGood.courierOption,
+    exportOption: releaseGood.exportOption,
+    ownTransport: releaseGood.ownTransport,
+    packingOption: releaseGood.packingOption,
+    marketplaceOrderStatus: releaseGood?.marketplaceOrderStatus || null,
+    releaseDate: releaseGood.releaseDate,
+    remark: releaseGood?.remark || null,
+    source: releaseGood?.source,
+    status: DRAFT_RELEASE_ORDER_STATUS.DRAFT,
+    creator: user,
+    updater: user
+  }
+
+  const resultDraftReleaseGood: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).save(newDraftReleaseGood)
+
+  // Persist OrderProduct rows linked to the draft. Mirrors createReleaseGood's
+  // OrderProduct save loop, swapping releaseGood for draftReleaseGood and skipping
+  // OrderInventory creation (drafts have no assigned inventory yet).
+  const savedOrderProducts = await Promise.all(
+    orderProducts.map(async orderProduct => {
+      // status MUST be 'DRAFT' — draft-release-good-create.ts:130 filters
+      // orderProducts on `op.status == 'DRAFT'` during draft → release conversion.
+      // Setting any other ORDER_PRODUCT_STATUS value here would cause the converted
+      // ReleaseGood to come out with zero line items.
+      const draftOrderProduct = Object.assign(new OrderProduct(), {
+        ...orderProduct,
+        name: OrderNoGenerator.orderProduct(),
+        domain,
+        bizplace,
+        draftReleaseGood: resultDraftReleaseGood,
+        type: ORDER_TYPES.RELEASE_OF_GOODS,
+        status: DRAFT_RELEASE_ORDER_STATUS.DRAFT,
+        creator: user,
+        updater: user
+      })
+      return await tx.getRepository(OrderProduct).save(draftOrderProduct)
+    })
+  )
+
+  resultDraftReleaseGood.orderProducts = savedOrderProducts
+
+  // Notify external subscribers that a draft has been created. Fire-and-forget,
+  // matching the pattern used at add-release-order.ts:557 for ReleaseOrderCreated.
+  // Note: this fires inside the outer transaction; if the transaction rolls back
+  // the webhook will still have been queued. Consumers should be idempotent.
+  webhookHandler(resultDraftReleaseGood, bizplace, WebhookEventsEnum.DraftOrderCreated)
+
+  return resultDraftReleaseGood
+}