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

package/src/modules/wms/api/inventory/import/validate/route.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { inventoryImportValidateSchema } from '../../../../data/validators'
+import { executeWmsInventoryImportRoute } from '../helpers'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['wms.import'] },
+}
+
+export async function POST(request: Request) {
+  return executeWmsInventoryImportRoute({
+    request,
+    routePath: 'wms/inventory/import/validate',
+    mode: 'validate',
+  })
+}
+
+const rowResultSchema = z.object({
+  rowNumber: z.number(),
+  status: z.enum(['valid', 'error', 'warning', 'skip']),
+  errors: z.array(z.string()),
+  warnings: z.array(z.string()),
+})
+
+const successSchema = z.object({
+  ok: z.boolean(),
+  importBatchId: z.string().uuid(),
+  summary: z.object({
+    totalRows: z.number(),
+    validRows: z.number(),
+    errorRows: z.number(),
+    warningRows: z.number(),
+    skipRows: z.number(),
+  }),
+  rows: z.array(rowResultSchema),
+})
+
+const errorSchema = z.object({ error: z.string() })
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Validate inventory CSV import',
+  methods: {
+    POST: {
+      summary: 'Validate inventory CSV import',
+      description:
+        'Dry-run validation for inventory import CSV rows. By default (mode "additive"), quantity is added to existing on-hand stock; opt into mode "reconcile" to instead treat quantity as the absolute target balance (overwrites existing stock, including reducing it). Accepts JSON rows, JSON csv text, or multipart file upload.',
+      requestBody: { contentType: 'application/json', schema: inventoryImportValidateSchema },
+      responses: [{ status: 200, description: 'Validation report', schema: successSchema }],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+      ],
+    },
+  },
+}

package/src/modules/wms/api/inventory/move/route.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { inventoryMoveSchema } from '../../../data/validators'
+import { executeWmsCustomPostRoute } from '../helpers'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['wms.adjust_inventory'] },
+}
+
+export async function POST(request: Request) {
+  return executeWmsCustomPostRoute({
+    request,
+    routePath: 'wms/inventory/move',
+    inputSchema: inventoryMoveSchema,
+    commandId: 'wms.inventory.move',
+    describeResource: (input) => ({
+      resourceKind: 'wms.inventory',
+      resourceId: `${input.warehouseId}:${input.fromLocationId}:${input.catalogVariantId}`,
+    }),
+    mapSuccess: (result: { movementId: string }) => ({
+      ok: true,
+      movementId: result.movementId,
+    }),
+  })
+}
+
+const successSchema = z.object({
+  ok: z.literal(true),
+  movementId: z.string().uuid(),
+})
+const errorSchema = z.object({ error: z.string() })
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Move inventory',
+  methods: {
+    POST: {
+      summary: 'Move inventory',
+      description: 'Moves stock from one location to another within a warehouse and appends a transfer movement.',
+      requestBody: { contentType: 'application/json', schema: inventoryMoveSchema },
+      responses: [{ status: 200, description: 'Inventory moved', schema: successSchema }],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+        { status: 409, description: 'Insufficient stock', schema: errorSchema },
+        { status: 422, description: 'Invalid location', schema: errorSchema },
+      ],
+    },
+  },
+}

package/src/modules/wms/api/inventory/movements/route.ts

