@open-mercato/core 0.6.6-develop.6305.1.4503070c9d → 0.6.6-develop.6313.1.618a49a6b4

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

@@ -14,7 +14,9 @@ import type { SalesCalculationService } from '../services/salesCalculationServic
 import type { SalesAdjustmentDraft, SalesLineSnapshot, SalesDocumentCalculationResult } from '../lib/types'
 import { cloneJson, ensureOrganizationScope, ensureSameScope, ensureTenantScope, extractUndoPayload, toNumericString, enforceSalesDocumentOptimisticLock, 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 { SalesOrder, SalesOrderAdjustment, SalesOrderLine, SalesReturn, SalesReturnLine, SalesShipment, SalesShipmentItem } from '../data/entities'
+import { coerceShipmentQuantity } from '../lib/shipments/snapshots'
+import { computeAvailableReturnQuantity } from '../lib/returnQuantity'
 import {
   returnCreateSchema,
   returnUpdateSchema,
@@ -541,6 +543,36 @@ async function restoreReturnEffects(
   return createdLines
 }
 
+async function loadShippedQuantityByLine(
+  em: EntityManager,
+  orderId: string,
+  scope: { tenantId: string; organizationId: string },
+): Promise<Map<string, number>> {
+  const shipments = await findWithDecryption(
+    em,
+    SalesShipment,
+    { order: orderId, deletedAt: null },
+    {},
+    scope,
+  )
+  const shippedByLine = new Map<string, number>()
+  if (!shipments.length) return shippedByLine
+  const items = await findWithDecryption(
+    em,
+    SalesShipmentItem,
+    { shipment: { $in: shipments.map((shipment) => shipment.id) } },
+    {},
+    scope,
+  )
+  items.forEach((item) => {
+    const orderLineId = typeof item.orderLine === 'string' ? item.orderLine : item.orderLine?.id ?? null
+    if (!orderLineId) return
+    const next = (shippedByLine.get(orderLineId) ?? 0) + coerceShipmentQuantity(item.quantity)
+    shippedByLine.set(orderLineId, next)
+  })
+  return shippedByLine
+}
+
 function normalizeLinesInput(lines: ReturnCreateInput['lines']): ReturnLineInput[] {
   const seen = new Set<string>()
   const result: ReturnLineInput[] = []
@@ -594,14 +626,23 @@ const createReturnCommand: CommandHandler<ReturnCreateInput, { returnId: string
       )
       const lineMap = new Map(orderLines.map((line) => [line.id, line]))
 
+      const shippedByLine = await loadShippedQuantityByLine(tx, order.id, {
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+      })
+
       requested.forEach(({ orderLineId, quantity }) => {
         const line = lineMap.get(orderLineId)
         if (!line) {
           throw new CrudHttpError(404, { error: translate('sales.returns.lineMissing', 'Order line not found.') })
         }
-        const available = toNumeric(line.quantity) - toNumeric(line.returnedQuantity)
+        const available = computeAvailableReturnQuantity({
+          quantity: toNumeric(line.quantity),
+          returnedQuantity: toNumeric(line.returnedQuantity),
+          shippedQuantity: shippedByLine.get(orderLineId) ?? 0,
+        })
         if (quantity - 1e-6 > available) {
-          throw new CrudHttpError(400, { error: translate('sales.returns.quantityExceeded', 'Cannot return more than the remaining quantity.') })
+          throw new CrudHttpError(400, { error: translate('sales.returns.quantityExceedsShipped', 'Cannot return more than the shipped quantity. Ship the items before recording a return.') })
         }
       })
 

package/src/modules/sales/components/documents/ReturnDialog.tsx

@@ -22,6 +22,7 @@ export type ReturnOrderLine = {
   lineNumber: number | null
   quantity: number
   returnedQuantity: number
+  shippedQuantity?: number
   thumbnail?: string | null
 }
 

package/src/modules/sales/components/documents/ReturnsSection.tsx

@@ -17,6 +17,7 @@ import {
   emitSalesDocumentTotalsRefresh,
   subscribeSalesDocumentTotalsRefresh,
 } from '@open-mercato/core/modules/sales/lib/frontend/documentTotalsEvents'
+import { sumShippedQuantityByLine } from '@open-mercato/core/modules/sales/lib/returnQuantity'
 import { formatMoney, normalizeNumber } from './lineItemUtils'
 import { ReturnDialog, type ReturnOrderLine } from './ReturnDialog'
 import { ReturnEditDialog, type ReturnEditRecord } from './ReturnEditDialog'
@@ -60,14 +61,25 @@ export function SalesReturnsSection({ orderId, currencyCode, documentUpdatedAt }
 
   const loadLines = React.useCallback(async () => {
     const params = new URLSearchParams({ page: '1', pageSize: '100', orderId })
-    const response = await apiCall<{ items?: Array<Record<string, unknown>> }>(
-      `/api/sales/order-lines?${params.toString()}`,
-      undefined,
-      { fallback: { items: [] } },
+    const shipmentParams = new URLSearchParams({ page: '1', pageSize: '200', orderId })
+    const [response, shipmentsResponse] = await Promise.all([
+      apiCall<{ items?: Array<Record<string, unknown>> }>(
+        `/api/sales/order-lines?${params.toString()}`,
+        undefined,
+        { fallback: { items: [] } },
+      ),
+      apiCall<{ items?: Array<Record<string, unknown>> }>(
+        `/api/sales/shipments?${shipmentParams.toString()}`,
+        undefined,
+        { fallback: { items: [] } },
+      ),
+    ])
+    const shippedByLine = sumShippedQuantityByLine(
+      Array.isArray(shipmentsResponse.result?.items) ? shipmentsResponse.result?.items : [],
     )
     const items = Array.isArray(response.result?.items) ? response.result?.items ?? [] : []
     const mapped: ReturnOrderLine[] = items
-      .map((item) => {
+      .map((item): ReturnOrderLine | null => {
         const map = item as Record<string, unknown>
         const id = typeof map.id === 'string' ? map.id : null
         if (!id) return null
@@ -110,6 +122,7 @@ export function SalesReturnsSection({ orderId, currencyCode, documentUpdatedAt }
           lineNumber,
           quantity: Number.isFinite(quantity) ? quantity : 0,
           returnedQuantity: Number.isFinite(returnedQuantity) ? returnedQuantity : 0,
+          shippedQuantity: shippedByLine.get(id) ?? 0,
         }
       })
       .filter((entry): entry is ReturnOrderLine => Boolean(entry?.id))

package/src/modules/sales/i18n/de.json

@@ -1326,6 +1326,7 @@
   "sales.returns.qty.increase": "Menge erhöhen",
   "sales.returns.quantity": "Menge",
   "sales.returns.quantityExceeded": "Es kann nicht mehr als die verbleibende Menge zurückgegeben werden.",
+  "sales.returns.quantityExceedsShipped": "Es kann nicht mehr als die versandte Menge zurückgegeben werden. Versenden Sie die Artikel, bevor Sie eine Rücksendung erfassen.",
   "sales.returns.reason": "Grund",
   "sales.returns.reason.placeholder": "Optional",
   "sales.returns.returnNumber": "Rückgabe",

package/src/modules/sales/i18n/en.json

@@ -1326,6 +1326,7 @@
   "sales.returns.qty.increase": "Increase quantity",
   "sales.returns.quantity": "Quantity",
   "sales.returns.quantityExceeded": "Cannot return more than the remaining quantity.",
+  "sales.returns.quantityExceedsShipped": "Cannot return more than the shipped quantity. Ship the items before recording a return.",
   "sales.returns.reason": "Reason",
   "sales.returns.reason.placeholder": "Optional",
   "sales.returns.returnNumber": "Return",

package/src/modules/sales/i18n/es.json

@@ -1326,6 +1326,7 @@
   "sales.returns.qty.increase": "Aumentar cantidad",
   "sales.returns.quantity": "Cantidad",
   "sales.returns.quantityExceeded": "No se puede devolver más que la cantidad restante.",
+  "sales.returns.quantityExceedsShipped": "No se puede devolver más que la cantidad enviada. Envíe los artículos antes de registrar una devolución.",
   "sales.returns.reason": "Motivo",
   "sales.returns.reason.placeholder": "Opcional",
   "sales.returns.returnNumber": "Devolución",

package/src/modules/sales/i18n/pl.json

@@ -1326,6 +1326,7 @@
   "sales.returns.qty.increase": "Zwiększ ilość",
   "sales.returns.quantity": "Ilość",
   "sales.returns.quantityExceeded": "Nie można zwrócić więcej niż pozostała ilość.",
+  "sales.returns.quantityExceedsShipped": "Nie można zwrócić więcej niż wysłana ilość. Wyślij artykuły, zanim zarejestrujesz zwrot.",
   "sales.returns.reason": "Powód",
   "sales.returns.reason.placeholder": "Opcjonalny",
   "sales.returns.returnNumber": "Zwrot",

package/src/modules/sales/lib/returnQuantity.ts

@@ -1,10 +1,57 @@
 export type ReturnAvailableInput = {
   quantity: number
   returnedQuantity: number
+  shippedQuantity?: number
 }
 
 export function computeAvailableReturnQuantity(line: ReturnAvailableInput): number {
-  const raw = line.quantity - line.returnedQuantity
+  const cap =
+    typeof line.shippedQuantity === 'number' && Number.isFinite(line.shippedQuantity)
+      ? Math.min(line.quantity, line.shippedQuantity)
+      : line.quantity
+  const raw = cap - line.returnedQuantity
   if (!Number.isFinite(raw) || raw <= 0) return 0
   return Math.max(0, Math.floor(raw + 1e-6))
 }
+
+function coerceQuantity(value: unknown): number {
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+  if (typeof value === 'string' && value.trim().length) {
+    const parsed = Number(value)
+    if (Number.isFinite(parsed)) return parsed
+  }
+  return 0
+}
+
+/**
+ * Aggregate shipped quantity per order line from the `/api/sales/shipments`
+ * list payload. Mirrors the server-side `loadShippedQuantityByLine` cap so the
+ * Return dialog's "Available" figure matches what `sales.returns.create`
+ * enforces. Each shipment exposes its lines under `items` (either the
+ * persisted snapshot or DB-grouped rows), both carrying `orderLineId` and
+ * `quantity`.
+ */
+export function sumShippedQuantityByLine(
+  shipments: ReadonlyArray<Record<string, unknown>> | null | undefined,
+): Map<string, number> {
+  const shippedByLine = new Map<string, number>()
+  if (!Array.isArray(shipments)) return shippedByLine
+  for (const shipment of shipments) {
+    if (!shipment || typeof shipment !== 'object') continue
+    const lineItems = (shipment as Record<string, unknown>).items
+    if (!Array.isArray(lineItems)) continue
+    for (const lineItem of lineItems) {
+      if (!lineItem || typeof lineItem !== 'object') continue
+      const record = lineItem as Record<string, unknown>
+      const orderLineId =
+        typeof record.orderLineId === 'string'
+          ? record.orderLineId
+          : typeof record.order_line_id === 'string'
+            ? record.order_line_id
+            : null
+      if (!orderLineId) continue
+      shippedByLine.set(orderLineId, (shippedByLine.get(orderLineId) ?? 0) + coerceQuantity(record.quantity))
+    }
+  }
+  return shippedByLine
+}

package/src/modules/workflows/lib/event-trigger-service.ts

@@ -123,6 +123,9 @@ function isSafeWorkflowRegexPattern(pattern: string): boolean {
   let lastClosedGroup: RegexGroupFrame | null = null
   let lastAtomWasQuantified = false
 
+  // Hand-written single-pass lexer: `index` is intentionally advanced inside the
+  // loop body (escape pairs, `(?:` prefixes, multi-char quantifiers, lazy `?`) on
+  // top of the `index += 1` update clause. Do not "simplify" these in-body writes.
   for (let index = 0; index < pattern.length; index += 1) {
     const char = pattern[index]