@open-mercato/core 0.10.1-develop.7728.1.6b52eb2849 → 0.10.1-develop.7736.1.88e07906bf

package/src/modules/sales/commands/returns.ts

@@ -15,7 +15,7 @@ import type { SalesCalculationService } from '../services/salesCalculationServic
 import type { SalesAdjustmentDraft, SalesLineSnapshot, SalesDocumentCalculationResult } from '../lib/types'
 import { isExternalAmountsMode } from '../lib/calculations'
 import { readPersistedHeaderTotals } from '../lib/externalAmounts'
-import { cloneJson, deriveLineNetFromGross, ensureOrganizationScope, ensureSameScope, ensureTenantScope, extractUndoPayload, toNumericString, enforceSalesDocumentOptimisticLock, SALES_RESOURCE_KIND_ORDER, SALES_RESOURCE_KIND_RETURN } from './shared'
+import { cloneJson, deriveLineNetFromGross, ensureOrganizationScope, ensureSameScope, ensureTenantScope, extractUndoPayload, toNumericString, enforceSalesDocumentOptimisticLock, lockSalesDocumentRow, SALES_RESOURCE_KIND_ORDER, SALES_RESOURCE_KIND_RETURN } from './shared'
 import { resolveRedoSnapshot } from '@open-mercato/shared/lib/commands/redo'
 import { SalesOrder, SalesOrderAdjustment, SalesOrderLine, SalesReturn, SalesReturnLine } from '../data/entities'
 import { mapOrderLineEntityToSnapshot } from '../lib/lineSnapshots'
@@ -317,6 +317,21 @@ async function loadReturnHeaderSnapshot(em: EntityManager, id: string): Promise<
   }
 }
 
