@open-mercato/core 0.4.6-develop-f7d3079656 → 0.4.6-develop-0861f05ea9

package/src/modules/sales/api/order-lines/route.ts

@@ -1,307 +1,23 @@
-import { z } from "zod";
-import { makeCrudRoute } 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 { SalesOrderLine } from "../../data/entities";
 import { orderLineCreateSchema } from "../../data/validators";
-import {
-  createPagedListResponseSchema,
-  createSalesCrudOpenApi,
-  defaultOkResponseSchema,
-} from "../openapi";
-import { withScopedPayload } from "../utils";
 import { E } from "#generated/entities.ids.generated";
 import * as F from "#generated/entities/sales_order_line";
-import { canonicalizeUnitCode, REFERENCE_UNIT_CODES } from "@open-mercato/shared/lib/units/unitCodes";
-
-const rawBodySchema = z.object({}).passthrough();
-const 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>;
-};
-
-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(),
-    orderId: z.string().uuid().optional(),
-    sortField: z.string().optional(),
-    sortDir: z.enum(["asc", "desc"]).optional(),
-  })
-  .passthrough();
-
-const routeMetadata = {
-  GET: { requireAuth: true, requireFeatures: ["sales.orders.view"] },
-  POST: { requireAuth: true, requireFeatures: ["sales.orders.manage"] },
-  PUT: { requireAuth: true, requireFeatures: ["sales.orders.manage"] },
-  DELETE: { requireAuth: true, requireFeatures: ["sales.orders.manage"] },
-};
-
-const upsertSchema = orderLineCreateSchema.extend({
-  id: z.string().uuid().optional(),
-});
-const deleteSchema = z.object({
-  id: z.string().uuid(),
-  orderId: z.string().uuid(),
-});
-
-const crud = makeCrudRoute({
-  metadata: routeMetadata,
-  orm: {
-    entity: SalesOrderLine,
-    idField: "id",
-    orgField: "organizationId",
-    tenantField: "tenantId",
-    softDeleteField: "deletedAt",
-  },
-  indexer: {
-    entityType: E.sales.sales_order_line,
-  },
-  list: {
-    schema: listSchema,
-    entityId: E.sales.sales_order_line,
-    fields: [
-      F.id,
-      "order_id",
-      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, ctx) => {
-      const filters: Record<string, unknown> = {};
-      if (query.id) filters.id = { $eq: query.id };
-      if (query.orderId) filters.order_id = { $eq: query.orderId };
-      try {
-        const em = ctx.container.resolve("em");
-        const cfFilters = await buildCustomFieldFiltersFromQuery({
-          entityId: E.sales.sales_order_line,
-          query,
-          em,
-          tenantId: ctx.auth?.tenantId ?? null,
-        });
-        Object.assign(filters, cfFilters);
-      } catch {
-        // ignore
-      }
-      return filters;
-    },
-    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,
-      };
-    },
-  },
-  actions: {
-    create: {
-      commandId: "sales.orders.lines.upsert",
-      schema: rawBodySchema,
-      mapInput: async ({ raw, ctx }) => {
-        const { translate } = await resolveTranslations();
-        const payload = upsertSchema.parse(
-          withScopedPayload(resolveRawBody(raw) ?? {}, ctx, translate),
-        );
-        return { body: payload };
-      },
-      response: ({ result }) => ({
-        id: result?.lineId ?? null,
-        orderId: result?.orderId ?? null,
-      }),
-      status: 201,
-    },
-    update: {
-      commandId: "sales.orders.lines.upsert",
-      schema: rawBodySchema,
-      mapInput: async ({ raw, ctx }) => {
-        const { translate } = await resolveTranslations();
-        const payload = upsertSchema.parse(
-          withScopedPayload(resolveRawBody(raw) ?? {}, ctx, translate),
-        );
-        return { body: payload };
-      },
-      response: ({ result }) => ({
-        id: result?.lineId ?? null,
-        orderId: result?.orderId ?? null,
-      }),
-    },
-    delete: {
-      commandId: "sales.orders.lines.delete",
-      schema: rawBodySchema,
-      mapInput: async ({ raw, ctx }) => {
-        const { translate } = await resolveTranslations();
-        const payload = deleteSchema.parse(
-          withScopedPayload(resolveRawBody(raw) ?? {}, ctx, translate),
-        );
-        if (!payload.id || !payload.orderId) {
-          throw new CrudHttpError(400, {
-            error: translate(
-              "sales.documents.detail.error",
-              "Document not found or inaccessible.",
-            ),
-          });
-        }
-        return { body: payload };
-      },
-      response: () => ({ ok: true }),
-    },
+import { makeSalesLineRoute } from "../../lib/makeSalesLineRoute";
+
+const route = makeSalesLineRoute({
+  entity: SalesOrderLine,
+  entityId: E.sales.sales_order_line,
+  fieldConstants: F,
+  parentFkColumn: "order_id",
+  parentFkParam: "orderId",
+  createSchema: orderLineCreateSchema,
+  features: { view: "sales.orders.view", manage: "sales.orders.manage" },
+  commandPrefix: "sales.orders.lines",
+  openApi: {
+    resourceName: "Order line",
+    description: "an order line and recalculates totals",
   },
 });
 
-const { GET, POST, PUT, DELETE } = crud;
-
-export { GET, POST, PUT, DELETE };
-
-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();
-
-const orderLineSchema = z.object({
-  id: z.string().uuid(),
-  order_id: 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(),
-});
-
-export const openApi = createSalesCrudOpenApi({
-  resourceName: "Order line",
-  querySchema: listSchema,
-  listResponseSchema: createPagedListResponseSchema(orderLineSchema),
-  create: {
-    schema: upsertSchema,
-    responseSchema: z.object({
-      id: z.string().uuid().nullable(),
-      orderId: z.string().uuid().nullable(),
-    }),
-    description: "Creates an order line and recalculates totals.",
-  },
-  update: {
-    schema: upsertSchema,
-    responseSchema: z.object({
-      id: z.string().uuid().nullable(),
-      orderId: z.string().uuid().nullable(),
-    }),
-    description: "Updates an order line and recalculates totals.",
-  },
-  del: {
-    schema: deleteSchema,
-    responseSchema: defaultOkResponseSchema,
-    description: "Deletes an order line and recalculates totals.",
-  },
-});
+export const { GET, POST, PUT, DELETE } = route;
+export const openApi = route.openApi;

package/src/modules/sales/api/order-statuses/route.ts

@@ -1,214 +1,21 @@
-import { z } from 'zod'
-import { makeCrudRoute } 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 { E } from '#generated/entities.ids.generated'
 import * as F from '#generated/entities/dictionary_entry'
-import { statusDictionaryCreateSchema, statusDictionaryUpdateSchema } from '../../data/validators'
-import { getSalesDictionaryDefinition, ensureSalesDictionary, type SalesDictionaryKind } from '../../lib/dictionaries'
-import { parseScopedCommandInput, resolveCrudRecordId } from '../utils'
-import {
-  createPagedListResponseSchema,
-  createSalesCrudOpenApi,
-  defaultDeleteRequestSchema,
-} from '../openapi'
-import { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
-
-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 kind: SalesDictionaryKind = 'order-status'
-const definition = getSalesDictionaryDefinition(kind)
-
-export 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: any): 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,
+import { makeStatusDictionaryRoute } from '../../lib/makeStatusDictionaryRoute'
+
+const route = makeStatusDictionaryRoute({
+  kind: 'order-status',
+  entityId: E.dictionaries.dictionary_entry,
+  fieldConstants: F,
+  openApi: {
+    resourceName: 'Order status',
+    pluralName: 'Order statuses',
+    description: 'Manage the lifecycle states available for sales orders.',
   },
-  list: {
-    schema: listSchema,
-    entityId: E.dictionaries.dictionary_entry,
-    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: any) => ({
-      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 }),
-    },
-  },
-})
-
-export const openApi = createSalesCrudOpenApi({
-  resourceName: 'Order status',
-  pluralName: 'Order statuses',
-  description: 'Manage the lifecycle states available for sales orders.',
-  querySchema: listSchema,
-  listResponseSchema: dictionaryListResponseSchema,
-  create: { schema: statusDictionaryCreateSchema },
-  update: { schema: statusDictionaryUpdateSchema },
-  del: { schema: defaultDeleteRequestSchema },
 })
 
-export const GET = crud.GET
-export const POST = crud.POST
-export const PUT = crud.PUT
-export const DELETE = crud.DELETE
+export const metadata = route.metadata
+export const openApi = route.openApi
+export const GET = route.GET
+export const POST = route.POST
+export const PUT = route.PUT
+export const DELETE = route.DELETE