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

package/src/modules/wms/api/inventory-profiles/route.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod'
+import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
+import { parseScopedCommandInput, resolveCrudRecordId } from '@open-mercato/shared/lib/api/scoped'
+import { E } from '#generated/entities.ids.generated'
+import { ProductInventoryProfile } from '../../data/entities'
+import {
+  productInventoryProfileCreateSchema,
+  productInventoryProfileUpdateSchema,
+} from '../../data/validators'
+import { createPagedListResponseSchema, createWmsCrudOpenApi, defaultOkResponseSchema } from '../openapi'
+import { attachInventoryProfileCatalogLabelsToListItems } from '../listEnrichers'
+
+const routeMetadata = {
+  GET: { requireAuth: true, requireFeatures: ['wms.view'] },
+  POST: { requireAuth: true, requireFeatures: ['wms.manage_inventory'] },
+  PUT: { requireAuth: true, requireFeatures: ['wms.manage_inventory'] },
+  DELETE: { requireAuth: true, requireFeatures: ['wms.manage_inventory'] },
+}
+
+export const metadata = routeMetadata
+
+const rawBodySchema = z.object({}).passthrough()
+
+const listSchema = z.object({
+  page: z.coerce.number().min(1).default(1),
+  pageSize: z.coerce.number().min(1).max(100).default(25),
+  catalogProductId: z.string().uuid().optional(),
+  catalogVariantId: z.string().uuid().optional(),
+  defaultStrategy: z.enum(['fifo', 'lifo', 'fefo']).optional(),
+  trackLot: z.string().optional(),
+  trackSerial: z.string().optional(),
+  trackExpiration: z.string().optional(),
+  ids: z.string().optional(),
+  sortField: z.string().optional(),
+  sortDir: z.enum(['asc', 'desc']).optional(),
+}).passthrough()
+
+const crud = makeCrudRoute({
+  metadata: routeMetadata,
+  orm: {
+    entity: ProductInventoryProfile,
+    idField: 'id',
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+    softDeleteField: 'deletedAt',
+  },
+  indexer: { entityType: E.wms.product_inventory_profile },
+  list: {
+    schema: listSchema,
+    entityId: E.wms.product_inventory_profile,
+    fields: [
+      'id',
+      'organization_id',
+      'tenant_id',
+      'catalog_product_id',
+      'catalog_variant_id',
+      'default_uom',
+      'track_lot',
+      'track_serial',
+      'track_expiration',
+      'default_strategy',
+      'reorder_point',
+      'safety_stock',
+      'created_at',
+      'updated_at',
+    ],
+    sortFieldMap: {
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+      defaultStrategy: 'default_strategy',
+      reorderPoint: 'reorder_point',
+      safetyStock: 'safety_stock',
+    },
+    buildFilters: async (query) => {
+      const filters: Record<string, unknown> = {}
+      if (query.catalogProductId) filters.catalog_product_id = { $eq: query.catalogProductId }
+      if (query.catalogVariantId) filters.catalog_variant_id = { $eq: query.catalogVariantId }
+      if (query.defaultStrategy) filters.default_strategy = { $eq: query.defaultStrategy }
+      const trackLot = parseBooleanToken(query.trackLot)
+      const trackSerial = parseBooleanToken(query.trackSerial)
+      const trackExpiration = parseBooleanToken(query.trackExpiration)
+      if (trackLot !== null) filters.track_lot = { $eq: trackLot }
+      if (trackSerial !== null) filters.track_serial = { $eq: trackSerial }
+      if (trackExpiration !== null) filters.track_expiration = { $eq: trackExpiration }
+      if (typeof query.ids === 'string' && query.ids.trim().length > 0) {
+        filters.id = {
+          $in: query.ids.split(',').map((value) => value.trim()).filter((value) => value.length > 0),
+        }
+      }
+      return filters
+    },
+  },
+  hooks: {
+    afterList: async (payload, ctx) => {
+      await attachInventoryProfileCatalogLabelsToListItems(payload, ctx)
+    },
+  },
+  actions: {
+    create: {
+      commandId: 'wms.inventoryProfiles.create',
+      schema: rawBodySchema,
+      mapInput: async ({ raw, ctx }) => {
+        const { translate } = await resolveTranslations()
+        return parseScopedCommandInput(productInventoryProfileCreateSchema, raw ?? {}, ctx, translate)
+      },
+      response: ({ result }) => ({ id: result?.profileId ?? null }),
+      status: 201,
+    },
+    update: {
+      commandId: 'wms.inventoryProfiles.update',
+      schema: rawBodySchema,
+      mapInput: async ({ raw, ctx }) => {
+        const { translate } = await resolveTranslations()
+        return parseScopedCommandInput(productInventoryProfileUpdateSchema, raw ?? {}, ctx, translate)
+      },
+      response: () => ({ ok: true }),
+    },
+    delete: {
+      commandId: 'wms.inventoryProfiles.delete',
+      schema: rawBodySchema,
+      mapInput: async ({ parsed, ctx }) => {
+        const { translate } = await resolveTranslations()
+        return { id: resolveCrudRecordId(parsed, ctx, translate) }
+      },
+      response: () => ({ ok: true }),
+    },
+  },
+})
+
+export const GET = crud.GET
+export const POST = crud.POST
+export const PUT = crud.PUT
+export const DELETE = crud.DELETE
+
+const profileListItemSchema = z.object({
+  id: z.string().uuid().nullable().optional(),
+  organization_id: z.string().uuid().nullable().optional(),
+  tenant_id: z.string().uuid().nullable().optional(),
+  catalog_product_id: z.string().uuid().nullable().optional(),
+  catalog_variant_id: z.string().uuid().nullable().optional(),
+  product_title: z.string().nullable().optional(),
+  product_sku: z.string().nullable().optional(),
+  variant_name: z.string().nullable().optional(),
+  variant_sku: z.string().nullable().optional(),
+  default_uom: z.string().nullable().optional(),
+  track_lot: z.boolean().nullable().optional(),
+  track_serial: z.boolean().nullable().optional(),
+  track_expiration: z.boolean().nullable().optional(),
+  default_strategy: z.string().nullable().optional(),
+  reorder_point: z.union([z.string(), z.number()]).nullable().optional(),
+  safety_stock: z.union([z.string(), z.number()]).nullable().optional(),
+  created_at: z.string().nullable().optional(),
+  updated_at: z.string().nullable().optional(),
+})
+
+export const openApi = createWmsCrudOpenApi({
+  resourceName: 'Inventory profile',
+  pluralName: 'Inventory profiles',
+  querySchema: listSchema,
+  listResponseSchema: createPagedListResponseSchema(profileListItemSchema),
+  create: {
+    schema: productInventoryProfileCreateSchema,
+    description: 'Creates a product inventory profile.',
+  },
+  update: {
+    schema: productInventoryProfileUpdateSchema,
+    responseSchema: defaultOkResponseSchema,
+    description: 'Updates an inventory profile by id.',
+  },
+  del: {
+    schema: z.object({ id: z.string().uuid() }),
+    responseSchema: defaultOkResponseSchema,
+    description: 'Soft-deletes an inventory profile by id.',
+  },
+})