+async function lockReturnOrder(
+  em: EntityManager,
+  orderId: string,
+  scope: { tenantId: string; organizationId: string },
+): Promise<SalesOrder | null> {
+  if (!(await lockSalesDocumentRow(em, 'sales_orders', orderId, scope))) return null
+  return findOneWithDecryption(
+    em,
+    SalesOrder,
+    { id: orderId, deletedAt: null, ...scope },
+    { refresh: true },
+    scope,
+  )
+}
+
 /**
  * Reverse the order-level effects of a return: restore each order line's
  * `returnedQuantity`, drop the return's line-scoped credit adjustments, remove
@@ -337,20 +352,17 @@ async function reverseReturnEffects(
   salesCalculationService: SalesCalculationService,
   snapshot: ReturnSnapshot,
 ): Promise<void> {
-  const order = await findOneWithDecryption(
-    em,
-    SalesOrder,
-    { id: snapshot.orderId, deletedAt: null },
-    {},
-    { tenantId: snapshot.tenantId, organizationId: snapshot.organizationId },
-  )
-  if (!order) return
-
+  let order: SalesOrder | null = null
   let lines: SalesOrderLine[] = []
   await withAtomicFlush(
     em,
     [
       async () => {
+        order = await lockReturnOrder(em, snapshot.orderId, {
+          tenantId: snapshot.tenantId,
+          organizationId: snapshot.organizationId,
+        })
+        if (!order) return
         lines = await findWithDecryption(
           em,
           SalesOrderLine,
@@ -369,6 +381,7 @@ async function reverseReturnEffects(
         })
       },
       async () => {
+        if (!order) return
         if (snapshot.adjustmentIds.length) {
           const adjustments = await findWithDecryption(
             em,
@@ -450,17 +463,24 @@ async function restoreReturnEffects(
     em,
     [
       async () => {
-        const order = await findOneWithDecryption(
+        const existingOrder = await findOneWithDecryption(
           em,
           SalesOrder,
           { id: snapshot.orderId, deletedAt: null },
           {},
           { tenantId: snapshot.tenantId, organizationId: snapshot.organizationId },
         )
+        if (!existingOrder) {
+          throw notFound(translate('sales.returns.orderMissing', 'Order not found.'))
+        }
+        ensureSameScope(existingOrder, snapshot.organizationId, snapshot.tenantId)
+        const order = await lockReturnOrder(em, existingOrder.id, {
+          tenantId: snapshot.tenantId,
+          organizationId: snapshot.organizationId,
+        })
         if (!order) {
           throw notFound(translate('sales.returns.orderMissing', 'Order not found.'))
         }
-        ensureSameScope(order, snapshot.organizationId, snapshot.tenantId)
 
         const orderLines = await findWithDecryption(
           em,
@@ -643,17 +663,24 @@ const createReturnCommand: CommandHandler<ReturnCreateInput, { returnId: string
 
     const salesCalculationService = ctx.container.resolve<SalesCalculationService>('salesCalculationService')
     const { header, createdLines, order } = await em.transactional(async (tx) => {
-      const order = await findOneWithDecryption(
+      const existingOrder = await findOneWithDecryption(
         tx,
         SalesOrder,
         { id: input.orderId, deletedAt: null },
         {},
         { tenantId: input.tenantId, organizationId: input.organizationId },
       )
+      if (!existingOrder) {
+        throw notFound(translate('sales.returns.orderMissing', 'Order not found.'))
+      }
+      ensureSameScope(existingOrder, input.organizationId, input.tenantId)
+      const order = await lockReturnOrder(tx, existingOrder.id, {
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+      })
       if (!order) {
         throw notFound(translate('sales.returns.orderMissing', 'Order not found.'))
       }
-      ensureSameScope(order, input.organizationId, input.tenantId)
       await enforceSalesDocumentOptimisticLock(ctx, order, SALES_RESOURCE_KIND_ORDER)
 
       const orderLines = await findWithDecryption(

package/src/modules/sales/commands/shared.ts

@@ -49,6 +49,46 @@ export async function enforceSalesDocumentOptimisticLock(
   })
 }
 
+type SalesDocumentLockTable = 'sales_orders' | 'sales_quotes'
+type SalesDocumentLockRow = {
+  id: string
+  tenant_id: string
+  organization_id: string
+  deleted_at: Date | null
+}
+type SalesDocumentLockDatabase = Record<SalesDocumentLockTable, SalesDocumentLockRow>
+
+/**
+ * Take the parent-document row lock that serializes every write deriving the
+ * order/quote header (totals, line count, paid amounts) or the document's child
+ * rows (lines, adjustments, returned/fulfilled quantities) inside the caller's
+ * transaction. Acquire it BEFORE reading the child rows the header is
+ * recalculated from, and before locking those child rows, so all writers use the
+ * same parent-then-children lock order (#6463).
+ *
+ * `FOR NO KEY UPDATE` conflicts with other writers of the same document, including
+ * the `FOR UPDATE` locks taken by payments and undo, while still allowing the
+ * `KEY SHARE` locks that foreign-key inserts (for example shipments) take on the
+ * parent row. Returns false when no live row matches the scoped id.
+ */
+export async function lockSalesDocumentRow(
+  em: EntityManager,
+  table: SalesDocumentLockTable,
+  id: string,
+  scope: { tenantId: string; organizationId: string },
+): Promise<boolean> {
+  const locked = await em.getKysely<SalesDocumentLockDatabase>()
+    .selectFrom(table)
+    .select('id')
+    .where('id', '=', id)
+    .where('tenant_id', '=', scope.tenantId)
+    .where('organization_id', '=', scope.organizationId)
+    .where('deleted_at', 'is', null)
+    .forNoKeyUpdate()
+    .executeTakeFirst()
+  return Boolean(locked)
+}
+
 export { cloneJson } from '../lib/json'
 
 export function toNumericString(value: number | null | undefined): string | null {

package/src/modules/sales/commands/shipments.ts

@@ -31,6 +31,7 @@ import {
   ensureTenantScope,
   extractUndoPayload,
   enforceSalesDocumentOptimisticLock,
+  lockSalesDocumentRow,
   SALES_RESOURCE_KIND_ORDER,
 } from './shared'
 import { resolveDictionaryEntryValue } from '../lib/dictionaries'
@@ -312,8 +313,16 @@ async function deleteShipmentWithItems(em: EntityManager, shipment: SalesShipmen
   await em.flush()
 }
 
+async function lockOrderBeforeLines(em: EntityManager, order: SalesOrder): Promise<void> {
+  await lockSalesDocumentRow(em, 'sales_orders', order.id, {
+    tenantId: order.tenantId,
+    organizationId: order.organizationId,
+  })
+}
+
 async function recomputeFulfilledQuantities(em: EntityManager, order: SalesOrder): Promise<void> {
   const scope = { tenantId: order.tenantId, organizationId: order.organizationId }
+  await lockOrderBeforeLines(em, order)
   const shipments = await findWithDecryption(em, SalesShipment, { order, deletedAt: null }, {}, scope)
   const shipmentIds = shipments.map((entry) => entry.id)
   const shipmentItems = shipmentIds.length
@@ -386,6 +395,7 @@ async function validateShipmentItems(params: {
     throw new CrudHttpError(400, { error: translate('sales.shipments.items_required', 'Add at least one line to ship.') })
   }
   const scope = { tenantId: order.tenantId, organizationId: order.organizationId }
+  if (lockOrderLines) await lockOrderBeforeLines(em, order)
   const orderLines = await findWithDecryption(
     em,
     SalesOrderLine,

package/src/modules/staff/api/timesheets/time-projects/route.ts

@@ -379,9 +379,13 @@ const crud = makeCrudRoute({
           .filter((value) => value.length > 0)
       }
       if (parseBooleanFlag(query.mine) && ctx.auth) {
+        const tenantId = ctx.auth.tenantId ?? null
+        const organizationId = ctx.selectedOrganizationId ?? ctx.auth.orgId ?? null
+        if (!tenantId || !organizationId) {
+          filters[F.id] = { $in: [IMPOSSIBLE_PROJECT_ID] }
+          return filters
+        }
         const em = ctx.container.resolve('em') as EntityManager
-        const tenantId = ctx.auth.tenantId ?? ''
-        const organizationId = ctx.selectedOrganizationId ?? ctx.auth.orgId ?? ''
         const assigned = await resolveCallerAssignedProjectIds(
           em,
           ctx.auth.sub,