@@ -0,0 +1,164 @@
+import { z } from 'zod'
+import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
+import { E } from '#generated/entities.ids.generated'
+import { InventoryMovement } from '../../../data/entities'
+import { inventoryMovementListQuerySchema } from '../../../data/validators'
+import { createPagedListResponseSchema } from '../../openapi'
+import {
+  attachLocationLabelsToListItems,
+  attachVariantLabelsToListItems,
+  attachWarehouseLabelsToListItems,
+} from '../../listEnrichers'
+import { buildInventoryListSearchOrFilters } from '../../listSearch'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['wms.view'] },
+}
+
+const crud = makeCrudRoute({
+  metadata,
+  orm: {
+    entity: InventoryMovement,
+    idField: 'id',
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+    softDeleteField: 'deletedAt',
+  },
+  indexer: { entityType: E.wms.inventory_movement },
+  list: {
+    schema: inventoryMovementListQuerySchema,
+    entityId: E.wms.inventory_movement,
+    disableListCache: true,
+    fields: [
+      'id',
+      'organization_id',
+      'tenant_id',
+      'warehouse_id',
+      'location_from_id',
+      'location_to_id',
+      'catalog_variant_id',
+      'lot_id',
+      'serial_number',
+      'quantity',
+      'type',
+      'reference_type',
+      'reference_id',
+      'performed_by',
+      'performed_at',
+      'received_at',
+      'reason',
+      'reason_code',
+      'created_at',
+      'updated_at',
+    ],
+    sortFieldMap: {
+      catalogVariantId: 'catalog_variant_id',
+      warehouseId: 'warehouse_id',
+      quantity: 'quantity',
+      type: 'type',
+      performedAt: 'performed_at',
+      receivedAt: 'received_at',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    },
+    buildFilters: async (query, ctx) => {
+      const filters: Record<string, unknown> = {}
+      if (query.warehouseId) filters.warehouse_id = { $eq: query.warehouseId }
+      if (query.catalogVariantId) filters.catalog_variant_id = { $eq: query.catalogVariantId }
+      if (query.lotId) filters.lot_id = { $eq: query.lotId }
+      if (query.referenceType) filters.reference_type = { $eq: query.referenceType }
+      if (query.referenceId) filters.reference_id = { $eq: query.referenceId }
+      if (query.type) filters.type = { $eq: query.type }
+      const andFilters: Record<string, unknown>[] = []
+      if (query.locationId) {
+        andFilters.push({
+          $or: [
+            { location_from_id: { $eq: query.locationId } },
+            { location_to_id: { $eq: query.locationId } },
+          ],
+        })
+      }
+      const term = query.search?.trim()
+      if (term) {
+        andFilters.push({
+          $or: await buildInventoryListSearchOrFilters(ctx, term, escapeLikePattern, {
+            extraFieldFilters: (like) => [
+              { reason: { $ilike: like } },
+              { reason_code: { $ilike: like } },
+            ],
+          }),
+        })
+      }
+      if (andFilters.length === 1) {
+        Object.assign(filters, andFilters[0])
+      } else if (andFilters.length > 1) {
+        filters.$and = andFilters
+      }
+      return filters
+    },
+  },
+  hooks: {
+    afterList: async (payload, ctx) => {
+      await Promise.all([
+        attachWarehouseLabelsToListItems(payload, ctx),
+        attachLocationLabelsToListItems(payload, ctx),
+        attachVariantLabelsToListItems(payload, ctx),
+      ])
+    },
+  },
+})
+
+export const GET = crud.GET
+
+const movementListItemSchema = 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(),
+  location_from_id: z.string().uuid().nullable().optional(),
+  location_from_code: z.string().nullable().optional(),
+  location_from_type: z.string().nullable().optional(),
+  location_to_id: z.string().uuid().nullable().optional(),
+  location_to_code: z.string().nullable().optional(),
+  location_to_type: z.string().nullable().optional(),
+  catalog_variant_id: z.string().uuid().nullable().optional(),
+  catalog_product_id: z.string().uuid().nullable().optional(),
+  variant_name: z.string().nullable().optional(),
+  variant_sku: z.string().nullable().optional(),
+  lot_id: z.string().uuid().nullable().optional(),
+  serial_number: z.string().nullable().optional(),
+  quantity: z.union([z.string(), z.number()]).nullable().optional(),
+  type: z.string().nullable().optional(),
+  reference_type: z.string().nullable().optional(),
+  reference_id: z.string().uuid().nullable().optional(),
+  performed_by: z.string().uuid().nullable().optional(),
+  performed_at: z.string().nullable().optional(),
+  received_at: z.string().nullable().optional(),
+  reason: z.string().nullable().optional(),
+  reason_code: z.string().nullable().optional(),
+  created_at: z.string().nullable().optional(),
+  updated_at: z.string().nullable().optional(),
+})
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Inventory movements',
+  methods: {
+    GET: {
+      summary: 'List inventory movements',
+      description: 'Returns paginated inventory ledger entries for the authenticated organization.',
+      query: inventoryMovementListQuerySchema,
+      responses: [
+        {
+          status: 200,
+          description: 'Inventory movements collection',
+          schema: createPagedListResponseSchema(movementListItemSchema),
+        },
+      ],
+    },
+  },
+}

