@open-mercato/core 0.4.6-develop-9ff1d4a9a2 → 0.4.6-develop-219dae16c5

package/src/modules/sales/lib/makeSalesLineRoute.ts

@@ -0,0 +1,345 @@
+import { z } from 'zod'
+import { makeCrudRoute, type CrudCtx } from '@open-mercato/shared/lib/crud/factory'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import {
+  buildCustomFieldFiltersFromQuery,
+  extractAllCustomFieldEntries,
+} from '@open-mercato/shared/lib/crud/custom-fields'
+import {
+  canonicalizeUnitCode,
+  REFERENCE_UNIT_CODES,
+} from '@open-mercato/shared/lib/units/unitCodes'
+import {
+  createPagedListResponseSchema,
+  createSalesCrudOpenApi,
+  defaultOkResponseSchema,
+} from '../api/openapi'
+import { withScopedPayload } from '../api/utils'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- MikroORM entity class constructor
+type EntityClass = new (...args: any[]) => unknown
+
+interface SalesLineRouteConfig {
+  entity: EntityClass
+  entityId: string
+  fieldConstants: Record<string, string>
+  parentFkColumn: string
+  parentFkParam: string
+  createSchema: z.ZodObject<z.ZodRawShape>
+  features: { view: string; manage: string }
+  commandPrefix: string
+  openApi: {
+    resourceName: string
+    description: string
+  }
+}
+
+const rawBodySchema = z.object({}).passthrough()
+
+function resolveRawBody(raw: unknown): Record<string, unknown> {
+  if (!raw || typeof raw !== 'object') return {}
+  if ('body' in raw) {
+    const payload = raw as { body?: unknown }
+    if (payload.body && typeof payload.body === 'object') {
+      return payload.body as Record<string, unknown>
+    }
+  }
+  return raw as Record<string, unknown>
+}
+
+function transformItem(item: Record<string, unknown> | null | undefined) {
+  if (!item) return item
+  const normalized = { ...item }
+  const cfEntries = extractAllCustomFieldEntries(item)
+  for (const key of Object.keys(normalized)) {
+    if (key.startsWith('cf:')) delete normalized[key]
+  }
+  const quantityUnit = canonicalizeUnitCode(
+    normalized['quantity_unit'] ?? normalized['quantityUnit'],
+  )
+  const normalizedUnit =
+    canonicalizeUnitCode(
+      normalized['normalized_unit'] ?? normalized['normalizedUnit'],
+    ) ?? quantityUnit
+  return {
+    ...normalized,
+    quantity_unit: quantityUnit,
+    normalized_unit: normalizedUnit,
+    ...cfEntries,
+  }
+}
+
+const uomSnapshotOpenApiSchema = z
+  .object({
+    version: z.literal(1),
+    productId: z.string().nullable(),
+    productVariantId: z.string().nullable(),
+    baseUnitCode: z.string().nullable(),
+    enteredUnitCode: z.string().nullable(),
+    enteredQuantity: z.string(),
+    toBaseFactor: z.string(),
+    normalizedQuantity: z.string(),
+    rounding: z.object({
+      mode: z.enum(['half_up', 'down', 'up']),
+      scale: z.number().int(),
+    }),
+    source: z.object({
+      conversionId: z.string().nullable(),
+      resolvedAt: z.string(),
+    }),
+    unitPriceReference: z
+      .object({
+        enabled: z.boolean(),
+        referenceUnitCode: z.enum(REFERENCE_UNIT_CODES).nullable(),
+        baseQuantity: z.string().nullable(),
+        grossPerReference: z.string().nullable().optional(),
+        netPerReference: z.string().nullable().optional(),
+      })
+      .optional(),
+  })
+  .nullable()
+  .optional()
+
+export function makeSalesLineRoute(config: SalesLineRouteConfig) {
+  const {
+    entity,
+    entityId,
+    fieldConstants: F,
+    parentFkColumn,
+    parentFkParam,
+    createSchema,
+    features,
+    commandPrefix,
+  } = config
+
+  const listSchema = z
+    .object({
+      page: z.coerce.number().min(1).default(1),
+      pageSize: z.coerce.number().min(1).max(100).default(50),
+      id: z.string().uuid().optional(),
+      [parentFkParam]: z.string().uuid().optional(),
+      sortField: z.string().optional(),
+      sortDir: z.enum(['asc', 'desc']).optional(),
+    })
+    .passthrough()
+
+  const upsertSchema = createSchema.extend({
+    id: z.string().uuid().optional(),
+  })
+
+  const deleteSchema = z.object({
+    id: z.string().uuid(),
+    [parentFkParam]: z.string().uuid(),
+  })
+
+  const routeMetadata = {
+    GET: { requireAuth: true, requireFeatures: [features.view] },
+    POST: { requireAuth: true, requireFeatures: [features.manage] },
+    PUT: { requireAuth: true, requireFeatures: [features.manage] },
+    DELETE: { requireAuth: true, requireFeatures: [features.manage] },
+  }
+
+  const crud = makeCrudRoute({
+    metadata: routeMetadata,
+    orm: {
+      entity,
+      idField: 'id',
+      orgField: 'organizationId',
+      tenantField: 'tenantId',
+      softDeleteField: 'deletedAt',
+    },
+    indexer: {
+      entityType: entityId,
+    },
+    list: {
+      schema: listSchema,
+      entityId,
+      fields: [
+        F.id,
+        parentFkColumn,
+        F.line_number,
+        F.kind,
+        F.status_entry_id,
+        F.status,
+        F.product_id,
+        F.product_variant_id,
+        F.catalog_snapshot,
+        F.name,
+        F.description,
+        F.comment,
+        F.organization_id,
+        F.tenant_id,
+        F.quantity,
+        F.quantity_unit,
+        F.normalized_quantity,
+        F.normalized_unit,
+        F.uom_snapshot,
+        F.currency_code,
+        F.unit_price_net,
+        F.unit_price_gross,
+        F.discount_amount,
+        F.discount_percent,
+        F.tax_rate,
+        F.tax_amount,
+        F.total_net_amount,
+        F.total_gross_amount,
+        F.configuration,
+        F.promotion_code,
+        F.promotion_snapshot,
+        F.metadata,
+        F.custom_field_set_id,
+        F.created_at,
+        F.updated_at,
+      ],
+      sortFieldMap: {
+        createdAt: F.created_at,
+        updatedAt: F.updated_at,
+        lineNumber: F.line_number,
+      },
+      buildFilters: async (query: Record<string, unknown>, ctx: CrudCtx) => {
+        const filters: Record<string, unknown> = {}
+        if (query.id) filters.id = { $eq: query.id }
+        if (query[parentFkParam]) filters[parentFkColumn] = { $eq: query[parentFkParam] }
+        try {
+          const em = ctx.container.resolve('em')
+          const cfFilters = await buildCustomFieldFiltersFromQuery({
+            entityId,
+            query,
+            em,
+            tenantId: ctx.auth?.tenantId ?? null,
+          })
+          Object.assign(filters, cfFilters)
+        } catch {
+          // ignore
+        }
+        return filters
+      },
+      transformItem,
+    },
+    actions: {
+      create: {
+        commandId: `${commandPrefix}.upsert`,
+        schema: rawBodySchema,
+        mapInput: async ({ raw, ctx }: { raw: unknown; ctx: CrudCtx }) => {
+          const { translate } = await resolveTranslations()
+          const payload = upsertSchema.parse(
+            withScopedPayload(resolveRawBody(raw) ?? {}, ctx, translate),
+          )
+          return { body: payload }
+        },
+        response: ({ result }: { result: Record<string, unknown> | null }) => ({
+          id: result?.lineId ?? null,
+          [parentFkParam]: result?.[parentFkParam] ?? null,
+        }),
+        status: 201,
+      },
+      update: {
+        commandId: `${commandPrefix}.upsert`,
+        schema: rawBodySchema,
+        mapInput: async ({ raw, ctx }: { raw: unknown; ctx: CrudCtx }) => {
+          const { translate } = await resolveTranslations()
+          const payload = upsertSchema.parse(
+            withScopedPayload(resolveRawBody(raw) ?? {}, ctx, translate),
+          )
+          return { body: payload }
+        },
+        response: ({ result }: { result: Record<string, unknown> | null }) => ({
+          id: result?.lineId ?? null,
+          [parentFkParam]: result?.[parentFkParam] ?? null,
+        }),
+      },
+      delete: {
+        commandId: `${commandPrefix}.delete`,
+        schema: rawBodySchema,
+        mapInput: async ({ raw, ctx }: { raw: unknown; ctx: CrudCtx }) => {
+          const { translate } = await resolveTranslations()
+          const payload = deleteSchema.parse(
+            withScopedPayload(resolveRawBody(raw) ?? {}, ctx, translate),
+          )
+          if (!payload.id || !payload[parentFkParam]) {
+            throw new CrudHttpError(400, {
+              error: translate(
+                'sales.documents.detail.error',
+                'Document not found or inaccessible.',
+              ),
+            })
+          }
+          return { body: payload }
+        },
+        response: () => ({ ok: true }),
+      },
+    },
+  })
+
+  const lineItemSchema = z.object({
+    id: z.string().uuid(),
+    [parentFkColumn]: z.string().uuid(),
+    line_number: z.number(),
+    kind: z.string(),
+    status_entry_id: z.string().uuid().nullable().optional(),
+    status: z.string().nullable().optional(),
+    product_id: z.string().uuid().nullable().optional(),
+    product_variant_id: z.string().uuid().nullable().optional(),
+    catalog_snapshot: z.record(z.string(), z.unknown()).nullable().optional(),
+    name: z.string().nullable().optional(),
+    description: z.string().nullable().optional(),
+    comment: z.string().nullable().optional(),
+    quantity: z.number(),
+    quantity_unit: z.string().nullable().optional(),
+    normalized_quantity: z.number(),
+    normalized_unit: z.string().nullable().optional(),
+    uom_snapshot: uomSnapshotOpenApiSchema,
+    currency_code: z.string(),
+    unit_price_net: z.number(),
+    unit_price_gross: z.number(),
+    discount_amount: z.number(),
+    discount_percent: z.number(),
+    tax_rate: z.number(),
+    tax_amount: z.number(),
+    total_net_amount: z.number(),
+    total_gross_amount: z.number(),
+    configuration: z.record(z.string(), z.unknown()).nullable().optional(),
+    promotion_code: z.string().nullable().optional(),
+    promotion_snapshot: z.record(z.string(), z.unknown()).nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+    custom_field_set_id: z.string().uuid().nullable().optional(),
+    created_at: z.string(),
+    updated_at: z.string(),
+  })
+
+  const upsertResponseSchema = z.object({
+    id: z.string().uuid().nullable(),
+    [parentFkParam]: z.string().uuid().nullable(),
+  })
+
+  const openApi = createSalesCrudOpenApi({
+    resourceName: config.openApi.resourceName,
+    querySchema: listSchema,
+    listResponseSchema: createPagedListResponseSchema(lineItemSchema),
+    create: {
+      schema: upsertSchema,
+      responseSchema: upsertResponseSchema,
+      description: `Creates ${config.openApi.description}.`,
+    },
+    update: {
+      schema: upsertSchema,
+      responseSchema: upsertResponseSchema,
+      description: `Updates ${config.openApi.description}.`,
+    },
+    del: {
+      schema: deleteSchema,
+      responseSchema: defaultOkResponseSchema,
+      description: `Deletes ${config.openApi.description}.`,
+    },
+  })
+
+  return {
+    metadata: routeMetadata,
+    openApi,
+    GET: crud.GET,
+    POST: crud.POST,
+    PUT: crud.PUT,
+    DELETE: crud.DELETE,
+  }
+}

