@open-mercato/core 0.6.8-develop.6998.1.d2bc46c56c → 0.6.8-develop.7001.1.03608ab252

package/src/modules/warranty_claims/api/entitlement/route.ts

@@ -0,0 +1,224 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { sql } from 'kysely'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { CrudHttpError, isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import type {
+  WarrantyEntitlementInput,
+  WarrantyEntitlementResolver,
+  WarrantyEntitlementResult,
+} from '../../services/entitlementResolver'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('warranty_claims')
+
+type EntitlementHistoryDb = {
+  warranty_claim_lines: {
+    claim_id: string
+    organization_id: string
+    tenant_id: string
+    serial_number: string | null
+    deleted_at: Date | null
+  }
+  warranty_claims: {
+    id: string
+    organization_id: string
+    tenant_id: string
+    claim_number: string
+    deleted_at: Date | null
+  }
+  warranty_claim_registrations: {
+    id: string
+    organization_id: string
+    tenant_id: string
+    serial_number: string | null
+    deleted_at: Date | null
+  }
+}
+
+type NumericAggregateValue = string | number | bigint | null
+
+type EntitlementRouteContext = {
+  tenantId: string
+  organizationId: string
+  em: EntityManager
+  resolver: WarrantyEntitlementResolver
+}
+
+type EntitlementResponse = WarrantyEntitlementResult & {
+  hasPriorClaims?: boolean
+  priorClaimCount?: number
+  priorRegistrationCount?: number
+  relatedClaimNumbers?: string[]
+}
+
+const UNKNOWN_ENTITLEMENT: WarrantyEntitlementResult = {
+  warrantyStatus: 'unknown',
+  coverageType: null,
+  expiresAt: null,
+  source: null,
+}
+
+const querySchema = z
+  .object({
+    serialNumber: z.string().trim().max(191).optional(),
+    orderId: z.string().uuid().optional(),
+    productId: z.string().uuid().optional(),
+    variantId: z.string().uuid().optional(),
+    sku: z.string().trim().max(191).optional(),
+    purchaseDate: z.string().trim().max(80).optional(),
+    excludeClaimId: z.string().uuid().optional(),
+  })
+  .strict()
+
+const entitlementResultSchema = z.object({
+  warrantyStatus: z.enum(['in_warranty', 'out_of_warranty', 'unknown']),
+  coverageType: z.enum(['standard', 'extended', 'none']).nullable(),
+  expiresAt: z.string().nullable(),
+  source: z.enum(['registration', 'order', 'manual', 'resolver']).nullable(),
+  hasPriorClaims: z.boolean().optional(),
+  priorClaimCount: z.number().int().nonnegative().optional(),
+  priorRegistrationCount: z.number().int().nonnegative().optional(),
+  relatedClaimNumbers: z.array(z.string()).optional(),
+})
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['warranty_claims.claim.view'] },
+}
+
+function hasAnyInput(input: WarrantyEntitlementInput): boolean {
+  return Object.values(input).some((value) => typeof value === 'string' && value.trim().length > 0)
+}
+
+function normalizeInput(query: z.infer<typeof querySchema>): WarrantyEntitlementInput {
+  return {
+    serialNumber: query.serialNumber?.trim() || null,
+    orderId: query.orderId ?? null,
+    productId: query.productId ?? null,
+    variantId: query.variantId ?? null,
+    sku: query.sku?.trim() || null,
+    purchaseDate: query.purchaseDate?.trim() || null,
+  }
+}
+
+function parseNumeric(value: NumericAggregateValue | undefined): number {
+  if (value === undefined || value === null) return 0
+  const parsed = Number(value)
+  return Number.isFinite(parsed) ? Math.trunc(parsed) : 0
+}
+
+async function resolveEntitlementContext(req: Request): Promise<EntitlementRouteContext> {
+  const container = await createRequestContainer()
+  const auth = await getAuthFromRequest(req)
+  const { translate } = await resolveTranslations()
+  if (!auth || !auth.tenantId) {
+    throw new CrudHttpError(401, { error: translate('warranty_claims.errors.unauthorized', 'Unauthorized') })
+  }
+  const organizationScope = await resolveOrganizationScopeForRequest({ container, auth, request: req })
+  const organizationId = organizationScope?.selectedId ?? auth.orgId ?? null
+  if (!organizationId) {
+    throw new CrudHttpError(400, { error: translate('warranty_claims.errors.organization_required', 'Organization context is required') })
+  }
+  return {
+    tenantId: auth.tenantId,
+    organizationId,
+    em: container.resolve<EntityManager>('em').fork(),
+    resolver: container.resolve<WarrantyEntitlementResolver>('warrantyEntitlementResolver'),
+  }
+}
+
+async function resolveSerialHistory(
+  context: Pick<EntitlementRouteContext, 'tenantId' | 'organizationId' | 'em'>,
+  serialNumber: string | null | undefined,
+  excludeClaimId?: string | null,
+): Promise<Pick<EntitlementResponse, 'hasPriorClaims' | 'priorClaimCount' | 'priorRegistrationCount' | 'relatedClaimNumbers'>> {
+  const serial = serialNumber?.trim()
+  if (!serial) return {}
+  const db = context.em.getKysely<EntitlementHistoryDb>()
+  let claimQuery = db
+    .selectFrom('warranty_claim_lines')
+    .innerJoin('warranty_claims', 'warranty_claims.id', 'warranty_claim_lines.claim_id')
+    .select('warranty_claims.claim_number as claimNumber')
+    .distinct()
+    .where('warranty_claim_lines.tenant_id', '=', context.tenantId)
+    .where('warranty_claim_lines.organization_id', '=', context.organizationId)
+    .where('warranty_claim_lines.serial_number', '=', serial)
+    .where('warranty_claim_lines.deleted_at', 'is', null)
+    .where('warranty_claims.tenant_id', '=', context.tenantId)
+    .where('warranty_claims.organization_id', '=', context.organizationId)
+    .where('warranty_claims.deleted_at', 'is', null)
+  if (excludeClaimId) {
+    claimQuery = claimQuery.where('warranty_claim_lines.claim_id', '!=', excludeClaimId)
+  }
+  const claimRows = await claimQuery.execute()
+  const relatedClaimNumbers = Array.from(new Set(
+    claimRows
+      .map((row) => row.claimNumber)
+      .filter((claimNumber): claimNumber is string => typeof claimNumber === 'string' && claimNumber.length > 0),
+  )).sort((left, right) => left.localeCompare(right))
+  const registrationRow = await db
+    .selectFrom('warranty_claim_registrations')
+    .select(sql<NumericAggregateValue>`count(*)`.as('count'))
+    .where('tenant_id', '=', context.tenantId)
+    .where('organization_id', '=', context.organizationId)
+    .where('serial_number', '=', serial)
+    .where('deleted_at', 'is', null)
+    .executeTakeFirst()
+  const priorClaimCount = relatedClaimNumbers.length
+  return {
+    hasPriorClaims: priorClaimCount > 0,
+    priorClaimCount,
+    priorRegistrationCount: parseNumeric(registrationRow?.count),
+    relatedClaimNumbers: relatedClaimNumbers.slice(0, 8),
+  }
+}
+
+export async function GET(req: Request) {
+  try {
+    const url = new URL(req.url)
+    const query = querySchema.parse(Object.fromEntries(url.searchParams))
+    const input = normalizeInput(query)
+    const context = await resolveEntitlementContext(req)
+    const history = await resolveSerialHistory(context, input.serialNumber, query.excludeClaimId)
+    if (!hasAnyInput(input)) {
+      return NextResponse.json({ ...UNKNOWN_ENTITLEMENT, ...history })
+    }
+    const result = await context.resolver.resolveEntitlement(
+      input,
+      { tenantId: context.tenantId, organizationId: context.organizationId },
+      context.em,
+    )
+    return NextResponse.json({ ...result, ...history })
+  } catch (err) {
+    if (isCrudHttpError(err)) return NextResponse.json(err.body, { status: err.status })
+    const { translate } = await resolveTranslations()
+    if (err instanceof z.ZodError) {
+      return NextResponse.json({ error: translate('warranty_claims.errors.invalidInput', 'Invalid input') }, { status: 400 })
+    }
+    logger.error('warranty_claims.entitlement.get failed', { err })
+    return NextResponse.json({ error: translate('warranty_claims.errors.load_failed', 'Failed to load warranty claim data') }, { status: 500 })
+  }
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'Warranty Claims',
+  summary: 'Resolve warranty entitlement',
+  methods: {
+    GET: {
+      summary: 'Resolve warranty entitlement for serial, order, product, SKU, or purchase date facts',
+      query: querySchema,
+      responses: [
+        {
+          status: 200,
+          description: 'Resolved warranty entitlement',
+          schema: entitlementResultSchema,
+        },
+      ],
+    },
+  },
+}