package/src/modules/wms/api/inventory/receive/route.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { inventoryReceiveSchema } from '../../../data/validators'
+import { executeWmsCustomPostRoute } from '../helpers'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['wms.receive_inventory'] },
+}
+
+export async function POST(request: Request) {
+  return executeWmsCustomPostRoute({
+    request,
+    routePath: 'wms/inventory/receive',
+    inputSchema: inventoryReceiveSchema,
+    commandId: 'wms.inventory.receive',
+    describeResource: (input) => ({
+      resourceKind: 'wms.inventory',
+      resourceId: `${input.warehouseId}:${input.locationId}:${input.catalogVariantId}`,
+    }),
+    mapSuccess: (result: { movementId: string }) => ({
+      ok: true,
+      movementId: result.movementId,
+    }),
+  })
+}
+
+const successSchema = z.object({
+  ok: z.literal(true),
+  movementId: z.string().uuid(),
+})
+const errorSchema = z.object({ error: z.string() })
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Receive inventory',
+  methods: {
+    POST: {
+      summary: 'Receive inventory',
+      description: 'Records inbound inventory receipt and appends a receipt movement ledger row.',
+      requestBody: { contentType: 'application/json', schema: inventoryReceiveSchema },
+      responses: [{ status: 200, description: 'Inventory received', schema: successSchema }],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+        { status: 422, description: 'Invalid location', schema: errorSchema },
+      ],
+    },
+  },
+}

package/src/modules/wms/api/inventory/release/route.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { inventoryReservationReleaseSchema } from '../../../data/validators'
+import { executeWmsCustomPostRoute } from '../helpers'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['wms.manage_reservations'] },
+}
+
+export async function POST(request: Request) {
+  return executeWmsCustomPostRoute({
+    request,
+    routePath: 'wms/inventory/release',
+    inputSchema: inventoryReservationReleaseSchema,
+    commandId: 'wms.inventory.release',
+    describeResource: (input) => ({
+      resourceKind: 'wms.inventoryReservation',
+      resourceId: input.reservationId,
+    }),
+    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: 'Release reservation',
+  methods: {
+    POST: {
+      summary: 'Release reservation',
+      description: 'Releases a previously reserved or allocated inventory reservation.',
+      requestBody: { contentType: 'application/json', schema: inventoryReservationReleaseSchema },
+      responses: [{ status: 200, description: 'Reservation released', schema: successSchema }],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+        { status: 404, description: 'Reservation not found', schema: errorSchema },
+      ],
+    },
+  },
+}

package/src/modules/wms/api/inventory/reservations/route.ts

@@ -0,0 +1,128 @@
+import { z } from 'zod'
+import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
+import { E } from '#generated/entities.ids.generated'
+import { InventoryReservation } from '../../../data/entities'
+import { inventoryReservationListQuerySchema } from '../../../data/validators'
+import { createPagedListResponseSchema } from '../../openapi'
+import {
+  attachReservationSourceLabelsToListItems,
+  attachVariantLabelsToListItems,
+  attachWarehouseLabelsToListItems,
+} from '../../listEnrichers'
+import { buildReservationSearchOrFilters } from '../../listSearch'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['wms.view'] },
+}
+
+const crud = makeCrudRoute({
+  metadata,
+  orm: {
+    entity: InventoryReservation,
+    idField: 'id',
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+    softDeleteField: 'deletedAt',
+  },
+  indexer: { entityType: E.wms.inventory_reservation },
+  list: {
+    schema: inventoryReservationListQuerySchema,
+    entityId: E.wms.inventory_reservation,
+    disableListCache: true,
+    fields: [
+      'id',
+      'organization_id',
+      'tenant_id',
+      'warehouse_id',
+      'catalog_variant_id',
+      'lot_id',
+      'serial_number',
+      'quantity',
+      'source_type',
+      'source_id',
+      'expires_at',
+      'status',
+      'created_at',
+      'updated_at',
+    ],
+    sortFieldMap: {
+      catalogVariantId: 'catalog_variant_id',
+      warehouseId: 'warehouse_id',
+      quantity: 'quantity',
+      sourceType: 'source_type',
+      status: 'status',
+      expiresAt: 'expires_at',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    },
+    buildFilters: async (query, ctx) => {
+      const filters: Record<string, unknown> = {}
+      if (query.warehouseId) filters.warehouse_id = { $eq: query.warehouseId }
+      if (query.catalogVariantId) filters.catalog_variant_id = { $eq: query.catalogVariantId }
+      if (query.lotId) filters.lot_id = { $eq: query.lotId }
+      if (query.sourceType) filters.source_type = { $eq: query.sourceType }
+      if (query.sourceId) filters.source_id = { $eq: query.sourceId }
+      if (query.status) filters.status = { $eq: query.status }
+      const term = query.search?.trim()
+      if (term) {
+        filters.$or = await buildReservationSearchOrFilters(ctx, term, escapeLikePattern)
+      }
+      return filters
+    },
+  },
+  hooks: {
+    afterList: async (payload, ctx) => {
+      await Promise.all([
+        attachWarehouseLabelsToListItems(payload, ctx),
+        attachVariantLabelsToListItems(payload, ctx),
+        attachReservationSourceLabelsToListItems(payload, ctx),
+      ])
+    },
+  },
+})
+
+export const GET = crud.GET
+
+const reservationListItemSchema = 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(),
+  catalog_variant_id: z.string().uuid().nullable().optional(),
+  catalog_product_id: z.string().uuid().nullable().optional(),
+  variant_name: z.string().nullable().optional(),
+  variant_sku: z.string().nullable().optional(),
+  lot_id: z.string().uuid().nullable().optional(),
+  serial_number: z.string().nullable().optional(),
+  quantity: z.union([z.string(), z.number()]).nullable().optional(),
+  source_type: z.string().nullable().optional(),
+  source_id: z.string().uuid().nullable().optional(),
+  source_label: z.string().nullable().optional(),
+  expires_at: z.string().nullable().optional(),
+  status: z.string().nullable().optional(),
+  created_at: z.string().nullable().optional(),
+  updated_at: z.string().nullable().optional(),
+})
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Inventory reservations',
+  methods: {
+    GET: {
+      summary: 'List inventory reservations',
+      description: 'Returns paginated inventory reservations for the authenticated organization.',
+      query: inventoryReservationListQuerySchema,
+      responses: [
+        {
+          status: 200,
+          description: 'Inventory reservations collection',
+          schema: createPagedListResponseSchema(reservationListItemSchema),
+        },
+      ],
+    },
+  },
+}

