@open-mercato/core 0.6.7-develop.6661.1.0043ed1d03 → 0.6.7-develop.6670.1.4efa7961c6

package/src/modules/wms/subscribers/reservation-shortfall-notification.ts

@@ -0,0 +1,98 @@
+import type { QueryEngine } from '@open-mercato/shared/lib/query/types'
+import { E } from '#generated/entities.ids.generated'
+import { resolveNotificationService } from '../../notifications/lib/notificationService'
+import { buildFeatureNotificationFromType } from '../../notifications/lib/notificationBuilder'
+import { notificationTypes } from '../notifications'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('wms')
+
+export const metadata = {
+  event: 'wms.inventory.reservation_shortfall',
+  persistent: true,
+  id: 'wms:reservation-shortfall-notification',
+}
+
+type ShortfallLine = {
+  catalogVariantId: string
+  requiredQuantity: number
+  reservedQuantity: number
+  shortfallQuantity: number
+}
+
+type ShortfallPayload = {
+  orderId: string
+  orderNumber?: string | null
+  shortfalls: ShortfallLine[]
+  tenantId: string
+  organizationId?: string | null
+}
+
+type ResolverContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+async function resolveShortfallSku(
+  ctx: ResolverContext,
+  catalogVariantId: string,
+  organizationId: string | null | undefined,
+  tenantId: string,
+): Promise<string> {
+  try {
+    const queryEngine = ctx.resolve<QueryEngine>('queryEngine')
+    const result = await queryEngine.query(E.catalog.catalog_product_variant, {
+      tenantId,
+      organizationId: organizationId ?? undefined,
+      filters: { id: { $eq: catalogVariantId } },
+      fields: ['id', 'sku', 'name'],
+      page: { page: 1, pageSize: 1 },
+    })
+    const row = result.items?.[0] as { sku?: string | null; name?: string | null } | undefined
+    const sku = typeof row?.sku === 'string' ? row.sku.trim() : ''
+    if (sku) return sku
+    const name = typeof row?.name === 'string' ? row.name.trim() : ''
+    if (name) return name
+  } catch {
+    // fall through to variant id
+  }
+  return catalogVariantId
+}
+
+export default async function handle(payload: ShortfallPayload, ctx: ResolverContext) {
+  try {
+    const notificationService = resolveNotificationService(ctx)
+    const typeDef = notificationTypes.find((type) => type.type === 'wms.inventory.reservation_shortfall')
+    if (!typeDef) return
+
+    const primaryShortfall = payload.shortfalls[0]
+    const shortfallSku = primaryShortfall
+      ? await resolveShortfallSku(
+          ctx,
+          primaryShortfall.catalogVariantId,
+          payload.organizationId,
+          payload.tenantId,
+        )
+      : ''
+    const shortfallQuantity = primaryShortfall ? String(primaryShortfall.shortfallQuantity) : '0'
+    const notificationInput = buildFeatureNotificationFromType(typeDef, {
+      requiredFeature: 'wms.view',
+      bodyVariables: {
+        orderNumber: payload.orderNumber ?? payload.orderId,
+        shortfallCount: String(payload.shortfalls.length),
+        shortfallSku,
+        shortfallQuantity,
+        shortfallVariantId: primaryShortfall?.catalogVariantId ?? '',
+      },
+      sourceEntityType: 'sales:order',
+      sourceEntityId: payload.orderId,
+      linkHref: `/backend/sales/orders/${encodeURIComponent(payload.orderId)}`,
+    })
+
+    await notificationService.createForFeature(notificationInput, {
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    })
+  } catch (error) {
+    logger.error('Failed to create notification', { subscriber: 'reservation-shortfall-notification', err: error })
+  }
+}

package/src/modules/wms/subscribers/sales-order-cancelled-release.ts

@@ -0,0 +1,21 @@
+import { releaseInventoryForCancelledOrder } from '../lib/salesOrderInventoryAutomation'
+
+export const metadata = {
+  event: 'sales.order.cancelled',
+  persistent: true,
+  id: 'wms:sales-order-cancelled-release',
+}
+
+type SubscriberContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+type SalesOrderCancelledPayload = {
+  orderId?: string | null
+  tenantId?: string | null
+  organizationId?: string | null
+}
+
+export default async function handle(payload: SalesOrderCancelledPayload, ctx: SubscriberContext) {
+  await releaseInventoryForCancelledOrder(payload, ctx)
+}

package/src/modules/wms/subscribers/sales-order-confirmed-reserve.ts

