@open-mercato/core 0.6.7-develop.6669.1.40b669666b → 0.6.7-develop.6671.1.4b925c5096

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)
+}

package/src/modules/wms/api/locations/route.ts

@@ -0,0 +1,171 @@
+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 { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
+import { E } from '#generated/entities.ids.generated'
+import { WarehouseLocation } from '../../data/entities'
+import { warehouseLocationCreateSchema, warehouseLocationUpdateSchema } from '../../data/validators'
+import { createPagedListResponseSchema, createWmsCrudOpenApi, defaultOkResponseSchema } from '../openapi'
+import { attachWarehouseLabelsToListItems } from '../listEnrichers'
+
+const routeMetadata = {
+  GET: { requireAuth: true, requireFeatures: ['wms.view'] },
+  POST: { requireAuth: true, requireFeatures: ['wms.manage_locations'] },
+  PUT: { requireAuth: true, requireFeatures: ['wms.manage_locations'] },
+  DELETE: { requireAuth: true, requireFeatures: ['wms.manage_locations'] },
+}
+
+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),
+  search: z.string().optional(),
+  warehouseId: z.string().uuid().optional(),
+  parentId: z.string().uuid().optional(),
+  type: z.enum(['zone', 'aisle', 'rack', 'bin', 'slot', 'dock', 'staging']).optional(),
+  isActive: 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: WarehouseLocation,
+    idField: 'id',
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+    softDeleteField: 'deletedAt',
+  },
+  indexer: { entityType: E.wms.warehouse_location },
+  list: {
+    schema: listSchema,
+    entityId: E.wms.warehouse_location,
+    fields: [
+      'id',
+      'organization_id',
+      'tenant_id',
+      'warehouse_id',
+      'parent_id',
+      'code',
+      'type',
+      'is_active',
+      'capacity_units',
+      'capacity_weight',
+      'created_at',
+      'updated_at',
+    ],
+    sortFieldMap: {
+      code: 'code',
+      type: 'type',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    },
+    buildFilters: async (query) => {
+      const filters: Record<string, unknown> = {}
+      if (query.warehouseId) filters.warehouse_id = { $eq: query.warehouseId }
+      if (query.parentId) filters.parent_id = { $eq: query.parentId }
+      if (query.type) filters.type = { $eq: query.type }
+      const isActive = parseBooleanToken(query.isActive)
+      if (isActive !== null) filters.is_active = { $eq: isActive }
+      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),
+        }
+      }
+      const term = query.search?.trim()
+      if (term) {
+        const like = `%${escapeLikePattern(term)}%`
+        filters.$or = [
+          { code: { $ilike: like } },
+          { type: { $ilike: like } },
+        ]
+      }
+      return filters
+    },
+  },
+  hooks: {
+    afterList: async (payload, ctx) => {
+      await attachWarehouseLabelsToListItems(payload, ctx)
+    },
+  },
+  actions: {
+    create: {
+      commandId: 'wms.locations.create',
+      schema: rawBodySchema,
+      mapInput: async ({ raw, ctx }) => {
+        const { translate } = await resolveTranslations()
+        return parseScopedCommandInput(warehouseLocationCreateSchema, raw ?? {}, ctx, translate)
+      },
+      response: ({ result }) => ({ id: result?.locationId ?? null }),
+      status: 201,
+    },
+    update: {
+      commandId: 'wms.locations.update',
+      schema: rawBodySchema,
+      mapInput: async ({ raw, ctx }) => {
+        const { translate } = await resolveTranslations()
+        return parseScopedCommandInput(warehouseLocationUpdateSchema, raw ?? {}, ctx, translate)
+      },
+      response: () => ({ ok: true }),
+    },
+    delete: {
+      commandId: 'wms.locations.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 locationListItemSchema = z.object({
+  id: z.string().uuid().nullable().optional(),
+  organization_id: z.string().uuid().nullable().optional(),
+  tenant_id: z.string().uuid().nullable().optional(),
+  warehouse_id: z.string().uuid().nullable().optional(),
+  warehouse_name: z.string().nullable().optional(),
+  warehouse_code: z.string().nullable().optional(),
+  parent_id: z.string().uuid().nullable().optional(),
+  code: z.string().nullable().optional(),
+  type: z.string().nullable().optional(),
+  is_active: z.boolean().nullable().optional(),
+  capacity_units: z.union([z.string(), z.number()]).nullable().optional(),
+  capacity_weight: 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: 'Warehouse location',
+  pluralName: 'Warehouse locations',
+  querySchema: listSchema,
+  listResponseSchema: createPagedListResponseSchema(locationListItemSchema),
+  create: {
+    schema: warehouseLocationCreateSchema,
+    description: 'Creates a storage location within a warehouse hierarchy.',
+  },
+  update: {
+    schema: warehouseLocationUpdateSchema,
+    responseSchema: defaultOkResponseSchema,
+    description: 'Updates a warehouse location by id.',
+  },
+  del: {
+    schema: z.object({ id: z.string().uuid() }),
+    responseSchema: defaultOkResponseSchema,
+    description: 'Soft-deletes a warehouse location by id.',
+  },
+})

