@open-mercato/core 0.6.7-develop.6669.1.40b669666b → 0.6.7-develop.6670.1.4efa7961c6

package/src/modules/wms/api/dashboard/operational/route.ts

@@ -0,0 +1,83 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import {
+  operationalDashboardQuerySchema,
+  operationalDashboardResponseSchema,
+} from '../../../data/validators'
+import {
+  loadOperationalDashboard,
+  OperationalDashboardWarehouseNotFoundError,
+} from '../../../lib/loadOperationalDashboard'
+
+const logger = createLogger('wms')
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['wms.view'] },
+}
+
+export async function GET(request: Request) {
+  try {
+    const url = new URL(request.url)
+    const parsedQuery = operationalDashboardQuerySchema.parse(Object.fromEntries(url.searchParams.entries()))
+    const container = await createRequestContainer()
+    const auth = await getAuthFromRequest(request)
+    if (!auth?.tenantId) {
+      throw new CrudHttpError(401, { error: 'Unauthorized' })
+    }
+    const organizationScope = await resolveOrganizationScopeForRequest({
+      container,
+      auth,
+      request,
+    })
+    const organizationId = organizationScope?.selectedId ?? auth.orgId ?? null
+    if (!organizationId) {
+      throw new CrudHttpError(401, { error: 'Unauthorized' })
+    }
+
+    const em = (container.resolve('em') as EntityManager).fork()
+    const payload = await loadOperationalDashboard(em, {
+      organizationId,
+      tenantId: auth.tenantId,
+      warehouseId: parsedQuery.warehouseId ?? null,
+    })
+
+    return NextResponse.json(operationalDashboardResponseSchema.parse(payload))
+  } catch (error) {
+    if (error instanceof OperationalDashboardWarehouseNotFoundError) {
+      return NextResponse.json({ error: 'Warehouse not found' }, { status: 404 })
+    }
+    if (error instanceof CrudHttpError) {
+      return NextResponse.json(error.body, { status: error.status })
+    }
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: 'Validation failed', details: error.issues }, { status: 400 })
+    }
+    logger.error('GET operational dashboard failed', { err: error })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Operational dashboard',
+  description:
+    'Aggregated KPIs, expiry watch lot rows (`expiryLots`), monthly movement trends, and recent activity for the WMS operational dashboard.',
+  methods: {
+    GET: {
+      summary: 'Load operational dashboard data',
+      query: operationalDashboardQuerySchema,
+      responses: [
+        { status: 200, description: 'Dashboard payload', schema: operationalDashboardResponseSchema },
+        { status: 401, description: 'Unauthorized' },
+        { status: 404, description: 'Warehouse not found' },
+      ],
+    },
+  },
+}

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

@@ -0,0 +1,108 @@
+import type { ApiInterceptor } from '@open-mercato/shared/lib/crud/api-interceptor'
+import {
+  decodeCatalogInventoryProfileIntent,
+  WMS_CATALOG_PROFILE_HEADER,
+} from '../lib/catalogInventoryProfileIntent'
+import {
+  syncCatalogInventoryProfile,
+} from '../lib/catalogInventoryProfileSync'
+
+function resolveRecordId(
+  requestBody: Record<string, unknown> | undefined,
+  responseBody: Record<string, unknown> | undefined,
+): string | null {
+  const responseId = responseBody?.id
+  if (typeof responseId === 'string' && responseId.trim().length > 0) {
+    return responseId
+  }
+
+  const requestId = requestBody?.id
+  if (typeof requestId === 'string' && requestId.trim().length > 0) {
+    return requestId
+  }
+
+  return null
+}
+
+export const interceptors: ApiInterceptor[] = [
+  {
+    id: 'wms.catalog-products.inventory-profile-sync',
+    targetRoute: 'catalog/products',
+    methods: ['POST', 'PUT'],
+    priority: 120,
+    async before(request) {
+      const rawHeader = request.headers[WMS_CATALOG_PROFILE_HEADER]
+      if (!rawHeader) return { ok: true }
+
+      const intent = decodeCatalogInventoryProfileIntent(rawHeader)
+      return {
+        ok: true,
+        metadata: { intent, target: 'product' },
+      }
+    },
+    async after(request, response, context) {
+      if (response.statusCode >= 400) return {}
+
+      const metadata = context.metadata as
+        | { intent?: ReturnType<typeof decodeCatalogInventoryProfileIntent>; target?: 'product' | 'variant' }
+        | undefined
+      if (!metadata?.intent) return {}
+
+      const recordId = resolveRecordId(request.body, response.body)
+      if (!recordId) return {}
+
+      await syncCatalogInventoryProfile({
+        intent: metadata.intent,
+        target: 'product',
+        recordId,
+        organizationId: context.organizationId,
+        tenantId: context.tenantId,
+        userId: context.userId,
+        container: context.container,
+      })
+
+      return {}
+    },
+  },
+  {
+    id: 'wms.catalog-variants.inventory-profile-sync',
+    targetRoute: 'catalog/variants',
+    methods: ['POST', 'PUT'],
+    priority: 120,
+    async before(request) {
+      const rawHeader = request.headers[WMS_CATALOG_PROFILE_HEADER]
+      if (!rawHeader) return { ok: true }
+
+      const intent = decodeCatalogInventoryProfileIntent(rawHeader)
+      return {
+        ok: true,
+        metadata: { intent, target: 'variant' },
+      }
+    },
+    async after(request, response, context) {
+      if (response.statusCode >= 400) return {}
+
+      const metadata = context.metadata as
+        | { intent?: ReturnType<typeof decodeCatalogInventoryProfileIntent>; target?: 'product' | 'variant' }
+        | undefined
+      if (!metadata?.intent) return {}
+
+      const recordId = resolveRecordId(request.body, response.body)
+      if (!recordId) return {}
+
+      await syncCatalogInventoryProfile({
+        intent: metadata.intent,
+        target: 'variant',
+        recordId,
+        organizationId: context.organizationId,
+        tenantId: context.tenantId,
+        userId: context.userId,
+        container: context.container,
+      })
+
+      return {}
+    },
+  },
+]
+
+export default interceptors

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