@@ -0,0 +1,21 @@
+import { reserveInventoryForConfirmedOrder } from '../lib/salesOrderInventoryAutomation'
+
+export const metadata = {
+  event: 'sales.order.confirmed',
+  persistent: true,
+  id: 'wms:sales-order-confirmed-reserve',
+}
+
+type SubscriberContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+type SalesOrderConfirmedPayload = {
+  orderId?: string | null
+  tenantId?: string | null
+  organizationId?: string | null
+}
+
+export default async function handle(payload: SalesOrderConfirmedPayload, ctx: SubscriberContext) {
+  await reserveInventoryForConfirmedOrder(payload, ctx)
+}

package/src/modules/wms/translations.ts

@@ -0,0 +1,6 @@
+export const translatableFields: Record<string, string[]> = {
+  'wms:warehouse': ['name'],
+  'wms:warehouse_zone': ['name'],
+}
+
+export default translatableFields

package/src/modules/wms/vector.ts

@@ -0,0 +1,7 @@
+import type { VectorModuleConfig } from '@open-mercato/shared/modules/vector'
+
+export const vectorConfig: VectorModuleConfig | null = null
+
+export const config = vectorConfig
+
+export default vectorConfig

package/src/modules/wms/widgets/injection/catalog-inventory-profile/widget.ts

