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

package/src/modules/resources/api/activities.ts

@@ -1,278 +1,34 @@
-import { z } from 'zod'
-import type { EntityManager } from '@mikro-orm/postgresql'
-import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
-import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
-import { resolveCrudRecordId, parseScopedCommandInput } from '@open-mercato/shared/lib/api/scoped'
-import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { makeActivityRoute } from '@open-mercato/core/modules/entities/lib/makeActivityRoute'
 import { ResourcesResourceActivity } from '../data/entities'
 import {
   resourcesResourceActivityCreateSchema,
   resourcesResourceActivityUpdateSchema,
 } from '../data/validators'
-import { User } from '@open-mercato/core/modules/auth/data/entities'
 import { E } from '#generated/entities.ids.generated'
-import { createResourcesCrudOpenApi, createPagedListResponseSchema, defaultOkResponseSchema } from './openapi'
-
-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),
-    entityId: z.string().uuid().optional(),
-    sortField: z.string().optional(),
-    sortDir: z.enum(['asc', 'desc']).optional(),
-  })
-  .passthrough()
-
-const routeMetadata = {
-  GET: { requireAuth: true, requireFeatures: ['resources.view'] },
-  POST: { requireAuth: true, requireFeatures: ['resources.manage_resources'] },
-  PUT: { requireAuth: true, requireFeatures: ['resources.manage_resources'] },
-  DELETE: { requireAuth: true, requireFeatures: ['resources.manage_resources'] },
-}
-
-export const metadata = routeMetadata
-
-const crud = makeCrudRoute({
-  metadata: routeMetadata,
-  orm: {
-    entity: ResourcesResourceActivity,
-    idField: 'id',
-    orgField: 'organizationId',
-    tenantField: 'tenantId',
-  },
-  indexer: {
-    entityType: E.resources.resources_resource_activity,
-  },
-  list: {
-    schema: listSchema,
-    entityId: E.resources.resources_resource_activity,
-    fields: [
-      'id',
-      'resource_id',
-      'activity_type',
-      'subject',
-      'body',
-      'occurred_at',
-      'author_user_id',
-      'appearance_icon',
-      'appearance_color',
-      'organization_id',
-      'tenant_id',
-      'created_at',
-      'updated_at',
-    ],
-    decorateCustomFields: {
-      entityIds: E.resources.resources_resource_activity,
-    },
-    sortFieldMap: {
-      occurredAt: 'occurred_at',
-      createdAt: 'created_at',
-      updatedAt: 'updated_at',
-    },
-    buildFilters: async (query) => {
-      const filters: Record<string, unknown> = {}
-      if (query.entityId) filters.resource_id = { $eq: query.entityId }
-      return filters
-    },
-    transformItem: (item: Record<string, unknown>) => {
-      const record = (item ?? {}) as Record<string, unknown>
-      const toIsoString = (value: unknown): string | null => {
-        if (value == null) return null
-        if (value instanceof Date) return value.toISOString()
-        if (typeof value === 'string') {
-          const trimmed = value.trim()
-          if (!trimmed.length) return null
-          const date = new Date(trimmed)
-          return Number.isNaN(date.getTime()) ? trimmed : date.toISOString()
-        }
-        return null
-      }
-      const readString = (value: unknown): string | null => (typeof value === 'string' ? value : null)
-      const idValue = readString(record.id) ?? (record.id != null ? String(record.id) : '')
-      const resourceId = readString(record['resource_id']) ?? readString(record['resourceId']) ?? null
-      const activityType =
-        readString(record['activity_type']) ??
-        readString(record['activityType']) ??
-        ''
-      const subject =
-        readString(record.subject) ??
-        (record.subject == null ? null : String(record.subject))
-      const body =
-        readString(record.body) ??
-        (record.body == null ? null : String(record.body))
-      const authorUserId =
-        readString(record['author_user_id']) ?? readString(record['authorUserId']) ?? null
-      const appearanceIconRaw =
-        readString(record['appearance_icon']) ?? readString(record['appearanceIcon'])
-      const appearanceColorRaw =
-        readString(record['appearance_color']) ?? readString(record['appearanceColor'])
-      const organizationId =
-        readString(record['organization_id']) ?? readString(record['organizationId'])
-      const tenantId =
-        readString(record['tenant_id']) ?? readString(record['tenantId'])
-      const output: Record<string, unknown> = {
-        id: idValue,
-        entityId: resourceId,
-        resourceId,
-        activityType,
-        subject,
-        body,
-        occurredAt: toIsoString(record['occurred_at'] ?? record['occurredAt']),
-        createdAt: toIsoString(record['created_at'] ?? record['createdAt']),
-        authorUserId,
-        organizationId,
-        tenantId,
-        appearanceIcon: appearanceIconRaw && appearanceIconRaw.trim().length ? appearanceIconRaw : null,
-        appearanceColor: appearanceColorRaw && appearanceColorRaw.trim().length ? appearanceColorRaw : null,
-        customFields: Array.isArray(record.customFields) ? record.customFields : undefined,
-        customValues: record.customValues ?? undefined,
-      }
-      for (const [key, value] of Object.entries(record)) {
-        if (key.startsWith('cf_') || key.startsWith('cf:')) {
-          output[key] = value
-        }
-      }
-      return output
-    },
-  },
-  actions: {
-    create: {
-      commandId: 'resources.resource-activities.create',
-      schema: rawBodySchema,
-      mapInput: async ({ raw, ctx }) => {
-        const { translate } = await resolveTranslations()
-        return parseScopedCommandInput(resourcesResourceActivityCreateSchema, raw ?? {}, ctx, translate)
-      },
-      response: ({ result }) => ({
-        id: result?.activityId ?? result?.id ?? null,
-        authorUserId: result?.authorUserId ?? null,
-      }),
-      status: 201,
-    },
-    update: {
-      commandId: 'resources.resource-activities.update',
-      schema: rawBodySchema,
-      mapInput: async ({ raw, ctx }) => {
-        const { translate } = await resolveTranslations()
-        return parseScopedCommandInput(resourcesResourceActivityUpdateSchema, raw ?? {}, ctx, translate)
-      },
-      response: () => ({ ok: true }),
-    },
-    delete: {
-      commandId: 'resources.resource-activities.delete',
-      schema: rawBodySchema,
-      mapInput: async ({ parsed, ctx }) => {
-        const { translate } = await resolveTranslations()
-        const id = resolveCrudRecordId(parsed, ctx, translate)
-        return { id }
-      },
-      response: () => ({ ok: true }),
-    },
-  },
-  hooks: {
-    afterList: async (payload, ctx) => {
-      const items = Array.isArray(payload.items) ? payload.items : []
-      if (!items.length) return
-      const userIds = new Set<string>()
-      items.forEach((item: unknown) => {
-        if (!item || typeof item !== 'object') return
-        const record = item as Record<string, unknown>
-        const userId =
-          typeof record.author_user_id === 'string'
-            ? record.author_user_id
-            : typeof record.authorUserId === 'string'
-              ? record.authorUserId
-              : null
-        if (userId) userIds.add(userId)
-      })
-      if (!userIds.size) return
-      try {
-        const em = (ctx.container.resolve('em') as EntityManager).fork()
-        const users = await findWithDecryption(
-          em,
-          User,
-          { id: { $in: Array.from(userIds) } },
-          undefined,
-          { tenantId: ctx.auth?.tenantId ?? null, organizationId: ctx.selectedOrganizationId ?? null },
-        )
-        const map = new Map<string, { name: string | null; email: string | null }>()
-        users.forEach((user) => {
-          const name = typeof user.name === 'string' && user.name.trim().length
-            ? user.name.trim()
-            : null
-          map.set(user.id, { name, email: user.email ?? null })
-        })
-        items.forEach((item: unknown) => {
-          if (!item || typeof item !== 'object') return
-          const record = item as Record<string, unknown>
-          const userId =
-            typeof record.author_user_id === 'string'
-              ? record.author_user_id
-              : typeof record.authorUserId === 'string'
-                ? record.authorUserId
-                : null
-          if (!userId) return
-          const meta = map.get(userId)
-          if (!meta) return
-          record.authorName = meta.name
-          record.authorEmail = meta.email
-          if (!('author_name' in record)) record.author_name = meta.name
-          if (!('author_email' in record)) record.author_email = meta.email
-        })
-      } catch (err) {
-        console.warn('[resources.activities] failed to enrich author metadata', err)
-      }
-    },
+import { createResourcesCrudOpenApi } from './openapi'
+
+const route = makeActivityRoute({
+  entity: ResourcesResourceActivity,
+  entityId: E.resources.resources_resource_activity,
+  parentFkColumn: 'resource_id',
+  parentFkParam: 'resourceId',
+  features: { view: 'resources.view', manage: 'resources.manage_resources' },
+  createSchema: resourcesResourceActivityCreateSchema,
+  updateSchema: resourcesResourceActivityUpdateSchema,
+  commandPrefix: 'resources.resource-activities',
+  logPrefix: '[resources.activities]',
+  openApiFactory: createResourcesCrudOpenApi,
+  openApi: {
+    resourceName: 'ResourceActivity',
+    createDescription: 'Adds an activity to a resource timeline.',
+    updateDescription: 'Updates a resource activity.',
+    deleteDescription: 'Deletes a resource activity.',
   },
 })
 
-export const GET = crud.GET
-export const POST = crud.POST
-export const PUT = crud.PUT
-export const DELETE = crud.DELETE
-
-const activityListItemSchema = z
-  .object({
-    id: z.string().uuid(),
-    resource_id: z.string().uuid().nullable().optional(),
-    activity_type: z.string().nullable().optional(),
-    subject: z.string().nullable().optional(),
-    body: z.string().nullable().optional(),
-    occurred_at: z.string().nullable().optional(),
-    author_user_id: z.string().uuid().nullable(),
-    appearance_icon: z.string().nullable().optional(),
-    appearance_color: z.string().nullable().optional(),
-    organization_id: z.string().uuid().nullable().optional(),
-    tenant_id: z.string().uuid().nullable().optional(),
-    created_at: z.string().nullable(),
-    updated_at: z.string().nullable().optional(),
-  })
-  .passthrough()
-
-const activityCreateResponseSchema = z.object({
-  id: z.string().uuid().nullable(),
-  authorUserId: z.string().uuid().nullable(),
-})
-
-export const openApi = createResourcesCrudOpenApi({
-  resourceName: 'ResourceActivity',
-  querySchema: listSchema,
-  listResponseSchema: createPagedListResponseSchema(activityListItemSchema),
-  create: {
-    schema: resourcesResourceActivityCreateSchema,
-    responseSchema: activityCreateResponseSchema,
-    description: 'Adds an activity to a resource timeline.',
-  },
-  update: {
-    schema: resourcesResourceActivityUpdateSchema,
-    responseSchema: defaultOkResponseSchema,
-    description: 'Updates a resource activity.',
-  },
-  del: {
-    schema: z.object({ id: z.string().uuid() }),
-    responseSchema: defaultOkResponseSchema,
-    description: 'Deletes a resource activity.',
-  },
-})
+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

package/src/modules/resources/commands/activities.ts

@@ -7,6 +7,7 @@ import {
   emitCrudUndoSideEffects,
   buildChanges,
   requireId,
+  normalizeAuthorUserId,
 } from '@open-mercato/shared/lib/commands/helpers'
 import type { DataEngine } from '@open-mercato/shared/lib/data/engine'
 import type { EntityManager } from '@mikro-orm/postgresql'
@@ -114,13 +115,7 @@ const createActivityCommand: CommandHandler<ResourcesResourceActivityCreateInput
     const { parsed, custom } = parseWithCustomFields(resourcesResourceActivityCreateSchema, rawInput)
     ensureTenantScope(ctx, parsed.tenantId)
     ensureOrganizationScope(ctx, parsed.organizationId)
-    const authSub = ctx.auth?.isApiKey ? null : ctx.auth?.sub ?? null
-    const normalizedAuthor = (() => {
-      if (parsed.authorUserId) return parsed.authorUserId
-      if (!authSub) return null
-      const uuidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/
-      return uuidRegex.test(authSub) ? authSub : null
-    })()
+    const normalizedAuthor = normalizeAuthorUserId(parsed.authorUserId, ctx.auth)
 
     const em = (ctx.container.resolve('em') as EntityManager).fork()
     const resource = await requireResource(em, parsed.entityId, 'Resource not found')

package/src/modules/resources/commands/comments.ts

@@ -1,6 +1,6 @@
 import { registerCommand } from '@open-mercato/shared/lib/commands'
 import type { CommandHandler } from '@open-mercato/shared/lib/commands'
-import { emitCrudSideEffects, emitCrudUndoSideEffects, buildChanges, requireId } from '@open-mercato/shared/lib/commands/helpers'
+import { emitCrudSideEffects, emitCrudUndoSideEffects, buildChanges, requireId, normalizeAuthorUserId } from '@open-mercato/shared/lib/commands/helpers'
 import type { DataEngine } from '@open-mercato/shared/lib/data/engine'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
@@ -60,13 +60,7 @@ const createCommentCommand: CommandHandler<
     const parsed = resourcesResourceCommentCreateSchema.parse(rawInput)
     ensureTenantScope(ctx, parsed.tenantId)
     ensureOrganizationScope(ctx, parsed.organizationId)
-    const authSub = ctx.auth?.isApiKey ? null : ctx.auth?.sub ?? null
-    const normalizedAuthor = (() => {
-      if (parsed.authorUserId) return parsed.authorUserId
-      if (!authSub) return null
-      const uuidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/
-      return uuidRegex.test(authSub) ? authSub : null
-    })()
+    const normalizedAuthor = normalizeAuthorUserId(parsed.authorUserId, ctx.auth)
 
     const em = (ctx.container.resolve('em') as EntityManager).fork()
     const resource = await requireResource(em, parsed.entityId, 'Resource not found')

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

@@ -1,223 +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 { SalesOrder } 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:orders']
-const WIDGET_CACHE_ID = 'sales:new-orders'
-
-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-orders'] },
-}
-
-type WidgetContext = WidgetScopeContext & {
-  limit: number
-  datePeriod: DatePeriodOption
-  customFrom?: string
-  customTo?: string
-}
-
-type NewOrdersWidgetResponse = {
-  items: Array<{
-    id: string
-    orderNumber: string
-    status: string | null
-    fulfillmentStatus: string | null
-    paymentStatus: string | null
-    customerName: string | null
-    customerEntityId: string | null
-    netAmount: string
-    grossAmount: string
-    currency: string | null
-    createdAt: string
-  }>
-  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
-    }
-
-    
-
-    // Use shared WidgetDataService to fetch aggregated widget data
-    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<SalesOrder> = {
-      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 [orders, total] = await findAndCountWithDecryption(
-      em,
-      SalesOrder,
-      where,
-      {
-        limit,
-        orderBy: { createdAt: 'desc' as const },
-      },
-      { tenantId, organizationId: organizationIdScope },
-    )
-
-    const items = orders.map((order) => ({
-      id: order.id,
-      orderNumber: order.orderNumber,
-      status: order.status ?? null,
-      fulfillmentStatus: order.fulfillmentStatus ?? null,
-      paymentStatus: order.paymentStatus ?? null,
-      customerName: extractCustomerName(order.customerSnapshot) ?? null,
-      customerEntityId: order.customerEntityId ?? null,
-      netAmount: order.grandTotalNetAmount ?? '0',
-      grossAmount: order.grandTotalGrossAmount ?? '0',
-      currency: order.currencyCode ?? null,
-      createdAt: order.createdAt.toISOString(),
-    }))
-
-    const response: NewOrdersWidgetResponse = {
-      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.newOrders failed', err)
-    return NextResponse.json(
-      { error: translate('sales.widgets.newOrders.error', 'Failed to load orders') },
-      { status: 500 },
-    )
-  }
-}
+import { extractCustomerName } from '../helpers'
+import { makeDashboardWidgetRoute } from '../../../../widgets/dashboard/makeDashboardWidgetRoute'
 
 const orderItemSchema = z.object({
   id: z.string().uuid(),
@@ -233,32 +17,33 @@ const orderItemSchema = z.object({
   createdAt: z.string(),
 })
 
-const responseSchema = z.object({
-  items: z.array(orderItemSchema),
-  total: z.number(),
-  dateRange: z.object({
-    from: z.string(),
-    to: z.string(),
+const { GET, metadata, openApi } = makeDashboardWidgetRoute({
+  entity: SalesOrder,
+  cacheId: 'sales:new-orders',
+  cacheTags: ['widget-data:sales:orders'],
+  feature: 'sales.widgets.new-orders',
+  itemSchema: orderItemSchema,
+  errorPrefix: 'sales.widgets.newOrders',
+  openApi: {
+    summary: 'New orders dashboard widget',
+    description: 'Fetches recently created sales orders for the dashboard widget with a configurable date period.',
+    getSummary: 'Fetch recently created sales orders',
+    itemDescription: 'List of recent orders',
+    errorFallback: 'Failed to load orders',
+  },
+  mapItem: (order) => ({
+    id: order.id as string,
+    orderNumber: order.orderNumber as string,
+    status: (order.status as string) ?? null,
+    fulfillmentStatus: (order.fulfillmentStatus as string) ?? null,
+    paymentStatus: (order.paymentStatus as string) ?? null,
+    customerName: extractCustomerName(order.customerSnapshot) ?? null,
+    customerEntityId: (order.customerEntityId as string) ?? null,
+    netAmount: (order.grandTotalNetAmount as string) ?? '0',
+    grossAmount: (order.grandTotalGrossAmount as string) ?? '0',
+    currency: (order.currencyCode as string) ?? null,
+    createdAt: order.createdAt ? (order.createdAt as Date).toISOString() : new Date().toISOString(),
   }),
 })
 
-const widgetErrorSchema = z.object({ error: z.string() })
-
-export const openApi: OpenApiRouteDoc = {
-  tag: 'Sales',
-  summary: 'New orders dashboard widget',
-  description: 'Fetches recently created sales orders for the dashboard widget with a configurable date period.',
-  methods: {
-    GET: {
-      summary: 'Fetch recently created sales orders',
-      query: querySchema,
-      responses: [{ status: 200, description: 'List of recent orders', 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 }