@@ -0,0 +1,50 @@
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { inventoryAdjustSchema } 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/adjust',
+    inputSchema: inventoryAdjustSchema,
+    commandId: 'wms.inventory.adjust',
+    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: 'Adjust inventory',
+  methods: {
+    POST: {
+      summary: 'Adjust inventory',
+      description: 'Applies a manual inventory adjustment and appends a movement ledger row.',
+      requestBody: { contentType: 'application/json', schema: inventoryAdjustSchema },
+      responses: [{ status: 200, description: 'Inventory adjusted', 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/allocate/route.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { inventoryReservationAllocateSchema } 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/allocate',
+    inputSchema: inventoryReservationAllocateSchema,
+    commandId: 'wms.inventory.allocate',
+    describeResource: (input) => ({
+      resourceKind: 'wms.inventoryReservation',
+      resourceId: input.reservationId,
+    }),
+    mapSuccess: (result: { allocationState: 'allocated' }) => ({
+      ok: true,
+      allocationState: result.allocationState,
+    }),
+  })
+}
+
+const successSchema = z.object({
+  ok: z.literal(true),
+  allocationState: z.literal('allocated'),
+})
+const errorSchema = z.object({ error: z.string() })
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Allocate reservation',
+  methods: {
+    POST: {
+      summary: 'Allocate reservation',
+      description: 'Converts a reservation from reserved quantity into allocated quantity on the selected stock buckets.',
+      requestBody: { contentType: 'application/json', schema: inventoryReservationAllocateSchema },
+      responses: [{ status: 200, description: 'Reservation allocated', schema: successSchema }],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+        { status: 404, description: 'Reservation not found', schema: errorSchema },
+        { status: 409, description: 'Invalid reservation state', schema: errorSchema },
+      ],
+    },
+  },
+}

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