package/src/modules/sales/lib/makeStatusDictionaryRoute.ts

@@ -0,0 +1,229 @@
+import { z } from 'zod'
+import { makeCrudRoute, type CrudCtx } from '@open-mercato/shared/lib/crud/factory'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { Dictionary, DictionaryEntry } from '@open-mercato/core/modules/dictionaries/data/entities'
+import { statusDictionaryCreateSchema, statusDictionaryUpdateSchema } from '../data/validators'
+import { getSalesDictionaryDefinition, ensureSalesDictionary, type SalesDictionaryKind } from './dictionaries'
+import { parseScopedCommandInput, resolveCrudRecordId } from '../api/utils'
+import {
+  createPagedListResponseSchema,
+  createSalesCrudOpenApi,
+  defaultDeleteRequestSchema,
+} from '../api/openapi'
+import { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
+
+interface StatusDictionaryRouteConfig {
+  kind: SalesDictionaryKind
+  entityId: string
+  fieldConstants: Record<string, string>
+  openApi: {
+    resourceName: string
+    pluralName: string
+    description: string
+  }
+}
+
+export function makeStatusDictionaryRoute(config: StatusDictionaryRouteConfig) {
+  const { kind, entityId, fieldConstants: F } = config
+  const definition = getSalesDictionaryDefinition(kind)
+
+  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(50),
+      search: z.string().optional(),
+      sortField: z.string().optional(),
+      sortDir: z.enum(['asc', 'desc']).optional(),
+    })
+    .passthrough()
+
+  const metadata = {
+    GET: { requireAuth: true, requireFeatures: ['sales.settings.manage'] },
+    POST: { requireAuth: true, requireFeatures: ['sales.settings.manage'] },
+    PUT: { requireAuth: true, requireFeatures: ['sales.settings.manage'] },
+    DELETE: { requireAuth: true, requireFeatures: ['sales.settings.manage'] },
+  }
+
+  const dictionaryItemSchema = z.object({
+    id: z.string().uuid(),
+    value: z.string(),
+    label: z.string().nullable(),
+    color: z.string().nullable(),
+    icon: z.string().nullable(),
+    organizationId: z.string().uuid().nullable(),
+    tenantId: z.string().uuid().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+  })
+
+  const dictionaryListResponseSchema = createPagedListResponseSchema(dictionaryItemSchema)
+
+  const normalizeId = (value: unknown): string | null => {
+    if (typeof value !== 'string') return null
+    const trimmed = value.trim()
+    return trimmed.length > 0 ? trimmed : null
+  }
+
+  async function resolveDictionaryContext(ctx: CrudCtx): Promise<{ dictionaryId: string; organizationId: string | null }> {
+    if (!ctx.auth || !ctx.auth.tenantId) {
+      throw new CrudHttpError(401, { error: 'Tenant context is required.' })
+    }
+    const em = ctx.container.resolve('em') as EntityManager
+    const tenantId: string = ctx.auth.tenantId
+    const candidateOrgIds = new Set<string>()
+    const pushCandidate = (value: unknown) => {
+      const normalized = normalizeId(value)
+      if (normalized) candidateOrgIds.add(normalized)
+    }
+    pushCandidate(ctx.selectedOrganizationId)
+    pushCandidate(ctx.auth.orgId ?? null)
+    const scope = ctx.organizationScope
+    if (scope) {
+      if (Array.isArray(scope.filterIds)) {
+        for (const id of scope.filterIds) pushCandidate(id)
+      }
+      if (Array.isArray(scope.allowedIds)) {
+        for (const id of scope.allowedIds) pushCandidate(id)
+      }
+    }
+
+    for (const orgId of candidateOrgIds) {
+      const dictionary = await ensureSalesDictionary({
+        em,
+        tenantId,
+        organizationId: orgId,
+        kind,
+      })
+      if (dictionary) {
+        return { dictionaryId: dictionary.id, organizationId: orgId }
+      }
+    }
+
+    const fallback = await em.findOne(
+      Dictionary,
+      {
+        tenantId,
+        key: definition.key,
+        deletedAt: null,
+      },
+      { orderBy: { createdAt: 'asc' } },
+    )
+    if (fallback) {
+      return { dictionaryId: fallback.id, organizationId: fallback.organizationId }
+    }
+    throw new CrudHttpError(400, { error: 'Organization context is required.' })
+  }
+
+  const crud = makeCrudRoute({
+    metadata,
+    orm: {
+      entity: DictionaryEntry,
+      idField: 'id',
+      orgField: 'organizationId',
+      tenantField: 'tenantId',
+      softDeleteField: null,
+    },
+    list: {
+      schema: listSchema,
+      entityId,
+      fields: [
+        F.id,
+        F.value,
+        F.label,
+        F.color,
+        F.icon,
+        F.organization_id,
+        F.tenant_id,
+        F.created_at,
+        F.updated_at,
+      ],
+      sortFieldMap: {
+        id: F.id,
+        value: F.value,
+        label: F.label,
+        createdAt: F.created_at,
+        updatedAt: F.updated_at,
+      },
+      buildFilters: async (query, ctx) => {
+        const { dictionaryId } = await resolveDictionaryContext(ctx)
+        const filters: Record<string, unknown> = {
+          dictionary_id: dictionaryId,
+        }
+        if (query.search && query.search.trim().length > 0) {
+          const term = `%${escapeLikePattern(query.search.trim())}%`
+          filters.$or = [
+            { [F.value]: { $ilike: term } },
+            { [F.label]: { $ilike: term } },
+          ]
+        }
+        return filters
+      },
+      transformItem: (item: Record<string, unknown>) => ({
+        id: item.id,
+        value: item.value,
+        label: item.label,
+        color: item.color ?? null,
+        icon: item.icon ?? null,
+        organizationId: item.organization_id ?? null,
+        tenantId: item.tenant_id ?? null,
+        createdAt: item.created_at,
+        updatedAt: item.updated_at,
+      }),
+    },
+    actions: {
+      create: {
+        commandId: `${definition.commandPrefix}.create`,
+        schema: rawBodySchema,
+        mapInput: async ({ raw, ctx }) => {
+          const { translate } = await resolveTranslations()
+          return parseScopedCommandInput(statusDictionaryCreateSchema, raw ?? {}, ctx, translate)
+        },
+        response: ({ result }) => ({ id: result?.entryId ?? null }),
+        status: 201,
+      },
+      update: {
+        commandId: `${definition.commandPrefix}.update`,
+        schema: rawBodySchema,
+        mapInput: async ({ raw, ctx }) => {
+          const { translate } = await resolveTranslations()
+          return parseScopedCommandInput(statusDictionaryUpdateSchema, raw ?? {}, ctx, translate)
+        },
+        response: () => ({ ok: true }),
+      },
+      delete: {
+        commandId: `${definition.commandPrefix}.delete`,
+        schema: rawBodySchema,
+        mapInput: async ({ parsed, ctx }) => {
+          const { translate } = await resolveTranslations()
+          const id = resolveCrudRecordId(parsed, ctx, translate)
+          return { id }
+        },
+        response: () => ({ ok: true }),
+      },
+    },
+  })
+
+  const openApi = createSalesCrudOpenApi({
+    resourceName: config.openApi.resourceName,
+    pluralName: config.openApi.pluralName,
+    description: config.openApi.description,
+    querySchema: listSchema,
+    listResponseSchema: dictionaryListResponseSchema,
+    create: { schema: statusDictionaryCreateSchema },
+    update: { schema: statusDictionaryUpdateSchema },
+    del: { schema: defaultDeleteRequestSchema },
+  })
+
+  return {
+    metadata,
+    openApi,
+    GET: crud.GET,
+    POST: crud.POST,
+    PUT: crud.PUT,
+    DELETE: crud.DELETE,
+  }
+}