package/src/modules/warranty_claims/api/events/route.ts

@@ -0,0 +1,226 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { EntityManager } from '@mikro-orm/postgresql'
+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 { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { CrudHttpError, isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { readJsonSafe } from '@open-mercato/shared/lib/http/readJsonSafe'
+import { runRouteMutationGuards, type RouteMutationGuardResult } from '@open-mercato/shared/lib/crud/route-mutation-guard'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { WarrantyClaimEvent } from '../../data/entities'
+import { commentClaimInputSchema, type CommentClaimInput } from '../../data/validators'
+import { requireScopedClaim, WARRANTY_CLAIM_RESOURCE_KIND, type WarrantyClaimScope } from '../../commands/shared'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('warranty_claims')
+
+const eventListQuerySchema = z.object({
+  claimId: z.string().uuid(),
+})
+
+type EventRouteContext = {
+  ctx: CommandRuntimeContext
+  tenantId: string
+  organizationId: string
+  scope: WarrantyClaimScope
+  translate: (key: string, fallback?: string) => string
+  em: EntityManager
+}
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['warranty_claims.claim.view'] },
+  POST: { requireAuth: true, requireFeatures: ['warranty_claims.claim.manage'] },
+}
+
+function toRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {}
+}
+
+function relationId(value: unknown): string | null {
+  if (typeof value === 'string') return value
+  const record = toRecord(value)
+  return typeof record.id === 'string' ? record.id : null
+}
+
+function toIso(value: unknown): string | null {
+  if (value instanceof Date) return value.toISOString()
+  if (typeof value === 'string') {
+    const date = new Date(value)
+    return Number.isNaN(date.getTime()) ? value : date.toISOString()
+  }
+  return null
+}
+
+function serializeEvent(event: WarrantyClaimEvent) {
+  return {
+    id: event.id,
+    claimId: relationId(event.claim),
+    kind: event.kind,
+    visibility: event.visibility,
+    body: event.body ?? null,
+    payload: event.payload ?? null,
+    actorUserId: event.actorUserId ?? null,
+    actorCustomerId: event.actorCustomerId ?? null,
+    createdAt: toIso(event.createdAt),
+  }
+}
+
+async function resolveEventContext(req: Request): Promise<EventRouteContext> {
+  const container = await createRequestContainer()
+  const auth = await getAuthFromRequest(req)
+  const { translate } = await resolveTranslations()
+  if (!auth || !auth.tenantId) {
+    throw new CrudHttpError(401, { error: translate('warranty_claims.errors.unauthorized', 'Unauthorized') })
+  }
+  const organizationScope = await resolveOrganizationScopeForRequest({ container, auth, request: req })
+  const organizationId = organizationScope?.selectedId ?? auth.orgId ?? null
+  if (!organizationId) {
+    throw new CrudHttpError(400, { error: translate('warranty_claims.errors.organization_required', 'Organization context is required') })
+  }
+  const em = container.resolve('em') as EntityManager
+  return {
+    ctx: {
+      container,
+      auth,
+      organizationScope,
+      selectedOrganizationId: organizationId,
+      organizationIds: organizationScope?.filterIds ?? (auth.orgId ? [auth.orgId] : null),
+      request: req,
+    },
+    tenantId: auth.tenantId,
+    organizationId,
+    scope: { tenantId: auth.tenantId, organizationId },
+    translate,
+    em,
+  }
+}
+
+async function runCommentGuard(
+  req: Request,
+  context: EventRouteContext,
+  input: CommentClaimInput,
+): Promise<RouteMutationGuardResult> {
+  const userId = context.ctx.auth?.sub
+  if (!userId) {
+    throw new CrudHttpError(401, { error: context.translate('warranty_claims.errors.unauthorized', 'Unauthorized') })
+  }
+  return runRouteMutationGuards({
+    container: context.ctx.container,
+    req,
+    auth: {
+      userId,
+      tenantId: context.tenantId,
+      organizationId: context.organizationId,
+    },
+    input: {
+      resourceKind: WARRANTY_CLAIM_RESOURCE_KIND,
+      resourceId: input.claimId,
+      operation: 'custom',
+      mutationPayload: { ...input },
+    },
+  })
+}
+
+export async function GET(req: Request) {
+  try {
+    const context = await resolveEventContext(req)
+    const url = new URL(req.url)
+    const query = eventListQuerySchema.parse({ claimId: url.searchParams.get('claimId') ?? undefined })
+    const claim = await requireScopedClaim(context.em, query.claimId, context.scope)
+    const events = await findWithDecryption(
+      context.em,
+      WarrantyClaimEvent,
+      { claim: claim.id, tenantId: context.scope.tenantId, organizationId: context.scope.organizationId },
+      { orderBy: { createdAt: 'ASC' } },
+      context.scope,
+    )
+    return NextResponse.json({ items: events.map(serializeEvent) })
+  } catch (err) {
+    if (isCrudHttpError(err)) return NextResponse.json(err.body, { status: err.status })
+    const { translate } = await resolveTranslations()
+    if (err instanceof z.ZodError) {
+      return NextResponse.json({ error: translate('warranty_claims.errors.invalidInput', 'Invalid input') }, { status: 400 })
+    }
+    logger.error('warranty_claims.events.get failed', { err })
+    return NextResponse.json({ error: translate('warranty_claims.errors.notFound', 'Warranty claim not found.') }, { status: 404 })
+  }
+}
+
+export async function POST(req: Request) {
+  try {
+    const context = await resolveEventContext(req)
+    const payload = toRecord(await readJsonSafe(req, {}))
+    const parsed = commentClaimInputSchema.parse(payload)
+    const input: CommentClaimInput = { ...parsed, actorCustomerId: undefined }
+    const guarded = await runCommentGuard(req, context, input)
+    if (!guarded.ok) {
+      return guarded.response
+    }
+    const commandInput = guarded.modifiedPayload
+      ? { ...commentClaimInputSchema.parse(guarded.modifiedPayload), actorCustomerId: undefined }
+      : input
+
+    const commandBus = context.ctx.container.resolve('commandBus') as CommandBus
+    const { result } = await commandBus.execute<CommentClaimInput, { claimId: string }>(
+      'warranty_claims.claim.comment',
+      { input: commandInput, ctx: context.ctx },
+    )
+
+    await guarded.runAfterSuccess()
+
+    return NextResponse.json({ ok: true, claimId: result?.claimId ?? commandInput.claimId })
+  } catch (err) {
+    if (isCrudHttpError(err)) return NextResponse.json(err.body, { status: err.status })
+    const { translate } = await resolveTranslations()
+    if (err instanceof z.ZodError) {
+      return NextResponse.json({ error: translate('warranty_claims.errors.invalidInput', 'Invalid input') }, { status: 400 })
+    }
+    logger.error('warranty_claims.events.post failed', { err })
+    return NextResponse.json({ error: translate('warranty_claims.errors.save_failed', 'Failed to save warranty claim') }, { status: 400 })
+  }
+}
+
+const eventSchema = z.object({
+  id: z.string().uuid(),
+  claimId: z.string().uuid().nullable(),
+  kind: z.string(),
+  visibility: z.string(),
+  body: z.string().nullable(),
+  payload: z.record(z.string(), z.unknown()).nullable(),
+  actorUserId: z.string().uuid().nullable(),
+  actorCustomerId: z.string().uuid().nullable(),
+  createdAt: z.string().nullable(),
+})
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'Warranty Claims',
+  summary: 'Warranty claim timeline events',
+  methods: {
+    GET: {
+      summary: 'List timeline events for a claim',
+      query: eventListQuerySchema,
+      responses: [
+        {
+          status: 200,
+          description: 'Timeline events',
+          schema: z.object({ items: z.array(eventSchema) }),
+        },
+      ],
+    },
+    POST: {
+      summary: 'Append a staff comment to a claim timeline',
+      requestBody: { contentType: 'application/json', schema: commentClaimInputSchema },
+      responses: [
+        {
+          status: 200,
+          description: 'Comment appended',
+          schema: z.object({ ok: z.boolean(), claimId: z.string().uuid() }),
+        },
+      ],
+    },
+  },
+}