@@ -0,0 +1,178 @@
+import { z } from 'zod'
+import type { EntityManager } from '@mikro-orm/postgresql'
+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 { InventoryBalance } from '../../../data/entities'
+import { inventoryBalanceListQuerySchema } from '../../../data/validators'
+import {
+  formatLowStockVariantIdsForFilter,
+  resolveLowStockVariantIds,
+} from '../../../lib/lowStockBalanceFilter'
+import { createPagedListResponseSchema } from '../../openapi'
+import {
+  attachLocationLabelsToListItems,
+  attachVariantLabelsToListItems,
+  attachWarehouseLabelsToListItems,
+} from '../../listEnrichers'
+import { buildInventoryListSearchOrFilters } from '../../listSearch'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['wms.view'] },
+}
+
+export function transformInventoryBalanceListItem(
+  item: Record<string, unknown>,
+): Record<string, unknown> {
+  const onHand = Number(item.quantity_on_hand ?? 0)
+  const reserved = Number(item.quantity_reserved ?? 0)
+  const allocated = Number(item.quantity_allocated ?? 0)
+  const rawAvailable = item.quantity_available
+  return {
+    ...item,
+    quantity_available: rawAvailable != null ? Number(rawAvailable) : onHand - reserved - allocated,
+  }
+}
+
+const crud = makeCrudRoute({
+  metadata,
+  orm: {
+    entity: InventoryBalance,
+    idField: 'id',
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+    softDeleteField: 'deletedAt',
+  },
+  indexer: { entityType: E.wms.inventory_balance },
+  list: {
+    schema: inventoryBalanceListQuerySchema,
+    entityId: E.wms.inventory_balance,
+    disableListCache: true,
+    fields: [
+      'id',
+      'organization_id',
+      'tenant_id',
+      'warehouse_id',
+      'location_id',
+      'catalog_variant_id',
+      'lot_id',
+      'serial_number',
+      'quantity_on_hand',
+      'quantity_reserved',
+      'quantity_allocated',
+      'quantity_available',
+      'created_at',
+      'updated_at',
+    ],
+    sortFieldMap: {
+      catalogVariantId: 'catalog_variant_id',
+      warehouseId: 'warehouse_id',
+      locationId: 'location_id',
+      quantityOnHand: 'quantity_on_hand',
+      quantityReserved: 'quantity_reserved',
+      quantityAllocated: 'quantity_allocated',
+      quantityAvailable: 'quantity_available',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    },
+    transformItem: transformInventoryBalanceListItem,
+    buildFilters: async (query, ctx) => {
+      const filters: Record<string, unknown> = {}
+      if (query.warehouseId) filters.warehouse_id = { $eq: query.warehouseId }
+      if (query.locationId) filters.location_id = { $eq: query.locationId }
+      if (query.lotId) filters.lot_id = { $eq: query.lotId }
+      if (query.serialNumber) filters.serial_number = { $eq: query.serialNumber }
+
+      let lowStockVariantIds: string[] | null = null
+      if (query.lowStock === 'belowReorder' || query.lowStock === 'belowSafety') {
+        const organizationId = ctx.selectedOrganizationId
+        const tenantId = ctx.auth?.tenantId
+        if (organizationId && tenantId) {
+          const em = ctx.container.resolve('em') as EntityManager
+          lowStockVariantIds = await resolveLowStockVariantIds(
+            em,
+            {
+              organizationId,
+              tenantId,
+              warehouseId: query.warehouseId ?? null,
+            },
+            query.lowStock,
+          )
+        }
+      }
+
+      if (query.catalogVariantId) {
+        if (lowStockVariantIds && !lowStockVariantIds.includes(query.catalogVariantId)) {
+          filters.catalog_variant_id = { $in: ['00000000-0000-4000-8000-000000000000'] }
+        } else {
+          filters.catalog_variant_id = { $eq: query.catalogVariantId }
+        }
+      } else if (lowStockVariantIds) {
+        filters.catalog_variant_id = {
+          $in: formatLowStockVariantIdsForFilter(lowStockVariantIds),
+        }
+      }
+
+      const term = query.search?.trim()
+      if (term) {
+        filters.$or = await buildInventoryListSearchOrFilters(ctx, term, escapeLikePattern)
+      }
+      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 inventoryBalanceListItemSchema = 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_id: z.string().uuid().nullable().optional(),
+  location_code: z.string().nullable().optional(),
+  location_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_on_hand: z.union([z.string(), z.number()]).nullable().optional(),
+  quantity_reserved: z.union([z.string(), z.number()]).nullable().optional(),
+  quantity_allocated: z.union([z.string(), z.number()]).nullable().optional(),
+  quantity_available: z.number().nullable().optional(),
+  created_at: z.string().nullable().optional(),
+  updated_at: z.string().nullable().optional(),
+})
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Inventory balances',
+  methods: {
+    GET: {
+      summary: 'List inventory balances',
+      description: 'Returns paginated inventory balance buckets for the authenticated organization.',
+      query: inventoryBalanceListQuerySchema,
+      responses: [
+        {
+          status: 200,
+          description: 'Inventory balances collection',
+          schema: createPagedListResponseSchema(inventoryBalanceListItemSchema),
+        },
+      ],
+    },
+  },
+}

package/src/modules/wms/api/inventory/cycle-count/route.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { inventoryCycleCountSchema } from '../../../data/validators'
+import { executeWmsCustomPostRoute } from '../helpers'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['wms.cycle_count'] },
+}
+
+export async function POST(request: Request) {
+  return executeWmsCustomPostRoute({
+    request,
+    routePath: 'wms/inventory/cycle-count',
+    inputSchema: inventoryCycleCountSchema,
+    commandId: 'wms.inventory.cycleCount',
+    describeResource: (input) => ({
+      resourceKind: 'wms.inventory',
+      resourceId: `${input.warehouseId}:${input.locationId}:${input.catalogVariantId}`,
+    }),
+    mapSuccess: (result: { adjustmentDelta: string; movementId: string | null }) => ({
+      ok: true,
+      adjustmentDelta: result.adjustmentDelta,
+      movementId: result.movementId,
+    }),
+  })
+}
+
+const successSchema = z.object({
+  ok: z.literal(true),
+  adjustmentDelta: z.string(),
+  movementId: z.string().uuid().nullable(),
+})
+const errorSchema = z.object({ error: z.string() })
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Cycle count reconcile',
+  methods: {
+    POST: {
+      summary: 'Cycle count reconcile',
+      description: 'Reconciles a counted quantity against the current on-hand balance and appends a cycle-count movement when a delta exists.',
+      requestBody: { contentType: 'application/json', schema: inventoryCycleCountSchema },
+      responses: [{ status: 200, description: 'Cycle count reconciled', 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/helpers.ts

@@ -0,0 +1,128 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import type { CommandBus, CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { readJsonSafe } from '@open-mercato/shared/lib/http/readJsonSafe'
+import {
+  runCrudMutationGuardAfterSuccess,
+  validateCrudMutationGuard,
+} from '@open-mercato/shared/lib/crud/mutation-guard'
+import { runCustomRouteAfterInterceptors } from '@open-mercato/shared/lib/crud/custom-route-interceptor'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('wms')
+
+type ResourceDescriptor = {
+  resourceKind: string
+  resourceId: string
+}
+
+type ExecuteWmsCustomPostRouteOptions<TInput, TResult> = {
+  request: Request
+  routePath: string
+  inputSchema: z.ZodType<TInput>
+  commandId: string
+  describeResource: (input: TInput) => ResourceDescriptor
+  mapSuccess: (result: TResult) => Record<string, unknown>
+}
+
+export async function executeWmsCustomPostRoute<TInput, TResult>(
+  options: ExecuteWmsCustomPostRouteOptions<TInput, TResult>,
+) {
+  try {
+    const container = await createRequestContainer()
+    const auth = await getAuthFromRequest(options.request)
+    const { translate } = await resolveTranslations()
+    if (!auth || !auth.tenantId) {
+      throw new CrudHttpError(401, { error: translate('wms.errors.unauthorized', 'Unauthorized') })
+    }
+    const organizationScope = await resolveOrganizationScopeForRequest({
+      container,
+      auth,
+      request: options.request,
+    })
+    const ctx: CommandRuntimeContext = {
+      container,
+      auth,
+      organizationScope,
+      selectedOrganizationId: organizationScope?.selectedId ?? auth.orgId ?? null,
+      organizationIds: organizationScope?.filterIds ?? (auth.orgId ? [auth.orgId] : null),
+      request: options.request,
+    }
+    const body = await readJsonSafe<Record<string, unknown>>(options.request, {})
+    const parsed = options.inputSchema.parse(body)
+    const resource = options.describeResource(parsed)
+    const guardResult = await validateCrudMutationGuard(container, {
+      tenantId: auth.tenantId,
+      organizationId: ctx.selectedOrganizationId,
+      userId: auth.sub,
+      resourceKind: resource.resourceKind,
+      resourceId: resource.resourceId,
+      operation: 'custom',
+      requestMethod: options.request.method,
+      requestHeaders: options.request.headers,
+      mutationPayload: parsed as Record<string, unknown>,
+    })
+    if (guardResult && !guardResult.ok) {
+      return NextResponse.json(guardResult.body, { status: guardResult.status })
+    }
+    const commandBus = container.resolve('commandBus') as CommandBus
+    const execution = await commandBus.execute<TInput, TResult>(options.commandId, {
+      input: parsed,
+      ctx,
+    })
+    if (guardResult?.ok && guardResult.shouldRunAfterSuccess) {
+      await runCrudMutationGuardAfterSuccess(container, {
+        tenantId: auth.tenantId,
+        organizationId: ctx.selectedOrganizationId,
+        userId: auth.sub,
+        resourceKind: resource.resourceKind,
+        resourceId: resource.resourceId,
+        operation: 'custom',
+        requestMethod: options.request.method,
+        requestHeaders: options.request.headers,
+        metadata: guardResult.metadata ?? null,
+      })
+    }
+    const responseBody = options.mapSuccess(execution.result)
+    const intercepted = await runCustomRouteAfterInterceptors({
+      routePath: options.routePath,
+      method: 'POST',
+      request: {
+        method: 'POST',
+        url: options.request.url,
+        body: parsed as Record<string, unknown>,
+        headers: Object.fromEntries(options.request.headers.entries()),
+      },
+      response: {
+        statusCode: 200,
+        body: responseBody,
+        headers: {},
+      },
+      context: {
+        em: container.resolve('em'),
+        container,
+        userId: auth.sub,
+        organizationId: ctx.selectedOrganizationId,
+        tenantId: auth.tenantId,
+      },
+    })
+    if (!intercepted.ok) {
+      return NextResponse.json(intercepted.body, { status: intercepted.statusCode })
+    }
+    return NextResponse.json(intercepted.body, { status: intercepted.statusCode })
+  } catch (error) {
+    if (error instanceof CrudHttpError) {
+      return NextResponse.json(error.body, { status: error.status })
+    }
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: 'Validation failed', details: error.issues }, { status: 400 })
+    }
+    logger.error('custom route failed', { routePath: options.routePath, commandId: options.commandId, err: error })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}