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

package/src/modules/wms/api/sales-orders/[salesOrderId]/warehouse-assignment/route.ts

@@ -0,0 +1,306 @@
+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 type { CommandBus, CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+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'
+import { salesOrderWarehouseAssignBodySchema } from '../../../../data/validators'
+import { loadSalesOrderWarehouseAssignmentView } from '../../../../lib/salesOrderWarehouseAssignment'
+import { executeWmsCustomPostRoute } from '../../../inventory/helpers'
+
+const logger = createLogger('wms')
+
+const paramsSchema = z.object({
+  salesOrderId: z.string().uuid(),
+})
+
+const assignmentResponseSchema = z.object({
+  assignment: z
+    .object({
+      id: z.string().uuid(),
+      salesOrderId: z.string().uuid(),
+      warehouseId: z.string().uuid(),
+      warehouseName: z.string().nullable(),
+      warehouseCode: z.string().nullable(),
+      notes: z.string().nullable(),
+      assignedBy: z.string().uuid().nullable(),
+    })
+    .nullable(),
+})
+
+const assignSuccessSchema = z.object({
+  ok: z.literal(true),
+  assignmentId: z.string().uuid(),
+  warehouseId: z.string().uuid(),
+})
+
+const okSchema = z.object({ ok: z.literal(true) })
+const errorSchema = z.object({ error: z.string() })
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['wms.view'] },
+  PUT: { requireAuth: true, requireFeatures: ['wms.manage_reservations'] },
+  PATCH: { requireAuth: true, requireFeatures: ['wms.manage_reservations'] },
+  DELETE: { requireAuth: true, requireFeatures: ['wms.manage_reservations'] },
+}
+
+async function resolveCommandContext(request: Request): Promise<CommandRuntimeContext> {
+  const container = await createRequestContainer()
+  const auth = await getAuthFromRequest(request)
+  if (!auth || !auth.tenantId) {
+    throw new CrudHttpError(401, { error: 'Unauthorized' })
+  }
+  const organizationScope = await resolveOrganizationScopeForRequest({
+    container,
+    auth,
+    request,
+  })
+  return {
+    container,
+    auth,
+    organizationScope,
+    selectedOrganizationId: organizationScope?.selectedId ?? auth.orgId ?? null,
+    organizationIds: organizationScope?.filterIds ?? (auth.orgId ? [auth.orgId] : null),
+    request,
+  }
+}
+
+function resolveScope(ctx: CommandRuntimeContext) {
+  const organizationId = ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
+  const tenantId = ctx.auth?.tenantId ?? null
+  if (!organizationId || !tenantId) {
+    throw new CrudHttpError(401, { error: 'Unauthorized' })
+  }
+  return { organizationId, tenantId }
+}
+
+export async function GET(
+  request: Request,
+  { params }: { params: { salesOrderId: string } },
+) {
+  try {
+    const parsedParams = paramsSchema.parse(params)
+    const ctx = await resolveCommandContext(request)
+    const scope = resolveScope(ctx)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const assignment = await loadSalesOrderWarehouseAssignmentView(
+      em,
+      parsedParams.salesOrderId,
+      scope,
+    )
+    return NextResponse.json({ assignment })
+  } 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('GET warehouse-assignment failed', { err: error })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}
+
+async function executeAssignMutation(request: Request, salesOrderId: string) {
+  const body = await readJsonSafe<Record<string, unknown>>(request, {})
+  const parsedBody = salesOrderWarehouseAssignBodySchema.parse(body)
+  const scopedRequest = new Request(request.url, {
+    method: 'POST',
+    headers: request.headers,
+    body: JSON.stringify({
+      ...parsedBody,
+      salesOrderId,
+    }),
+  })
+  return executeWmsCustomPostRoute({
+    request: scopedRequest,
+    routePath: `wms/sales-orders/${salesOrderId}/warehouse-assignment`,
+    inputSchema: z.object({
+      salesOrderId: z.string().uuid(),
+      warehouseId: z.string().uuid(),
+      notes: z.string().trim().max(500).optional(),
+      tenantId: z.string().uuid().optional(),
+      organizationId: z.string().uuid().optional(),
+      metadata: z.record(z.string(), z.unknown()).optional(),
+    }),
+    commandId: 'wms.sales-order.assign-warehouse',
+    describeResource: (input) => ({
+      resourceKind: 'wms.sales_order_warehouse_assignment',
+      resourceId: input.salesOrderId,
+    }),
+    mapSuccess: (result: { assignmentId: string; warehouseId: string }) => ({
+      ok: true,
+      assignmentId: result.assignmentId,
+      warehouseId: result.warehouseId,
+    }),
+  })
+}
+
+export async function PUT(
+  request: Request,
+  routeContext: { params: { salesOrderId: string } },
+) {
+  const parsedParams = paramsSchema.parse(routeContext.params)
+  return executeAssignMutation(request, parsedParams.salesOrderId)
+}
+
+export async function PATCH(
+  request: Request,
+  routeContext: { params: { salesOrderId: string } },
+) {
+  const parsedParams = paramsSchema.parse(routeContext.params)
+  return executeAssignMutation(request, parsedParams.salesOrderId)
+}
+
+export async function DELETE(
+  request: Request,
+  routeContext: { params: { salesOrderId: string } },
+) {
+  try {
+    const parsedParams = paramsSchema.parse(routeContext.params)
+    const ctx = await resolveCommandContext(request)
+    const scope = resolveScope(ctx)
+    const resource = {
+      resourceKind: 'wms.sales_order_warehouse_assignment',
+      resourceId: parsedParams.salesOrderId,
+    }
+    const guardResult = await validateCrudMutationGuard(ctx.container, {
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      userId: ctx.auth?.sub ?? '',
+      resourceKind: resource.resourceKind,
+      resourceId: resource.resourceId,
+      operation: 'custom',
+      requestMethod: request.method,
+      requestHeaders: request.headers,
+      mutationPayload: { salesOrderId: parsedParams.salesOrderId },
+    })
+    if (guardResult && !guardResult.ok) {
+      return NextResponse.json(guardResult.body, { status: guardResult.status })
+    }
+
+    const commandBus = ctx.container.resolve('commandBus') as CommandBus
+    await commandBus.execute('wms.sales-order.unassign-warehouse', {
+      input: {
+        salesOrderId: parsedParams.salesOrderId,
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId,
+      },
+      ctx,
+    })
+
+    if (guardResult?.ok && guardResult.shouldRunAfterSuccess) {
+      await runCrudMutationGuardAfterSuccess(ctx.container, {
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId,
+        userId: ctx.auth?.sub ?? '',
+        resourceKind: resource.resourceKind,
+        resourceId: resource.resourceId,
+        operation: 'custom',
+        requestMethod: request.method,
+        requestHeaders: request.headers,
+        metadata: guardResult.metadata ?? null,
+      })
+    }
+
+    const responseBody = { ok: true as const }
+    const intercepted = await runCustomRouteAfterInterceptors({
+      routePath: `wms/sales-orders/${parsedParams.salesOrderId}/warehouse-assignment`,
+      method: 'DELETE',
+      request: {
+        method: 'DELETE',
+        url: request.url,
+        body: { salesOrderId: parsedParams.salesOrderId },
+        headers: Object.fromEntries(request.headers.entries()),
+      },
+      response: {
+        statusCode: 200,
+        body: responseBody,
+        headers: {},
+      },
+      context: {
+        em: ctx.container.resolve('em'),
+        container: ctx.container,
+        userId: ctx.auth?.sub ?? '',
+        organizationId: scope.organizationId,
+        tenantId: scope.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('DELETE warehouse-assignment failed', { err: error })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Sales order warehouse assignment',
+  methods: {
+    GET: {
+      summary: 'Get warehouse assignment for sales order',
+      description:
+        'Returns the explicit WMS warehouse assignment for a sales order, or null when none is set.',
+      responses: [
+        { status: 200, description: 'Assignment state', schema: assignmentResponseSchema },
+      ],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+      ],
+    },
+    PUT: {
+      summary: 'Assign warehouse to sales order',
+      description:
+        'Creates or replaces the explicit warehouse assignment for a sales order.',
+      requestBody: { contentType: 'application/json', schema: salesOrderWarehouseAssignBodySchema },
+      responses: [
+        { status: 200, description: 'Warehouse assigned', schema: assignSuccessSchema },
+        { status: 201, description: 'Warehouse assigned', schema: assignSuccessSchema },
+      ],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+        { status: 404, description: 'Warehouse not found', schema: errorSchema },
+        { status: 422, description: 'Warehouse is inactive', schema: errorSchema },
+      ],
+    },
+    PATCH: {
+      summary: 'Patch warehouse assignment for sales order',
+      description: 'Same as PUT — upserts the explicit warehouse assignment.',
+      requestBody: { contentType: 'application/json', schema: salesOrderWarehouseAssignBodySchema },
+      responses: [{ status: 200, description: 'Warehouse assigned', schema: assignSuccessSchema }],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+      ],
+    },
+    DELETE: {
+      summary: 'Remove warehouse assignment from sales order',
+      description: 'Clears the explicit assignment so enricher and automation fall back again.',
+      responses: [{ status: 200, description: 'Assignment removed', schema: okSchema }],
+      errors: [
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+      ],
+    },
+  },
+}

package/src/modules/wms/api/sales-orders/assign-warehouse/route.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { salesOrderWarehouseAssignSchema } from '../../../data/validators'
+import { executeWmsCustomPostRoute } from '../../inventory/helpers'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['wms.manage_reservations'] },
+}
+
+export async function POST(request: Request) {
+  return executeWmsCustomPostRoute({
+    request,
+    routePath: 'wms/sales-orders/assign-warehouse',
+    inputSchema: salesOrderWarehouseAssignSchema,
+    commandId: 'wms.sales-order.assign-warehouse',
+    describeResource: (input) => ({
+      resourceKind: 'wms.sales_order_warehouse_assignment',
+      resourceId: input.salesOrderId,
+    }),
+    mapSuccess: (result: { assignmentId: string; warehouseId: string }) => ({
+      ok: true,
+      assignmentId: result.assignmentId,
+      warehouseId: result.warehouseId,
+    }),
+  })
+}
+
+const successSchema = z.object({
+  ok: z.literal(true),
+  assignmentId: z.string().uuid(),
+  warehouseId: z.string().uuid(),
+})
+
+const errorSchema = z.object({ error: z.string() })
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'WMS',
+  summary: 'Assign warehouse to sales order',
+  methods: {
+    POST: {
+      summary: 'Assign warehouse to sales order',
+      description:
+        'Explicitly assigns a warehouse to a sales order. When set, the enricher returns this warehouse and the reservation automation prefers it.',
+      requestBody: { contentType: 'application/json', schema: salesOrderWarehouseAssignSchema },
+      responses: [
+        { status: 201, description: 'Warehouse assigned', schema: successSchema },
+        { status: 200, description: 'Warehouse assignment updated', schema: successSchema },
+      ],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+        { status: 404, description: 'Warehouse not found', schema: errorSchema },
+        { status: 422, description: 'Warehouse is inactive', schema: errorSchema },
+      ],
+    },
+  },
+}