package/src/modules/wms/api/lots/route.ts

@@ -0,0 +1,205 @@
+import { z } from 'zod'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { parseScopedCommandInput, resolveCrudRecordId } from '@open-mercato/shared/lib/api/scoped'
+import { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
+import { E } from '#generated/entities.ids.generated'
+import { InventoryLot } from '../../data/entities'
+import { inventoryLotCreateSchema, inventoryLotUpdateSchema } from '../../data/validators'
+import { buildExpiryWindowDateFilter, type ExpiryWindow } from '../../lib/expiry'
+import { createPagedListResponseSchema, createWmsCrudOpenApi, defaultOkResponseSchema } from '../openapi'
+
+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),
+  search: z.string().optional(),
+  catalogVariantId: z.string().uuid().optional(),
+  status: z.enum(['available', 'hold', 'quarantine', 'expired']).optional(),
+  expiryWindow: z.enum(['expiringSoon', 'pastDue']).optional(),
+  warehouseId: z.string().uuid().optional(),
+  ids: z.string().optional(),
+  sortField: z.string().optional(),
+  sortDir: z.enum(['asc', 'desc']).optional(),
+}).passthrough()
+
+const crud = makeCrudRoute({
+  metadata: routeMetadata,
+  orm: {
+    entity: InventoryLot,
+    idField: 'id',
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+    softDeleteField: 'deletedAt',
+  },
+  indexer: { entityType: E.wms.inventory_lot },
+  list: {
+    schema: listSchema,
+    entityId: E.wms.inventory_lot,
+    fields: [
+      'id',
+      'organization_id',
+      'tenant_id',
+      'catalog_variant_id',
+      'sku',
+      'lot_number',
+      'batch_number',
+      'manufactured_at',
+      'best_before_at',
+      'expires_at',
+      'status',
+      'metadata',
+      'created_at',
+      'updated_at',
+    ],
+    sortFieldMap: {
+      lotNumber: 'lot_number',
+      sku: 'sku',
+      status: 'status',
+      expiresAt: 'expires_at',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    },
+    buildFilters: async (query, ctx) => {
+      const filters: Record<string, unknown> = {}
+      if (query.catalogVariantId) filters.catalog_variant_id = { $eq: query.catalogVariantId }
+      if (query.status) filters.status = { $eq: query.status }
+      if (query.expiryWindow) {
+        Object.assign(filters, buildExpiryWindowDateFilter(query.expiryWindow as ExpiryWindow))
+      }
+      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),
+        }
+      }
+      const requiresAvailableStock =
+        Boolean(query.warehouseId) || query.expiryWindow === 'pastDue'
+      if (requiresAvailableStock) {
+        const organizationId = ctx.selectedOrganizationId
+        const tenantId = ctx.auth?.tenantId
+        if (organizationId && tenantId) {
+          const em = ctx.container.resolve('em') as EntityManager
+          const balanceParams: unknown[] = [organizationId, tenantId]
+          let balanceSql = `
+            select distinct lot_id
+            from wms_inventory_balances
+            where organization_id = ?
+              and tenant_id = ?
+              and deleted_at is null
+              and lot_id is not null
+              and (
+                coalesce(quantity_on_hand, 0)
+                - coalesce(quantity_reserved, 0)
+                - coalesce(quantity_allocated, 0)
+              ) > 0`
+          if (query.warehouseId) {
+            balanceSql += ' and warehouse_id = ?'
+            balanceParams.push(query.warehouseId)
+          }
+          const rows = await em.getConnection().execute<Array<{ lot_id: string }>>(
+            balanceSql,
+            balanceParams,
+          )
+          const lotIds = rows.map((row) => row.lot_id).filter((value) => value.length > 0)
+          filters.id = {
+            $in: lotIds.length > 0 ? lotIds : ['00000000-0000-4000-8000-000000000000'],
+          }
+        }
+      }
+      const term = query.search?.trim()
+      if (term) {
+        const like = `%${escapeLikePattern(term)}%`
+        filters.$or = [
+          { sku: { $ilike: like } },
+          { lot_number: { $ilike: like } },
+          { batch_number: { $ilike: like } },
+        ]
+      }
+      return filters
+    },
+  },
+  actions: {
+    create: {
+      commandId: 'wms.lots.create',
+      schema: rawBodySchema,
+      mapInput: async ({ raw, ctx }) => {
+        const { translate } = await resolveTranslations()
+        return parseScopedCommandInput(inventoryLotCreateSchema, raw ?? {}, ctx, translate)
+      },
+      response: ({ result }) => ({ id: result?.lotId ?? null }),
+      status: 201,
+    },
+    update: {
+      commandId: 'wms.lots.update',
+      schema: rawBodySchema,
+      mapInput: async ({ raw, ctx }) => {
+        const { translate } = await resolveTranslations()
+        return parseScopedCommandInput(inventoryLotUpdateSchema, raw ?? {}, ctx, translate)
+      },
+      response: () => ({ ok: true }),
+    },
+    delete: {
+      commandId: 'wms.lots.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 lotListItemSchema = z.object({
+  id: z.string().uuid().nullable().optional(),
+  organization_id: z.string().uuid().nullable().optional(),
+  tenant_id: z.string().uuid().nullable().optional(),
+  catalog_variant_id: z.string().uuid().nullable().optional(),
+  sku: z.string().nullable().optional(),
+  lot_number: z.string().nullable().optional(),
+  batch_number: z.string().nullable().optional(),
+  manufactured_at: z.string().nullable().optional(),
+  best_before_at: z.string().nullable().optional(),
+  expires_at: z.string().nullable().optional(),
+  status: z.string().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+  created_at: z.string().nullable().optional(),
+  updated_at: z.string().nullable().optional(),
+})
+
+export const openApi = createWmsCrudOpenApi({
+  resourceName: 'Inventory lot',
+  pluralName: 'Inventory lots',
+  querySchema: listSchema,
+  listResponseSchema: createPagedListResponseSchema(lotListItemSchema),
+  create: {
+    schema: inventoryLotCreateSchema,
+    description: 'Creates an inventory lot or batch record.',
+  },
+  update: {
+    schema: inventoryLotUpdateSchema,
+    responseSchema: defaultOkResponseSchema,
+    description: 'Updates an inventory lot by id.',
+  },
+  del: {
+    schema: z.object({ id: z.string().uuid() }),
+    responseSchema: defaultOkResponseSchema,
+    description: 'Soft-deletes an inventory lot by id.',
+  },
+})

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