@@ -0,0 +1,238 @@
+import type { InjectionFieldWidget } from '@open-mercato/shared/modules/widgets/injection'
+import {
+  encodeCatalogInventoryProfileIntent,
+  WMS_CATALOG_PROFILE_HEADER,
+  type CatalogInventoryProfileIntent,
+} from '../../../lib/catalogInventoryProfileIntent'
+
+type RecordLike = Record<string, unknown>
+
+function asRecord(value: unknown): RecordLike | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  return value as RecordLike
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function readBoolean(value: unknown): boolean {
+  return value === true
+}
+
+function readNumber(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+  if (typeof value === 'string' && value.trim().length > 0) {
+    const parsed = Number(value)
+    if (Number.isFinite(parsed)) return parsed
+  }
+  return undefined
+}
+
+function buildIntent(data: RecordLike): CatalogInventoryProfileIntent {
+  return {
+    manageInventory: readBoolean(data['wms.manageInventory']),
+    defaultUom: readString(data['wms.defaultUom']).trim() || null,
+    defaultStrategy: (() => {
+      const strategy = readString(data['wms.defaultStrategy']).trim()
+      return strategy === 'fifo' || strategy === 'lifo' || strategy === 'fefo'
+        ? strategy
+        : undefined
+    })(),
+    trackLot: readBoolean(data['wms.trackLot']),
+    trackSerial: readBoolean(data['wms.trackSerial']),
+    trackExpiration: readBoolean(data['wms.trackExpiration']),
+    reorderPoint: readNumber(data['wms.reorderPoint']) ?? 0,
+    safetyStock: readNumber(data['wms.safetyStock']) ?? 0,
+  }
+}
+
+function buildDisplayState(data: RecordLike): RecordLike {
+  const wms = asRecord(data._wms)
+  const inventoryProfile = asRecord(wms?.inventoryProfile)
+  const fallbackDefaultUom = readString(data.defaultUnit).trim()
+
+  return {
+    ...data,
+    'wms.manageInventory': Boolean(inventoryProfile),
+    'wms.defaultUom':
+      readString(inventoryProfile?.defaultUom).trim() ||
+      fallbackDefaultUom,
+    'wms.defaultStrategy':
+      readString(inventoryProfile?.defaultStrategy).trim() || 'fifo',
+    'wms.trackLot': readBoolean(inventoryProfile?.trackLot),
+    'wms.trackSerial': readBoolean(inventoryProfile?.trackSerial),
+    'wms.trackExpiration': readBoolean(inventoryProfile?.trackExpiration),
+    'wms.reorderPoint':
+      readNumber(inventoryProfile?.reorderPoint) ?? 0,
+    'wms.safetyStock':
+      readNumber(inventoryProfile?.safetyStock) ?? 0,
+  }
+}
+
+const visibleWhenManaged = {
+  field: 'wms.manageInventory',
+  operator: 'eq' as const,
+  value: true,
+}
+
+const widget: InjectionFieldWidget = {
+  metadata: {
+    id: 'wms.injection.catalog-inventory-profile',
+    priority: 120,
+    features: ['wms.manage_inventory'],
+  },
+  fields: [
+    {
+      id: 'wms.manageInventory',
+      label: 'Manage inventory with WMS',
+      labelKey: 'wms.widgets.catalog.inventoryProfile.manageInventory',
+      type: 'boolean',
+      group: 'wms.inventoryProfile',
+    },
+    {
+      id: 'wms.defaultUom',
+      label: 'Default UOM',
+      labelKey: 'wms.widgets.catalog.inventoryProfile.defaultUom',
+      type: 'text',
+      group: 'wms.inventoryProfile',
+      visibleWhen: visibleWhenManaged,
+    },
+    {
+      id: 'wms.defaultStrategy',
+      label: 'Rotation strategy',
+      labelKey: 'wms.widgets.catalog.inventoryProfile.defaultStrategy',
+      type: 'select',
+      group: 'wms.inventoryProfile',
+      visibleWhen: visibleWhenManaged,
+      options: [
+        {
+          value: 'fifo',
+          label: 'FIFO',
+          labelKey: 'wms.widgets.catalog.inventoryProfile.strategy.fifo',
+        },
+        {
+          value: 'lifo',
+          label: 'LIFO',
+          labelKey: 'wms.widgets.catalog.inventoryProfile.strategy.lifo',
+        },
+        {
+          value: 'fefo',
+          label: 'FEFO',
+          labelKey: 'wms.widgets.catalog.inventoryProfile.strategy.fefo',
+        },
+      ],
+    },
+    {
+      id: 'wms.trackLot',
+      label: 'Track lots',
+      labelKey: 'wms.widgets.catalog.inventoryProfile.trackLot',
+      type: 'boolean',
+      group: 'wms.inventoryProfile',
+      visibleWhen: visibleWhenManaged,
+    },
+    {
+      id: 'wms.trackSerial',
+      label: 'Track serials',
+      labelKey: 'wms.widgets.catalog.inventoryProfile.trackSerial',
+      type: 'boolean',
+      group: 'wms.inventoryProfile',
+      visibleWhen: visibleWhenManaged,
+    },
+    {
+      id: 'wms.trackExpiration',
+      label: 'Track expiration',
+      labelKey: 'wms.widgets.catalog.inventoryProfile.trackExpiration',
+      type: 'boolean',
+      group: 'wms.inventoryProfile',
+      visibleWhen: visibleWhenManaged,
+    },
+    {
+      id: 'wms.reorderPoint',
+      label: 'Reorder point',
+      labelKey: 'wms.widgets.catalog.inventoryProfile.reorderPoint',
+      type: 'number',
+      group: 'wms.inventoryProfile',
+      visibleWhen: visibleWhenManaged,
+    },
+    {
+      id: 'wms.safetyStock',
+      label: 'Safety stock',
+      labelKey: 'wms.widgets.catalog.inventoryProfile.safetyStock',
+      type: 'number',
+      group: 'wms.inventoryProfile',
+      visibleWhen: visibleWhenManaged,
+    },
+  ],
+  eventHandlers: {
+    async transformDisplayData(data) {
+      const source = asRecord(data)
+      if (!source) return data
+      return buildDisplayState(source) as typeof data
+    },
+    async onBeforeSave(data) {
+      const source = asRecord(data)
+      if (!source) return { ok: true }
+
+      const intent = buildIntent(source)
+      if (!intent.manageInventory) {
+        return {
+          ok: true,
+          requestHeaders: {
+            [WMS_CATALOG_PROFILE_HEADER]:
+              encodeCatalogInventoryProfileIntent(intent),
+          },
+        }
+      }
+
+      const fieldErrors: Record<string, string> = {}
+      if (!intent.defaultUom) {
+        fieldErrors['wms.defaultUom'] =
+          'wms.widgets.catalog.inventoryProfile.errors.defaultUomRequired'
+      }
+      if (!intent.defaultStrategy) {
+        fieldErrors['wms.defaultStrategy'] =
+          'wms.widgets.catalog.inventoryProfile.errors.strategyRequired'
+      }
+      if (
+        intent.trackExpiration &&
+        intent.defaultStrategy &&
+        intent.defaultStrategy !== 'fefo'
+      ) {
+        fieldErrors['wms.defaultStrategy'] =
+          'wms.widgets.catalog.inventoryProfile.errors.fefoRequired'
+      }
+      if (
+        typeof intent.reorderPoint === 'number' &&
+        intent.reorderPoint < 0
+      ) {
+        fieldErrors['wms.reorderPoint'] =
+          'wms.widgets.catalog.inventoryProfile.errors.nonNegative'
+      }
+      if (
+        typeof intent.safetyStock === 'number' &&
+        intent.safetyStock < 0
+      ) {
+        fieldErrors['wms.safetyStock'] =
+          'wms.widgets.catalog.inventoryProfile.errors.nonNegative'
+      }
+
+      if (Object.keys(fieldErrors).length > 0) {
+        return {
+          ok: false,
+          fieldErrors,
+        }
+      }
+
+      return {
+        ok: true,
+        requestHeaders: {
+          [WMS_CATALOG_PROFILE_HEADER]:
+            encodeCatalogInventoryProfileIntent(intent),
+        },
+      }
+    },
+  },
+}
+
+export default widget

package/src/modules/wms/widgets/injection/order-items-stock-column/widget.tsx