package/src/modules/wms/api/sales-orders/unassign-warehouse/route.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { salesOrderWarehouseUnassignSchema } from '../../../data/validators'
+import { executeWmsCustomPostRoute } from '../../inventory/helpers'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['wms.manage_reservations'] },
+}
+
+export async function POST(request: Request) {
+  return executeWmsCustomPostRoute({
+    request,
+    routePath: 'wms/sales-orders/unassign-warehouse',
+    inputSchema: salesOrderWarehouseUnassignSchema,
+    commandId: 'wms.sales-order.unassign-warehouse',
+    describeResource: (input) => ({
+      resourceKind: 'wms.sales_order_warehouse_assignment',
+      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: 'Remove warehouse assignment from sales order',
+  methods: {
+    POST: {
+      summary: 'Remove warehouse assignment from sales order',
+      description:
+        'Removes an explicit warehouse assignment from a sales order. The enricher will fall back to deriving the warehouse from active reservations or the primary warehouse.',
+      requestBody: { contentType: 'application/json', schema: salesOrderWarehouseUnassignSchema },
+      responses: [{ status: 200, description: 'Assignment removed', schema: successSchema }],
+      errors: [
+        { status: 400, description: 'Validation failed', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+      ],
+    },
+  },
+}

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

@@ -0,0 +1,181 @@
+import { z } from 'zod'
+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 { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
+import { E } from '#generated/entities.ids.generated'
+import { Warehouse } from '../../data/entities'
+import { warehouseCreateSchema, warehouseUpdateSchema } from '../../data/validators'
+import { createPagedListResponseSchema, createWmsCrudOpenApi, defaultOkResponseSchema } from '../openapi'
+
+const F = {
+  id: 'id',
+  organization_id: 'organization_id',
+  tenant_id: 'tenant_id',
+  name: 'name',
+  code: 'code',
+  is_active: 'is_active',
+  is_primary: 'is_primary',
+  address_line1: 'address_line1',
+  city: 'city',
+  postal_code: 'postal_code',
+  country: 'country',
+  timezone: 'timezone',
+  created_at: 'created_at',
+  updated_at: 'updated_at',
+} as const
+
+const routeMetadata = {
+  GET: { requireAuth: true, requireFeatures: ['wms.view'] },
+  POST: { requireAuth: true, requireFeatures: ['wms.manage_warehouses'] },
+  PUT: { requireAuth: true, requireFeatures: ['wms.manage_warehouses'] },
+  DELETE: { requireAuth: true, requireFeatures: ['wms.manage_warehouses'] },
+}
+
+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(),
+  ids: z.string().optional(),
+  isActive: z.string().optional(),
+  sortField: z.string().optional(),
+  sortDir: z.enum(['asc', 'desc']).optional(),
+}).passthrough()
+
+const crud = makeCrudRoute({
+  metadata: routeMetadata,
+  orm: {
+    entity: Warehouse,
+    idField: 'id',
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+    softDeleteField: 'deletedAt',
+  },
+  indexer: { entityType: E.wms.warehouse },
+  list: {
+    schema: listSchema,
+    disableListCache: true,
+    entityId: E.wms.warehouse,
+    fields: [
+      F.id,
+      F.organization_id,
+      F.tenant_id,
+      F.name,
+      F.code,
+      F.is_active,
+      F.is_primary,
+      F.address_line1,
+      F.city,
+      F.postal_code,
+      F.country,
+      F.timezone,
+      F.created_at,
+      F.updated_at,
+    ],
+    sortFieldMap: {
+      name: F.name,
+      code: F.code,
+      createdAt: F.created_at,
+      updatedAt: F.updated_at,
+    },
+    buildFilters: async (query) => {
+      const filters: Record<string, unknown> = {}
+      if (typeof query.ids === 'string' && query.ids.trim().length > 0) {
+        filters[F.id] = {
+          $in: query.ids.split(',').map((value) => value.trim()).filter((value) => value.length > 0),
+        }
+      }
+      const isActive = parseBooleanToken(query.isActive)
+      if (isActive !== null) filters[F.is_active] = { $eq: isActive }
+      const term = query.search?.trim()
+      if (term) {
+        const like = `%${escapeLikePattern(term)}%`
+        filters.$or = [
+          { [F.name]: { $ilike: like } },
+          { [F.code]: { $ilike: like } },
+          { [F.city]: { $ilike: like } },
+          { [F.country]: { $ilike: like } },
+        ]
+      }
+      return filters
+    },
+  },
+  actions: {
+    create: {
+      commandId: 'wms.warehouses.create',
+      schema: rawBodySchema,
+      mapInput: async ({ raw, ctx }) => {
+        const { translate } = await resolveTranslations()
+        return parseScopedCommandInput(warehouseCreateSchema, raw ?? {}, ctx, translate)
+      },
+      response: ({ result }) => ({ id: result?.warehouseId ?? null }),
+      status: 201,
+    },
+    update: {
+      commandId: 'wms.warehouses.update',
+      schema: rawBodySchema,
+      mapInput: async ({ raw, ctx }) => {
+        const { translate } = await resolveTranslations()
+        return parseScopedCommandInput(warehouseUpdateSchema, raw ?? {}, ctx, translate)
+      },
+      response: () => ({ ok: true }),
+    },
+    delete: {
+      commandId: 'wms.warehouses.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 warehouseListItemSchema = z.object({
+  id: z.string().uuid().nullable().optional(),
+  organization_id: z.string().uuid().nullable().optional(),
+  tenant_id: z.string().uuid().nullable().optional(),
+  name: z.string().nullable().optional(),
+  code: z.string().nullable().optional(),
+  is_active: z.boolean().nullable().optional(),
+  is_primary: z.boolean().nullable().optional(),
+  address_line1: z.string().nullable().optional(),
+  city: z.string().nullable().optional(),
+  postal_code: z.string().nullable().optional(),
+  country: z.string().nullable().optional(),
+  timezone: z.string().nullable().optional(),
+  created_at: z.string().nullable().optional(),
+  updated_at: z.string().nullable().optional(),
+})
+
+export const openApi = createWmsCrudOpenApi({
+  resourceName: 'Warehouse',
+  pluralName: 'Warehouses',
+  querySchema: listSchema,
+  listResponseSchema: createPagedListResponseSchema(warehouseListItemSchema),
+  create: {
+    schema: warehouseCreateSchema,
+    description: 'Creates a warehouse for inventory operations.',
+  },
+  update: {
+    schema: warehouseUpdateSchema,
+    responseSchema: defaultOkResponseSchema,
+    description: 'Updates a warehouse by id.',
+  },
+  del: {
+    schema: z.object({ id: z.string().uuid() }),
+    responseSchema: defaultOkResponseSchema,
+    description: 'Soft-deletes a warehouse by id.',
+  },
+})