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

package/src/modules/sales/api/dashboard/widgets/new-quotes/route.ts

@@ -1,224 +1,7 @@
-import { createHash } from 'node:crypto'
-import { NextResponse } from 'next/server'
 import { z } from 'zod'
-import type { FilterQuery } from '@mikro-orm/core'
-import type { CacheStrategy } from '@open-mercato/cache'
-import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
-import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
-import { runWithCacheTenant } from '@open-mercato/cache'
-import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
-import { findAndCountWithDecryption } from '@open-mercato/shared/lib/encryption/find'
-import { resolveDateRange } from '@open-mercato/ui/backend/date-range'
 import { SalesQuote } from '../../../../data/entities'
-import { extractCustomerName, type DatePeriodOption } from '../helpers'
-import { resolveWidgetScope, type WidgetScopeContext } from '../../../../../customers/api/dashboard/widgets/utils'
-
-const WIDGET_CACHE_TTL = 120_000
-const WIDGET_CACHE_SEGMENT_TTL = 86_400_000
-const WIDGET_CACHE_SEGMENT_KEY = 'widget-data:__segment__'
-const WIDGET_CACHE_TAGS = ['widget-data', 'widget-data:sales:quotes']
-const WIDGET_CACHE_ID = 'sales:new-quotes'
-
-const querySchema = z.object({
-  limit: z.coerce.number().min(1).max(20).default(5),
-  datePeriod: z.enum(['last24h', 'last7d', 'last30d', 'custom']).default('last24h'),
-  customFrom: z.string().optional(),
-  customTo: z.string().optional(),
-  tenantId: z.string().uuid().optional(),
-  organizationId: z.string().uuid().optional(),
-})
-
-export const metadata = {
-  GET: { requireAuth: true, requireFeatures: ['dashboards.view', 'sales.widgets.new-quotes'] },
-}
-
-type WidgetContext = WidgetScopeContext & {
-  limit: number
-  datePeriod: DatePeriodOption
-  customFrom?: string
-  customTo?: string
-}
-
-type NewQuotesWidgetResponse = {
-  items: Array<{
-    id: string
-    quoteNumber: string
-    status: string | null
-    customerName: string | null
-    customerEntityId: string | null
-    validFrom: string | null
-    validUntil: string | null
-    netAmount: string
-    grossAmount: string
-    currency: string | null
-    createdAt: string
-    convertedOrderId: string | null
-  }>
-  total: number
-  dateRange: {
-    from: string
-    to: string
-  }
-}
-
-function normalizeOrganizationIds(organizationIds: string[] | null): string[] | null {
-  if (organizationIds === null) return null
-  const set = new Set(organizationIds)
-  return Array.from(set).sort((a, b) => a.localeCompare(b))
-}
-
-function buildCacheKey(params: {
-  tenantId: string
-  organizationIds: string[] | null
-  limit: number
-  datePeriod: DatePeriodOption
-  customFrom?: string
-  customTo?: string
-}): string {
-  const hash = createHash('sha256')
-  hash.update(
-    JSON.stringify({
-      widget: WIDGET_CACHE_ID,
-      ...params,
-      organizationIds: normalizeOrganizationIds(params.organizationIds),
-    })
-  )
-  return `widget-data:${hash.digest('hex').slice(0, 16)}`
-}
-
-async function resolveContext(req: Request, translate: (key: string, fallback?: string) => string): Promise<WidgetContext> {
-  const url = new URL(req.url)
-  const rawQuery: Record<string, string> = {}
-  for (const [key, value] of url.searchParams.entries()) rawQuery[key] = value
-  const parsed = querySchema.safeParse(rawQuery)
-  if (!parsed.success) {
-    throw new CrudHttpError(400, { error: translate('sales.errors.invalid_query', 'Invalid query parameters') })
-  }
-
-  const { container, em, tenantId, organizationIds } = await resolveWidgetScope(req, translate, {
-    tenantId: parsed.data.tenantId ?? null,
-    organizationId: parsed.data.organizationId ?? null,
-  })
-
-  return {
-    container,
-    em,
-    tenantId,
-    organizationIds,
-    limit: parsed.data.limit,
-    datePeriod: parsed.data.datePeriod,
-    customFrom: parsed.data.customFrom,
-    customTo: parsed.data.customTo,
-  }
-}
-
-export async function GET(req: Request) {
-  const { translate } = await resolveTranslations()
-  try {
-    const { container, em, tenantId, organizationIds, limit, datePeriod, customFrom, customTo } = await resolveContext(
-      req,
-      translate
-    )
-    const range = (() => {
-      if (datePeriod === 'custom') {
-        const from = customFrom ? new Date(customFrom) : new Date(0)
-        const to = customTo ? new Date(customTo) : new Date()
-        return { start: from, end: to }
-      }
-      const preset = datePeriod === 'last7d' ? 'last_7_days' : datePeriod === 'last30d' ? 'last_30_days' : 'today'
-      return resolveDateRange(preset)
-    })()
-
-    let cache: CacheStrategy | null = null
-    try {
-      cache = container.resolve<CacheStrategy>('cache')
-    } catch {
-      cache = null
-    }
-
-    
-
-    const cacheKey = buildCacheKey({ tenantId, organizationIds, limit, datePeriod, customFrom, customTo })
-    const tenantScope = tenantId ?? null
-
-    if (cache) {
-      try {
-        const cached = await runWithCacheTenant(tenantScope, () => cache!.get(cacheKey))
-        if (cached && typeof cached === 'object' && 'items' in (cached as object)) {
-          return NextResponse.json(cached)
-        }
-      } catch {
-      }
-    }
-
-    const where: FilterQuery<SalesQuote> = {
-      tenantId,
-      deletedAt: null,
-      createdAt: { $gte: range.start, $lte: range.end },
-    }
-
-    if (Array.isArray(organizationIds)) {
-      const unique = Array.from(new Set(organizationIds))
-      where.organizationId = unique.length === 1 ? unique[0] : { $in: unique }
-    }
-
-    const organizationIdScope = Array.isArray(organizationIds) && organizationIds.length === 1 ? organizationIds[0] : null
-    const [quotes, total] = await findAndCountWithDecryption(
-      em,
-      SalesQuote,
-      where,
-      {
-        limit,
-        orderBy: { createdAt: 'desc' as const },
-      },
-      { tenantId, organizationId: organizationIdScope },
-    )
-
-    const items = quotes.map((quote) => ({
-      id: quote.id,
-      quoteNumber: quote.quoteNumber,
-      status: quote.status ?? null,
-      customerName: extractCustomerName(quote.customerSnapshot) ?? null,
-      customerEntityId: quote.customerEntityId ?? null,
-      validFrom: quote.validFrom ? quote.validFrom.toISOString() : null,
-      validUntil: quote.validUntil ? quote.validUntil.toISOString() : null,
-      netAmount: quote.grandTotalNetAmount ?? '0',
-      grossAmount: quote.grandTotalGrossAmount ?? '0',
-      currency: quote.currencyCode ?? null,
-      createdAt: quote.createdAt.toISOString(),
-      convertedOrderId: quote.convertedOrderId ?? null,
-    }))
-
-    const response: NewQuotesWidgetResponse = {
-      items,
-      total,
-      dateRange: { from: range.start.toISOString(), to: range.end.toISOString() },
-    }
-
-    if (cache) {
-      try {
-        await runWithCacheTenant(tenantScope, () => cache!.set(cacheKey, response, { ttl: WIDGET_CACHE_TTL, tags: WIDGET_CACHE_TAGS }))
-        await runWithCacheTenant(tenantScope, () => cache!.set(
-          WIDGET_CACHE_SEGMENT_KEY,
-          { updatedAt: response.dateRange.to },
-          { ttl: WIDGET_CACHE_SEGMENT_TTL, tags: ['widget-data'] },
-        ))
-      } catch {
-      }
-    }
-
-    return NextResponse.json(response)
-  } catch (err) {
-    if (err instanceof CrudHttpError) {
-      return NextResponse.json(err.body, { status: err.status })
-    }
-    console.error('sales.widgets.newQuotes failed', err)
-    return NextResponse.json(
-      { error: translate('sales.widgets.newQuotes.error', 'Failed to load quotes') },
-      { status: 500 },
-    )
-  }
-}
+import { extractCustomerName } from '../helpers'
+import { makeDashboardWidgetRoute } from '../../../../widgets/dashboard/makeDashboardWidgetRoute'
 
 const quoteItemSchema = z.object({
   id: z.string().uuid(),
@@ -235,32 +18,34 @@ const quoteItemSchema = z.object({
   convertedOrderId: z.string().uuid().nullable(),
 })
 
-const responseSchema = z.object({
-  items: z.array(quoteItemSchema),
-  total: z.number(),
-  dateRange: z.object({
-    from: z.string(),
-    to: z.string(),
+const { GET, metadata, openApi } = makeDashboardWidgetRoute({
+  entity: SalesQuote,
+  cacheId: 'sales:new-quotes',
+  cacheTags: ['widget-data:sales:quotes'],
+  feature: 'sales.widgets.new-quotes',
+  itemSchema: quoteItemSchema,
+  errorPrefix: 'sales.widgets.newQuotes',
+  openApi: {
+    summary: 'New quotes dashboard widget',
+    description: 'Fetches recently created sales quotes for the dashboard widget with a configurable date period.',
+    getSummary: 'Fetch recently created sales quotes',
+    itemDescription: 'List of recent quotes',
+    errorFallback: 'Failed to load quotes',
+  },
+  mapItem: (quote) => ({
+    id: quote.id as string,
+    quoteNumber: quote.quoteNumber as string,
+    status: (quote.status as string) ?? null,
+    customerName: extractCustomerName(quote.customerSnapshot) ?? null,
+    customerEntityId: (quote.customerEntityId as string) ?? null,
+    validFrom: quote.validFrom ? (quote.validFrom as Date).toISOString() : null,
+    validUntil: quote.validUntil ? (quote.validUntil as Date).toISOString() : null,
+    netAmount: (quote.grandTotalNetAmount as string) ?? '0',
+    grossAmount: (quote.grandTotalGrossAmount as string) ?? '0',
+    currency: (quote.currencyCode as string) ?? null,
+    createdAt: quote.createdAt ? (quote.createdAt as Date).toISOString() : new Date().toISOString(),
+    convertedOrderId: (quote.convertedOrderId as string) ?? null,
   }),
 })
 
-const widgetErrorSchema = z.object({ error: z.string() })
-
-export const openApi: OpenApiRouteDoc = {
-  tag: 'Sales',
-  summary: 'New quotes dashboard widget',
-  description: 'Fetches recently created sales quotes for the dashboard widget with a configurable date period.',
-  methods: {
-    GET: {
-      summary: 'Fetch recently created sales quotes',
-      query: querySchema,
-      responses: [{ status: 200, description: 'List of recent quotes', schema: responseSchema }],
-      errors: [
-        { status: 400, description: 'Invalid query parameters', schema: widgetErrorSchema },
-        { status: 401, description: 'Unauthorized', schema: widgetErrorSchema },
-        { status: 403, description: 'Forbidden', schema: widgetErrorSchema },
-        { status: 500, description: 'Widget failed to load', schema: widgetErrorSchema },
-      ],
-    },
-  },
-}
+export { GET, metadata, openApi }

package/src/modules/sales/api/order-line-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-line-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-line-status',
+  entityId: E.dictionaries.dictionary_entry,
+  fieldConstants: F,
+  openApi: {
+    resourceName: 'Order line status',
+    pluralName: 'Order line statuses',
+    description: 'Manage custom order line statuses available for sales documents.',
   },
-  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 line status',
-  pluralName: 'Order line statuses',
-  description: 'Manage custom order line statuses available for sales documents.',
-  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