package/src/modules/wms/api/inventory/reserve/route.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { inventoryReservationCreateSchema } from '../../../data/validators'
+import { executeWmsCustomPostRoute } from '../helpers'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['wms.manage_reservations'] },
+}
+
+export async function POST(request: Request) {
+  return executeWmsCustomPostRoute({
+    request,
+    routePath: 'wms/inventory/reserve',
+    inputSchema: inventoryReservationCreateSchema,
+    commandId: 'wms.inventory.reserve',
+    describeResource: (input) => ({
+      resourceKind: 'wms.inventory',
+      resourceId: `${input.warehouseId}:${input.catalogVariantId}`,
+    }),
+    mapSuccess: (result: { reservationId: string; allocatedBuckets: Array<{ locationId: string; lotId: string | null; quantity: string }> }) => ({
+      ok: true,
+      reservationId: result.reservationId,
+      allocatedBuckets: result.allocatedBuckets,
+    }),
+  })
+}
+
+const successSchema = z.object({
+  ok: z.literal(true),
+  reservationId: z.string().uuid(),
+  allocatedBuckets: z.array(
+    z.object({
+      locationId: z.string().uuid(),
+      lotId: z.string().uuid().nullable(),
+      quantity: z.string(),
+    }),
+  ),
+})
+
+const errorSchema = z.object({ error: z.string() })
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Reserve inventory',
+  methods: {
+    POST: {
+      summary: 'Reserve inventory',
+      description: 'Creates an inventory reservation and assigns available buckets using the configured stock strategy.',
+      requestBody: { contentType: 'application/json', schema: inventoryReservationCreateSchema },
+      responses: [{ status: 200, description: 'Inventory reserved', schema: successSchema }],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+        { status: 409, description: 'Insufficient stock', schema: errorSchema },
+        { status: 422, description: 'Invalid tracking state', schema: errorSchema },
+      ],
+    },
+  },
+}