@@ -0,0 +1,153 @@
+'use client'
+
+import * as React from 'react'
+import type { InjectionColumnWidget } from '@open-mercato/shared/modules/widgets/injection'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { useOrderItemsInjectionContext } from '@open-mercato/core/modules/sales/widgets/injection/order-items-context'
+
+type WmsStockEntry = {
+  catalogVariantId: string
+  available: string
+  reserved: string
+}
+
+type WmsOrderListResponse = {
+  items?: Array<{
+    _wms?: {
+      stockSummary?: WmsStockEntry[]
+    }
+  }>
+}
+
+const CACHE_TTL_MS = 60_000
+
+type CacheEntry = {
+  data: WmsStockEntry[]
+  fetchedAt: number
+}
+
+const orderStockCache = new Map<string, CacheEntry>()
+const pendingFetches = new Map<string, Promise<void>>()
+
+function getCachedStock(documentId: string): WmsStockEntry[] | null {
+  const entry = orderStockCache.get(documentId)
+  if (!entry) return null
+  if (Date.now() - entry.fetchedAt > CACHE_TTL_MS) {
+    orderStockCache.delete(documentId)
+    return null
+  }
+  return entry.data
+}
+
+async function fetchOrderStock(documentId: string): Promise<void> {
+  if (getCachedStock(documentId) !== null) return
+  if (pendingFetches.has(documentId)) return pendingFetches.get(documentId)
+
+  const promise = apiCall<WmsOrderListResponse>(`/api/sales/orders?id=${documentId}`)
+    .then((res) => {
+      const summary = res.result?.items?.[0]?._wms?.stockSummary ?? []
+      orderStockCache.set(documentId, { data: summary, fetchedAt: Date.now() })
+    })
+    .catch(() => {
+      orderStockCache.set(documentId, { data: [], fetchedAt: Date.now() })
+    })
+    .finally(() => {
+      pendingFetches.delete(documentId)
+    })
+
+  pendingFetches.set(documentId, promise)
+  return promise
+}
+
+function WmsOrderItemStockCell({ getValue }: { getValue: () => unknown }) {
+  const t = useT()
+  const ctx = useOrderItemsInjectionContext()
+  const variantId = getValue() as string | null
+
+  const [stock, setStock] = React.useState<WmsStockEntry | null | undefined>(
+    () => {
+      if (!variantId || !ctx?.documentId) return undefined
+      const summary = getCachedStock(ctx.documentId)
+      if (!summary) return undefined
+      return summary.find((e) => e.catalogVariantId === variantId) ?? null
+    },
+  )
+
+  React.useEffect(() => {
+    if (!variantId || !ctx?.documentId) return
+    const documentId = ctx.documentId
+
+    const cached = getCachedStock(documentId)
+    if (cached) {
+      setStock(cached.find((e) => e.catalogVariantId === variantId) ?? null)
+      return
+    }
+
+    let cancelled = false
+    void fetchOrderStock(documentId).then(() => {
+      if (cancelled) return
+      const summary = getCachedStock(documentId) ?? []
+      setStock(summary.find((e) => e.catalogVariantId === variantId) ?? null)
+    })
+
+    return () => {
+      cancelled = true
+    }
+  }, [variantId, ctx?.documentId])
+
+  if (!variantId || ctx?.kind !== 'order') return null
+
+  if (stock === undefined) {
+    return (
+      <span className="text-xs text-muted-foreground">
+        {t('wms.widgets.sales.orderItems.stockColumn.loading', '…')}
+      </span>
+    )
+  }
+
+  if (stock === null) {
+    return (
+      <span className="text-xs text-muted-foreground">
+        {t('wms.widgets.sales.orderItems.stockColumn.noData', '—')}
+      </span>
+    )
+  }
+
+  return (
+    <div className="flex flex-col gap-0.5 text-xs">
+      <span className="font-medium tabular-nums">
+        {stock.available}{' '}
+        <span className="font-normal text-muted-foreground">
+          {t('wms.widgets.sales.orderItems.stockColumn.available', 'avail.')}
+        </span>
+      </span>
+      {Number(stock.reserved) > 0 && (
+        <span className="text-muted-foreground tabular-nums">
+          {stock.reserved}{' '}
+          {t('wms.widgets.sales.orderItems.stockColumn.reserved', 'reserved')}
+        </span>
+      )}
+    </div>
+  )
+}
+
+const widget: InjectionColumnWidget = {
+  metadata: {
+    id: 'wms.injection.order-items-stock-column',
+    priority: 50,
+    features: ['wms.view'],
+  },
+  columns: [
+    {
+      id: 'wms_warehouse_stock',
+      headerKey: 'wms.widgets.sales.orderItems.stockColumn.header',
+      header: 'Warehouse Stock',
+      accessorKey: 'productVariantId',
+      sortable: false,
+      cell: WmsOrderItemStockCell,
+    },
+  ],
+}
+
+export default widget