@@ -0,0 +1,28 @@
+import { type ZodTypeAny } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import {
+  createCrudOpenApiFactory,
+  createPagedListResponseSchema as createSharedPagedListResponseSchema,
+  defaultCreateResponseSchema as sharedDefaultCreateResponseSchema,
+  defaultOkResponseSchema as sharedDefaultOkResponseSchema,
+  type CrudOpenApiOptions,
+} from '@open-mercato/shared/lib/openapi/crud'
+
+export const defaultCreateResponseSchema = sharedDefaultCreateResponseSchema
+export const defaultOkResponseSchema = sharedDefaultOkResponseSchema
+
+export function createPagedListResponseSchema(itemSchema: ZodTypeAny) {
+  return createSharedPagedListResponseSchema(itemSchema, { paginationMetaOptional: true })
+}
+
+const buildWmsCrudOpenApi = createCrudOpenApiFactory({
+  defaultTag: 'WMS',
+  defaultCreateResponseSchema,
+  defaultOkResponseSchema,
+  makeListDescription: ({ pluralLower }) =>
+    `Returns a paginated collection of ${pluralLower} scoped to the authenticated organization.`,
+})
+
+export function createWmsCrudOpenApi(options: CrudOpenApiOptions): OpenApiRouteDoc {
+  return buildWmsCrudOpenApi(options)
+}

package/src/modules/wms/api/sales-orders/[salesOrderId]/re-run-reservation/route.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { readJsonSafe } from '@open-mercato/shared/lib/http/readJsonSafe'
+import { executeWmsCustomPostRoute } from '../../../inventory/helpers'
+import { reRunReservationInputSchema } from '../../../../commands/sales-order-assignment'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['wms.manage_reservations'] },
+}
+
+const paramsSchema = z.object({
+  salesOrderId: z.string().uuid(),
+})
+
+export async function POST(
+  request: Request,
+  routeContext: { params: { salesOrderId: string } },
+) {
+  const parsedParams = paramsSchema.parse(routeContext.params)
+  const body = await readJsonSafe<Record<string, unknown>>(request, {})
+  const scopedRequest = new Request(request.url, {
+    method: 'POST',
+    headers: request.headers,
+    body: JSON.stringify({ ...body, salesOrderId: parsedParams.salesOrderId }),
+  })
+  return executeWmsCustomPostRoute({
+    request: scopedRequest,
+    routePath: `wms/sales-orders/${parsedParams.salesOrderId}/re-run-reservation`,
+    inputSchema: reRunReservationInputSchema,
+    commandId: 'wms.sales-order.re-run-reservation',
+    describeResource: (input) => ({
+      resourceKind: 'wms.sales_order_reservation',
+      resourceId: input.salesOrderId,
+    }),
+    mapSuccess: () => ({ ok: true }),
+  })
+}
+
+const successSchema = z.object({ ok: z.literal(true) })
+const errorSchema = z.object({ error: z.string() })
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Re-run reservation for sales order',
+  methods: {
+    POST: {
+      summary: 'Re-run reservation for sales order',
+      description:
+        'Triggers the automatic reservation logic for a sales order, attempting to fill any remaining shortfall.',
+      responses: [{ status: 200, description: 'Reservation re-run attempted', schema: successSchema }],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+        { status: 404, description: 'Order not found', schema: errorSchema },
+      ],
+    },
+  },
+}