package/src/modules/wms/api/listEnrichers.ts

@@ -0,0 +1,312 @@
+// Lightweight afterList enrichers shared across WMS list routes.
+//
+// These run inside `makeCrudRoute({ hooks: { afterList } })` and batch-resolve
+// foreign-key labels (e.g. warehouse_id -> warehouse_name) so backend tables
+// can render the human-readable label without N+1 lookups on the client.
+//
+// We deliberately use the `queryEngine` (entity-id-based) rather than ORM
+// entity classes so this file stays decoupled from `wms/data/entities`
+// internals and from the catalog ORM — same pattern used by High #5 in WMS
+// data enrichers.
+
+import type { CrudCtx } from '@open-mercato/shared/lib/crud/factory'
+import type { QueryEngine } from '@open-mercato/shared/lib/query/types'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { E } from '#generated/entities.ids.generated'
+
+const logger = createLogger('wms')
+
+type AnyListPayload = {
+  items?: Array<Record<string, unknown>>
+}
+
+type LookupRow = Record<string, unknown> & { id?: string | null }
+
+const LOOKUP_BATCH_SIZE = 500
+
+function uniqueIdsFromKeys(
+  items: Array<Record<string, unknown>>,
+  keys: string[],
+): string[] {
+  const set = new Set<string>()
+  for (const item of items) {
+    for (const key of keys) {
+      const value = item?.[key]
+      if (typeof value === 'string' && value.length > 0) set.add(value)
+    }
+  }
+  return Array.from(set)
+}
+
+/**
+ * Internal: batch-load `entityId` rows by primary id through the QueryEngine
+ * and return them keyed by id. Splits requests into chunks of 500. Errors are
+ * logged (with a `source` tag for grep-ability) and degrade to an empty map so
+ * the surrounding list response still goes through.
+ */
+async function batchLoadById(
+  ctx: CrudCtx,
+  entityId: string,
+  ids: string[],
+  fields: string[],
+  source: string,
+): Promise<Map<string, LookupRow>> {
+  if (ids.length === 0) return new Map()
+  const tenantId = ctx.auth?.tenantId
+  if (!tenantId) return new Map()
+  const queryEngine = ctx.container.resolve('queryEngine') as QueryEngine
+  const map = new Map<string, LookupRow>()
+  for (let offset = 0; offset < ids.length; offset += LOOKUP_BATCH_SIZE) {
+    const slice = ids.slice(offset, offset + LOOKUP_BATCH_SIZE)
+    try {
+      const result = await queryEngine.query<LookupRow>(entityId, {
+        tenantId,
+        organizationId: ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? undefined,
+        organizationIds: ctx.organizationIds ?? undefined,
+        filters: { id: { $in: slice } },
+        fields,
+        page: { page: 1, pageSize: slice.length },
+      })
+      for (const row of result.items ?? []) {
+        if (row?.id && typeof row.id === 'string') map.set(row.id, row)
+      }
+    } catch (err) {
+      logger.warn('batch lookup failed', { source, entityId, err })
+    }
+  }
+  return map
+}
+
+function decorateOnce(item: Record<string, unknown>, key: string, value: unknown): void {
+  if (item[key] === undefined) item[key] = value
+}
+
+// ---------------------------------------------------------------------------
+// Warehouses
+// ---------------------------------------------------------------------------
+
+type WarehouseRow = LookupRow & { name?: string | null; code?: string | null }
+
+const WAREHOUSE_FIELDS = ['id', 'name', 'code']
+
+/**
+ * Decorate list items with `warehouse_name` and `warehouse_code` when they
+ * carry a `warehouse_id` column. Mutates `payload.items` in place.
+ */
+export async function attachWarehouseLabelsToListItems(
+  payload: AnyListPayload,
+  ctx: CrudCtx,
+): Promise<void> {
+  const items = Array.isArray(payload?.items) ? payload.items : []
+  if (items.length === 0) return
+  const ids = uniqueIdsFromKeys(items, ['warehouse_id'])
+  if (ids.length === 0) return
+  const map = (await batchLoadById(
+    ctx,
+    E.wms.warehouse,
+    ids,
+    WAREHOUSE_FIELDS,
+    'warehouse',
+  )) as Map<string, WarehouseRow>
+  if (map.size === 0) return
+  for (const item of items) {
+    const id = item?.warehouse_id
+    if (typeof id !== 'string' || !id) continue
+    const row = map.get(id)
+    if (!row) continue
+    decorateOnce(item, 'warehouse_name', row.name ?? null)
+    decorateOnce(item, 'warehouse_code', row.code ?? null)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Locations
+// ---------------------------------------------------------------------------
+
+type LocationLookupRow = LookupRow & { code?: string | null; type?: string | null }
+
+const LOCATION_FIELDS = ['id', 'code', 'type']
+
+/**
+ * Decorate list items with location label/type for any of these foreign-key
+ * columns: `location_id`, `location_from_id`, `location_to_id`. The decorated
+ * fields follow the same prefix:
+ *
+ *   location_id        -> location_code, location_type
+ *   location_from_id   -> location_from_code, location_from_type
+ *   location_to_id     -> location_to_code, location_to_type
+ *
+ * Mutates `payload.items` in place.
+ */
+export async function attachLocationLabelsToListItems(
+  payload: AnyListPayload,
+  ctx: CrudCtx,
+): Promise<void> {
+  const items = Array.isArray(payload?.items) ? payload.items : []
+  if (items.length === 0) return
+  const fkColumns = ['location_id', 'location_from_id', 'location_to_id']
+  const ids = uniqueIdsFromKeys(items, fkColumns)
+  if (ids.length === 0) return
+  const map = (await batchLoadById(
+    ctx,
+    E.wms.warehouse_location,
+    ids,
+    LOCATION_FIELDS,
+    'location',
+  )) as Map<string, LocationLookupRow>
+  if (map.size === 0) return
+  for (const item of items) {
+    for (const fk of fkColumns) {
+      const id = item?.[fk]
+      if (typeof id !== 'string' || !id) continue
+      const row = map.get(id)
+      if (!row) continue
+      const prefix = fk.replace(/_id$/, '')
+      decorateOnce(item, `${prefix}_code`, row.code ?? null)
+      decorateOnce(item, `${prefix}_type`, row.type ?? null)
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Catalog variants
+// ---------------------------------------------------------------------------
+
+type VariantLookupRow = LookupRow & {
+  name?: string | null
+  sku?: string | null
+  product_id?: string | null
+}
+
+const VARIANT_FIELDS = ['id', 'name', 'sku', 'product_id']
+
+/**
+ * Decorate list items with `variant_name`, `variant_sku`, and `product_id`
+ * when they carry a `catalog_variant_id` column. Mutates `payload.items` in
+ * place. Uses `queryEngine.query(E.catalog.catalog_product_variant, ...)`
+ * rather than importing the catalog ORM entity directly, to keep the WMS
+ * module decoupled from the catalog package internals.
+ */
+export async function attachVariantLabelsToListItems(
+  payload: AnyListPayload,
+  ctx: CrudCtx,
+): Promise<void> {
+  const items = Array.isArray(payload?.items) ? payload.items : []
+  if (items.length === 0) return
+  const ids = uniqueIdsFromKeys(items, ['catalog_variant_id'])
+  if (ids.length === 0) return
+  const map = (await batchLoadById(
+    ctx,
+    E.catalog.catalog_product_variant,
+    ids,
+    VARIANT_FIELDS,
+    'variant',
+  )) as Map<string, VariantLookupRow>
+  if (map.size === 0) return
+  for (const item of items) {
+    const id = item?.catalog_variant_id
+    if (typeof id !== 'string' || !id) continue
+    const row = map.get(id)
+    if (!row) continue
+    decorateOnce(item, 'variant_name', row.name ?? null)
+    decorateOnce(item, 'variant_sku', row.sku ?? null)
+    decorateOnce(item, 'catalog_product_id', row.product_id ?? null)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Catalog products
+// ---------------------------------------------------------------------------
+
+type ProductLookupRow = LookupRow & { title?: string | null; sku?: string | null }
+
+const PRODUCT_FIELDS = ['id', 'title', 'sku']
+
+/**
+ * Decorate list items with `product_title` and `product_sku` when they carry a
+ * `catalog_product_id` column. Mutates `payload.items` in place.
+ */
+export async function attachProductLabelsToListItems(
+  payload: AnyListPayload,
+  ctx: CrudCtx,
+): Promise<void> {
+  const items = Array.isArray(payload?.items) ? payload.items : []
+  if (items.length === 0) return
+  const ids = uniqueIdsFromKeys(items, ['catalog_product_id'])
+  if (ids.length === 0) return
+  const map = (await batchLoadById(
+    ctx,
+    E.catalog.catalog_product,
+    ids,
+    PRODUCT_FIELDS,
+    'product',
+  )) as Map<string, ProductLookupRow>
+  if (map.size === 0) return
+  for (const item of items) {
+    const id = item?.catalog_product_id
+    if (typeof id !== 'string' || !id) continue
+    const row = map.get(id)
+    if (!row) continue
+    decorateOnce(item, 'product_title', row.title ?? null)
+    decorateOnce(item, 'product_sku', row.sku ?? null)
+  }
+}
+
+/**
+ * Decorate inventory profile rows with catalog product and variant labels.
+ * Mutates `payload.items` in place.
+ */
+export async function attachInventoryProfileCatalogLabelsToListItems(
+  payload: AnyListPayload,
+  ctx: CrudCtx,
+): Promise<void> {
+  await Promise.all([
+    attachProductLabelsToListItems(payload, ctx),
+    attachVariantLabelsToListItems(payload, ctx),
+  ])
+}
+
+// ---------------------------------------------------------------------------
+// Reservation sources
+// ---------------------------------------------------------------------------
+
+type SalesOrderLookupRow = LookupRow & { order_number?: string | null }
+
+const SALES_ORDER_FIELDS = ['id', 'order_number']
+
+/**
+ * Decorate reservation rows with `source_label` when the source can be resolved
+ * to a human-readable reference (currently sales orders). Mutates
+ * `payload.items` in place.
+ */
+export async function attachReservationSourceLabelsToListItems(
+  payload: AnyListPayload,
+  ctx: CrudCtx,
+): Promise<void> {
+  const items = Array.isArray(payload?.items) ? payload.items : []
+  if (items.length === 0) return
+
+  const orderIds = uniqueIdsFromKeys(
+    items.filter((item) => item?.source_type === 'order'),
+    ['source_id'],
+  )
+  if (orderIds.length === 0) return
+
+  const map = (await batchLoadById(
+    ctx,
+    E.sales.sales_order,
+    orderIds,
+    SALES_ORDER_FIELDS,
+    'reservation-source',
+  )) as Map<string, SalesOrderLookupRow>
+  if (map.size === 0) return
+
+  for (const item of items) {
+    if (item?.source_type !== 'order') continue
+    const id = item?.source_id
+    if (typeof id !== 'string' || !id) continue
+    const row = map.get(id)
+    const orderNumber = row?.order_number?.trim()
+    if (orderNumber) decorateOnce(item, 'source_label', orderNumber)
+  }
+}

package/src/modules/wms/api/listSearch.ts

@@ -0,0 +1,121 @@
+import type { CrudCtx } from '@open-mercato/shared/lib/crud/factory'
+import type { QueryEngine } from '@open-mercato/shared/lib/query/types'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { E } from '#generated/entities.ids.generated'
+
+const logger = createLogger('wms')
+
+const SEARCH_PAGE_SIZE = 100
+
+async function queryMatchingIds(
+  ctx: CrudCtx,
+  entityId: string,
+  filters: Record<string, unknown>,
+  source: string,
+): Promise<string[]> {
+  const tenantId = ctx.auth?.tenantId
+  if (!tenantId) return []
+  try {
+    const queryEngine = ctx.container.resolve('queryEngine') as QueryEngine
+    const result = await queryEngine.query<{ id?: string | null }>(entityId, {
+      tenantId,
+      organizationId: ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? undefined,
+      organizationIds: ctx.organizationIds ?? undefined,
+      filters,
+      fields: ['id'],
+      page: { page: 1, pageSize: SEARCH_PAGE_SIZE },
+    })
+    return (result.items ?? [])
+      .map((row) => (typeof row?.id === 'string' ? row.id : null))
+      .filter((id): id is string => Boolean(id))
+  } catch (err) {
+    logger.warn('lookup failed', { source, entityId, err })
+    return []
+  }
+}
+
+/**
+ * Resolve warehouse ids whose name or code matches an already-escaped ILIKE term
+ * (e.g. `%midnight%`). Used by reservation/balance list search so operators can
+ * find rows by the labels shown in the table, not only serial numbers.
+ */
+export async function resolveWarehouseIdsMatchingSearch(
+  ctx: CrudCtx,
+  like: string,
+): Promise<string[]> {
+  return queryMatchingIds(
+    ctx,
+    E.wms.warehouse,
+    {
+      $or: [
+        { name: { $ilike: like } },
+        { code: { $ilike: like } },
+      ],
+    },
+    'warehouse-search',
+  )
+}
+
+/**
+ * Resolve catalog variant ids whose name or SKU matches an already-escaped
+ * ILIKE term. Decoupled from catalog ORM via QueryEngine (same as list enrichers).
+ */
+export async function resolveVariantIdsMatchingSearch(
+  ctx: CrudCtx,
+  like: string,
+): Promise<string[]> {
+  return queryMatchingIds(
+    ctx,
+    E.catalog.catalog_product_variant,
+    {
+      $or: [
+        { name: { $ilike: like } },
+        { sku: { $ilike: like } },
+      ],
+    },
+    'variant-search',
+  )
+}
+
+/**
+ * Build a list `$or` clause that matches serial number, warehouse label, or
+ * variant name/SKU for the given search term. Optional `extraFieldFilters`
+ * appends additional ILIKE clauses (e.g. movement reason fields).
+ */
+export async function buildInventoryListSearchOrFilters(
+  ctx: CrudCtx,
+  term: string,
+  escapeLike: (value: string) => string,
+  options?: {
+    extraFieldFilters?: (like: string) => Array<Record<string, unknown>>
+  },
+): Promise<Array<Record<string, unknown>>> {
+  const like = `%${escapeLike(term)}%`
+  const orFilters: Array<Record<string, unknown>> = [{ serial_number: { $ilike: like } }]
+  if (options?.extraFieldFilters) {
+    orFilters.push(...options.extraFieldFilters(like))
+  }
+  const [warehouseIds, variantIds] = await Promise.all([
+    resolveWarehouseIdsMatchingSearch(ctx, like),
+    resolveVariantIdsMatchingSearch(ctx, like),
+  ])
+  if (warehouseIds.length > 0) {
+    orFilters.push({ warehouse_id: { $in: warehouseIds } })
+  }
+  if (variantIds.length > 0) {
+    orFilters.push({ catalog_variant_id: { $in: variantIds } })
+  }
+  return orFilters
+}
+
+/**
+ * Build a reservation-list `$or` clause that matches serial number, warehouse
+ * label, or variant name/SKU for the given search term.
+ */
+export async function buildReservationSearchOrFilters(
+  ctx: CrudCtx,
+  term: string,
+  escapeLike: (value: string) => string,
+): Promise<Array<Record<string, unknown>>> {
+  return buildInventoryListSearchOrFilters(ctx, term, escapeLike)
+}