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

package/src/modules/warranty_claims/commands/index.ts

@@ -0,0 +1,3 @@
+import './claims'
+import './claim-lines'
+import './settings'

package/src/modules/warranty_claims/commands/settings.ts

@@ -0,0 +1,198 @@
+import { UniqueConstraintViolationException } from '@mikro-orm/core'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { registerCommand, type CommandHandler } from '@open-mercato/shared/lib/commands'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { buildOptimisticLockConflictBody } from '@open-mercato/shared/lib/crud/optimistic-lock-command'
+import { WarrantyClaimSettings } from '../data/entities'
+import {
+  warrantyClaimSettingsSaveSchema,
+  type WarrantyClaimSettingsSaveInput,
+  type WarrantyClaimSettingsUpdateInput,
+} from '../data/validators'
+import {
+  WARRANTY_CLAIM_SETTINGS_DEFAULTS,
+  loadWarrantyClaimSettings,
+  type WarrantyClaimEffectiveSettings,
+} from '../lib/settings'
+import {
+  enforceWarrantyClaimOptimisticLock,
+  ensureOrganizationScope,
+  ensureTenantScope,
+} from './shared'
+
+export const WARRANTY_CLAIM_SETTINGS_RESOURCE_KIND = 'warranty_claims.settings'
+
+export type SaveWarrantyClaimSettingsResult = WarrantyClaimEffectiveSettings & {
+  settingsId: string
+  returnWindowDays: number | null
+  updatedAt: string | null
+}
+
+function parseCommandInput(rawInput: unknown): WarrantyClaimSettingsSaveInput {
+  const parsed = warrantyClaimSettingsSaveSchema.safeParse(rawInput ?? {})
+  if (!parsed.success) {
+    throw new CrudHttpError(400, { error: 'warranty_claims.errors.invalidInput' })
+  }
+  return parsed.data
+}
+
+function isUniqueViolation(error: unknown): boolean {
+  if (error instanceof UniqueConstraintViolationException) return true
+  if (!error || typeof error !== 'object') return false
+  if ((error as { code?: string }).code === '23505') return true
+  const message = (error as { message?: string }).message
+  return typeof message === 'string' && message.includes('duplicate key')
+}
+
+function hasOwn(input: object, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(input, key)
+}
+
+function amountString(value: number | null | undefined): string | null {
+  if (value === null || value === undefined) return null
+  return String(value)
+}
+
+function amountNumber(value: string | number | null | undefined): number | null {
+  if (value === null || value === undefined) return null
+  const parsed = typeof value === 'number' ? value : Number(value)
+  return Number.isFinite(parsed) ? parsed : null
+}
+
+function toIso(value: Date | string | null | undefined): string | null {
+  if (!value) return null
+  const date = value instanceof Date ? value : new Date(value)
+  return Number.isNaN(date.getTime()) ? null : date.toISOString()
+}
+
+function applySettingsUpdate(settings: WarrantyClaimSettings, input: WarrantyClaimSettingsUpdateInput): void {
+  if (hasOwn(input, 'slaHours') && input.slaHours !== undefined) settings.slaHours = input.slaHours
+  if (hasOwn(input, 'slaPauseOnInfoRequested') && input.slaPauseOnInfoRequested !== undefined) {
+    settings.slaPauseOnInfoRequested = input.slaPauseOnInfoRequested
+  }
+  if (hasOwn(input, 'slaAtRiskThresholdPct') && input.slaAtRiskThresholdPct !== undefined) {
+    settings.slaAtRiskThresholdPct = input.slaAtRiskThresholdPct
+  }
+  if (hasOwn(input, 'autoApproveEnabled') && input.autoApproveEnabled !== undefined) {
+    settings.autoApproveEnabled = input.autoApproveEnabled
+  }
+  if (hasOwn(input, 'autoApproveMaxAmount')) settings.autoApproveMaxAmount = amountString(input.autoApproveMaxAmount)
+  if (hasOwn(input, 'autoApproveCurrencyCode')) settings.autoApproveCurrencyCode = input.autoApproveCurrencyCode ?? null
+  if (hasOwn(input, 'autoApproveRequireInWarranty') && input.autoApproveRequireInWarranty !== undefined) {
+    settings.autoApproveRequireInWarranty = input.autoApproveRequireInWarranty
+  }
+  if (hasOwn(input, 'defaultWarrantyMonths')) settings.defaultWarrantyMonths = input.defaultWarrantyMonths ?? null
+  if (hasOwn(input, 'businessHours')) settings.businessHours = input.businessHours ?? null
+  if (hasOwn(input, 'escalationTiers')) settings.escalationTiers = input.escalationTiers ?? null
+  if (hasOwn(input, 'adjudicationUseRules') && input.adjudicationUseRules !== undefined) {
+    settings.adjudicationUseRules = input.adjudicationUseRules
+  }
+  if (hasOwn(input, 'quarantineGrades')) settings.quarantineGrades = input.quarantineGrades ?? null
+  if (hasOwn(input, 'returnLabelProvider')) settings.returnLabelProvider = input.returnLabelProvider ?? null
+  if (hasOwn(input, 'returnWindowDays')) settings.returnWindowDays = input.returnWindowDays ?? null
+}
+
+function assertAutoApproveConfig(settings: WarrantyClaimSettings): void {
+  if (!settings.autoApproveEnabled) return
+  if (settings.autoApproveMaxAmount !== null && settings.autoApproveMaxAmount !== undefined && settings.autoApproveCurrencyCode) return
+  throw new CrudHttpError(400, { error: 'warranty_claims.errors.autoApproveConfigIncomplete' })
+}
+
+function buildResult(settings: WarrantyClaimSettings): SaveWarrantyClaimSettingsResult {
+  return {
+    settingsId: settings.id,
+    slaHours: settings.slaHours,
+    slaPauseOnInfoRequested: settings.slaPauseOnInfoRequested,
+    slaAtRiskThresholdPct: settings.slaAtRiskThresholdPct,
+    autoApproveEnabled: settings.autoApproveEnabled,
+    autoApproveMaxAmount: amountNumber(settings.autoApproveMaxAmount),
+    autoApproveCurrencyCode: settings.autoApproveCurrencyCode ?? null,
+    autoApproveRequireInWarranty: settings.autoApproveRequireInWarranty,
+    defaultWarrantyMonths: settings.defaultWarrantyMonths ?? null,
+    businessHours: settings.businessHours ?? null,
+    escalationTiers: settings.escalationTiers ?? null,
+    adjudicationUseRules: settings.adjudicationUseRules,
+    quarantineGrades: settings.quarantineGrades ?? null,
+    returnLabelProvider: settings.returnLabelProvider ?? null,
+    returnWindowDays: settings.returnWindowDays ?? null,
+    updatedAt: toIso(settings.updatedAt),
+  }
+}
+
+const saveWarrantyClaimSettingsCommand: CommandHandler<
+  WarrantyClaimSettingsSaveInput,
+  SaveWarrantyClaimSettingsResult
+> = {
+  id: 'warranty_claims.settings.save',
+  async execute(rawInput, ctx) {
+    const input = parseCommandInput(rawInput)
+    ensureTenantScope(ctx, input.tenantId)
+    ensureOrganizationScope(ctx, input.organizationId)
+
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    let settings = await loadWarrantyClaimSettings(em, {
+      tenantId: input.tenantId,
+      organizationId: input.organizationId,
+    })
+    const exists = Boolean(settings)
+
+    if (settings) {
+      await enforceWarrantyClaimOptimisticLock(ctx, settings, WARRANTY_CLAIM_SETTINGS_RESOURCE_KIND)
+    } else {
+      const now = new Date()
+      settings = em.create(WarrantyClaimSettings, {
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+        slaHours: WARRANTY_CLAIM_SETTINGS_DEFAULTS.slaHours,
+        slaPauseOnInfoRequested: WARRANTY_CLAIM_SETTINGS_DEFAULTS.slaPauseOnInfoRequested,
+        slaAtRiskThresholdPct: WARRANTY_CLAIM_SETTINGS_DEFAULTS.slaAtRiskThresholdPct,
+        autoApproveEnabled: WARRANTY_CLAIM_SETTINGS_DEFAULTS.autoApproveEnabled,
+        autoApproveMaxAmount: null,
+        autoApproveCurrencyCode: null,
+        autoApproveRequireInWarranty: WARRANTY_CLAIM_SETTINGS_DEFAULTS.autoApproveRequireInWarranty,
+        defaultWarrantyMonths: WARRANTY_CLAIM_SETTINGS_DEFAULTS.defaultWarrantyMonths,
+        businessHours: WARRANTY_CLAIM_SETTINGS_DEFAULTS.businessHours,
+        escalationTiers: WARRANTY_CLAIM_SETTINGS_DEFAULTS.escalationTiers,
+        adjudicationUseRules: WARRANTY_CLAIM_SETTINGS_DEFAULTS.adjudicationUseRules,
+        quarantineGrades: WARRANTY_CLAIM_SETTINGS_DEFAULTS.quarantineGrades,
+        returnLabelProvider: WARRANTY_CLAIM_SETTINGS_DEFAULTS.returnLabelProvider,
+        returnWindowDays: null,
+        createdAt: now,
+        updatedAt: now,
+      })
+      em.persist(settings)
+    }
+
+    applySettingsUpdate(settings, input)
+    assertAutoApproveConfig(settings)
+    if (exists) settings.updatedAt = new Date()
+
+    try {
+      await em.flush()
+    } catch (error) {
+      if (exists || !isUniqueViolation(error)) throw error
+      const retryEm = (ctx.container.resolve('em') as EntityManager).fork()
+      const winner = await loadWarrantyClaimSettings(retryEm, {
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+      })
+      if (!winner) throw error
+      const currentUpdatedAt = toIso(winner.updatedAt)
+      const expectedUpdatedAt = toIso(settings.updatedAt)
+      if (currentUpdatedAt && expectedUpdatedAt) {
+        throw new CrudHttpError(409, buildOptimisticLockConflictBody(currentUpdatedAt, expectedUpdatedAt))
+      }
+      throw new CrudHttpError(409, { error: 'warranty_claims.errors.conflict' })
+    }
+
+    return buildResult(settings)
+  },
+}
+
+registerCommand(saveWarrantyClaimSettingsCommand)
+
+export const warrantyClaimSettingsCommands = [saveWarrantyClaimSettingsCommand]
+
+export {
+  saveWarrantyClaimSettingsCommand,
+}

package/src/modules/warranty_claims/commands/shared.ts

@@ -0,0 +1,212 @@
+import { randomUUID } from 'crypto'
+import type { FindOneOptions } from '@mikro-orm/core'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
+import { assertFound } from '@open-mercato/shared/lib/crud/errors'
+import { invalidateCrudCache } from '@open-mercato/shared/lib/crud/cache'
+import { enforceCommandOptimisticLockWithGuards } from '@open-mercato/shared/lib/crud/optimistic-lock-command'
+import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
+import { emitCrudSideEffects, flushCrudSideEffects } from '@open-mercato/shared/lib/commands/helpers'
+import type { DataEngine } from '@open-mercato/shared/lib/data/engine'
+import { findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import {
+  WarrantyClaim,
+  WarrantyClaimEvent,
+  WarrantyClaimLine,
+} from '../data/entities'
+import type {
+  WarrantyClaimEventKind,
+  WarrantyClaimEventVisibility,
+} from '../data/validators'
+import { computeHeaderRollups } from '../lib/stateMachine'
+
+export { assertFound } from '@open-mercato/shared/lib/crud/errors'
+export { ensureOrganizationScope, ensureSameScope, ensureTenantScope } from '@open-mercato/shared/lib/commands/scope'
+export { extractUndoPayload } from '@open-mercato/shared/lib/commands/undo'
+
+export const WARRANTY_CLAIM_RESOURCE_KIND = 'warranty_claims.claim'
+export const WARRANTY_CLAIM_LINE_RESOURCE_KIND = 'warranty_claims.claim_line'
+
+export type WarrantyClaimScope = {
+  organizationId: string
+  tenantId: string
+}
+
+export type VersionedRecord = {
+  id: string
+  updatedAt?: Date | string | null
+}
+
+export type ResolverContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+export type AppendClaimEventInput = {
+  visibility?: WarrantyClaimEventVisibility
+  body?: string | null
+  payload?: Record<string, unknown> | null
+  actorUserId?: string | null
+  actorCustomerId?: string | null
+}
+
+export async function enforceWarrantyClaimOptimisticLock(
+  ctx: CommandRuntimeContext,
+  record: VersionedRecord | null | undefined,
+  resourceKind = WARRANTY_CLAIM_RESOURCE_KIND,
+  expected?: string | Date | null,
+): Promise<void> {
+  if (!record) return
+  await enforceCommandOptimisticLockWithGuards(ctx.container, {
+    resourceKind,
+    resourceId: record.id,
+    current: record.updatedAt ?? null,
+    expected,
+    request: ctx.request ?? null,
+  })
+}
+
+export async function loadScopedClaim(
+  em: EntityManager,
+  id: string,
+  scope: WarrantyClaimScope,
+  options: FindOneOptions<WarrantyClaim> = {},
+): Promise<WarrantyClaim | null> {
+  return findOneWithDecryption(
+    em,
+    WarrantyClaim,
+    { id, tenantId: scope.tenantId, organizationId: scope.organizationId, deletedAt: null },
+    options,
+    scope,
+  )
+}
+
+export async function requireScopedClaim(
+  em: EntityManager,
+  id: string,
+  scope: WarrantyClaimScope,
+  options: FindOneOptions<WarrantyClaim> = {},
+): Promise<WarrantyClaim> {
+  const claim = await loadScopedClaim(em, id, scope, options)
+  return assertFound(claim, 'warranty_claims.errors.notFound')
+}
+
+export function appendClaimEvent(
+  em: EntityManager,
+  claim: WarrantyClaim,
+  kind: WarrantyClaimEventKind,
+  input: AppendClaimEventInput = {},
+): WarrantyClaimEvent {
+  const event = em.create(WarrantyClaimEvent, {
+    id: randomUUID(),
+    claim,
+    organizationId: claim.organizationId,
+    tenantId: claim.tenantId,
+    kind,
+    visibility: input.visibility ?? 'internal',
+    body: input.body ?? null,
+    payload: input.payload ?? null,
+    actorUserId: input.actorUserId ?? null,
+    actorCustomerId: input.actorCustomerId ?? null,
+    createdAt: new Date(),
+  })
+  em.persist(event)
+  return event
+}
+
+export async function reconcileVendorRecoverySourceClaim(
+  ctx: ResolverContext,
+  input: { claimId: string; tenantId: string; organizationId: string },
+): Promise<void> {
+  const em = (ctx.resolve('em') as EntityManager).fork()
+  const scope = { tenantId: input.tenantId, organizationId: input.organizationId }
+  const recoveryClaim = await findOneWithDecryption(
+    em,
+    WarrantyClaim,
+    { id: input.claimId, tenantId: scope.tenantId, organizationId: scope.organizationId, deletedAt: null },
+    {},
+    scope,
+  )
+  if (!recoveryClaim || recoveryClaim.claimType !== 'vendor_recovery' || !recoveryClaim.sourceClaimId) return
+
+  const sourceClaim = await findOneWithDecryption(
+    em,
+    WarrantyClaim,
+    { id: recoveryClaim.sourceClaimId, tenantId: scope.tenantId, organizationId: scope.organizationId, deletedAt: null },
+    {},
+    scope,
+  )
+  if (!sourceClaim) return
+
+  const resolvedChildren = await findWithDecryption(
+    em,
+    WarrantyClaim,
+    {
+      sourceClaimId: sourceClaim.id,
+      claimType: 'vendor_recovery',
+      status: { $in: ['resolved', 'closed'] },
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      deletedAt: null,
+    },
+    {},
+    scope,
+  )
+  const childLines = resolvedChildren.length
+    ? await findWithDecryption(
+        em,
+        WarrantyClaimLine,
+        {
+          claim: { $in: resolvedChildren.map((child) => child.id) },
+          tenantId: scope.tenantId,
+          organizationId: scope.organizationId,
+          deletedAt: null,
+        },
+        {},
+        scope,
+      )
+    : []
+  const recoveredTotal = computeHeaderRollups(childLines).totalApprovedAmount
+  await withAtomicFlush(
+    em,
+    [
+      () => {
+        sourceClaim.totalRecoveredAmount = String(recoveredTotal)
+        sourceClaim.updatedAt = new Date()
+      },
+    ],
+    { transaction: true, label: 'warranty_claims.vendor_recovery.reconciliation' },
+  )
+
+  const dataEngine = ctx.resolve<DataEngine>('dataEngine')
+  await emitCrudSideEffects({
+    dataEngine,
+    action: 'updated',
+    entity: sourceClaim,
+    identifiers: {
+      id: sourceClaim.id,
+      organizationId: sourceClaim.organizationId,
+      tenantId: sourceClaim.tenantId,
+    },
+    indexer: { entityType: 'warranty_claims:warranty_claim' },
+    events: {
+      module: 'warranty_claims',
+      entity: 'claim',
+      persistent: true,
+      buildPayload: () => ({
+        id: sourceClaim.id,
+        organizationId: sourceClaim.organizationId,
+        tenantId: sourceClaim.tenantId,
+        claimType: sourceClaim.claimType,
+        status: sourceClaim.status,
+      }),
+    },
+  })
+  await flushCrudSideEffects(dataEngine)
+  await invalidateCrudCache(
+    ctx as unknown as Parameters<typeof invalidateCrudCache>[0],
+    'warranty_claims.claim',
+    { id: sourceClaim.id, organizationId: sourceClaim.organizationId, tenantId: sourceClaim.tenantId },
+    input.tenantId,
+    'warranty_claims.vendor_recovery.reconciliation',
+  )
+}

package/src/modules/warranty_claims/data/constants.ts

@@ -0,0 +1,37 @@
+import type { WarrantyClaimStatus, WarrantyClaimType } from './validators'
+
+export const CLAIM_STATUS_TRANSITIONS: Record<WarrantyClaimStatus, WarrantyClaimStatus[]> = {
+  draft: ['submitted', 'cancelled'],
+  submitted: ['in_review', 'cancelled'],
+  in_review: ['info_requested', 'approved', 'rejected', 'cancelled'],
+  info_requested: ['in_review', 'rejected', 'cancelled'],
+  approved: ['awaiting_return', 'resolved', 'cancelled'],
+  awaiting_return: ['received', 'cancelled'],
+  received: ['inspecting'],
+  inspecting: ['resolved'],
+  resolved: ['closed'],
+  rejected: ['in_review', 'closed'],
+  closed: ['in_review'],
+  cancelled: [],
+}
+
+// Customer-detail claim metrics treat these states as no longer open. `rejected`
+// can be reopened by the lifecycle, but it must not count toward active claims.
+export const CLAIM_METRIC_TERMINAL_STATUSES = ['resolved', 'closed', 'cancelled', 'rejected'] as const
+
+export const DEFAULT_SLA_HOURS = 48
+
+export const CLAIM_NUMBER_PREFIXES: Record<WarrantyClaimType, string> = {
+  warranty: 'WTY',
+  return: 'RMA',
+  core_return: 'COR',
+  vendor_recovery: 'VRC',
+}
+
+export const WARRANTY_CLAIM_DICTIONARY_KINDS = [
+  'warranty-claim-fault-code',
+  'warranty-claim-reason',
+  'warranty-claim-rejection-reason',
+] as const
+
+export type WarrantyClaimDictionaryKind = (typeof WARRANTY_CLAIM_DICTIONARY_KINDS)[number]

package/src/modules/warranty_claims/data/enrichers.ts

@@ -0,0 +1,165 @@
+import type { Kysely } from 'kysely'
+import type { EnricherContext, ResponseEnricher } from '@open-mercato/shared/lib/crud/response-enricher'
+import { CLAIM_METRIC_TERMINAL_STATUSES } from './constants'
+
+type NumericAggregateValue = string | number | bigint | null
+type NumericCountValue = Exclude<NumericAggregateValue, null>
+
+type WarrantyClaimMetricsTable = {
+  customer_id: string | null
+  organization_id: string
+  tenant_id: string
+  status: string
+  created_at: Date | string | null
+  deleted_at: Date | string | null
+}
+
+type WarrantyClaimsEnricherDb = {
+  warranty_claims: WarrantyClaimMetricsTable
+}
+
+type CustomerRecord = Record<string, unknown> & {
+  id: string
+}
+
+type WarrantyClaimsPayload = {
+  openCount: number
+  lifetimeCount: number
+  lastClaimDate: string | null
+}
+
+type WarrantyClaimsEnrichment = {
+  _warranty_claims: WarrantyClaimsPayload
+}
+
+type ClaimMetricsRow = {
+  customer_id: string | null
+  lifetime_count: NumericAggregateValue
+  open_count: NumericAggregateValue
+  last_claim_date: Date | string | null
+}
+
+const ZERO_WARRANTY_CLAIMS_PAYLOAD: WarrantyClaimsPayload = {
+  openCount: 0,
+  lifetimeCount: 0,
+  lastClaimDate: null,
+}
+
+function resolveKyselyClient<TDb>(em: unknown): Kysely<TDb> | null {
+  if (em == null || typeof em !== 'object') return null
+  const getKysely = (em as { getKysely?: unknown }).getKysely
+  if (typeof getKysely !== 'function') return null
+  const db = (getKysely as () => unknown).call(em)
+  if (db == null) return null
+  return db as Kysely<TDb>
+}
+
+function parseCount(value: NumericAggregateValue): number {
+  if (value === null) return 0
+  const parsed = Number(value)
+  return Number.isFinite(parsed) ? Math.trunc(parsed) : 0
+}
+
+function toIsoString(value: Date | string | null): string | null {
+  if (value === null) return null
+  const date = value instanceof Date ? value : new Date(value)
+  return Number.isNaN(date.getTime()) ? null : date.toISOString()
+}
+
+function withZeroPayload(records: CustomerRecord[]): Array<CustomerRecord & WarrantyClaimsEnrichment> {
+  return records.map((record) => ({
+    ...record,
+    _warranty_claims: ZERO_WARRANTY_CLAIMS_PAYLOAD,
+  }))
+}
+
+async function enrichCustomerClaimMetrics(
+  records: CustomerRecord[],
+  context: EnricherContext,
+): Promise<Array<CustomerRecord & WarrantyClaimsEnrichment>> {
+  if (records.length === 0) return []
+
+  const db = resolveKyselyClient<WarrantyClaimsEnricherDb>(context.em)
+  if (!db) return withZeroPayload(records)
+
+  const customerIds = records
+    .map((record) => record.id)
+    .filter((id): id is string => typeof id === 'string' && id.length > 0)
+
+  if (customerIds.length === 0) return withZeroPayload(records)
+
+  const rows = await db
+    .selectFrom('warranty_claims')
+    .select(['customer_id'])
+    .select((eb) => [
+      eb.fn.countAll<NumericCountValue>().as('lifetime_count'),
+      eb.fn.countAll<NumericCountValue>()
+        .filterWhere('status', 'not in', [...CLAIM_METRIC_TERMINAL_STATUSES])
+        .as('open_count'),
+      eb.fn.max<Date | string | null>('created_at').as('last_claim_date'),
+    ])
+    .where('tenant_id', '=', context.tenantId)
+    .where('organization_id', '=', context.organizationId)
+    .where('deleted_at', 'is', null)
+    .where('customer_id', 'in', customerIds)
+    .groupBy('customer_id')
+    .execute() as ClaimMetricsRow[]
+
+  const metricsByCustomer = new Map<string, WarrantyClaimsPayload>()
+  for (const row of rows) {
+    const customerId = typeof row.customer_id === 'string' ? row.customer_id : null
+    if (!customerId) continue
+    metricsByCustomer.set(customerId, {
+      openCount: parseCount(row.open_count),
+      lifetimeCount: parseCount(row.lifetime_count),
+      lastClaimDate: toIsoString(row.last_claim_date),
+    })
+  }
+
+  return records.map((record) => ({
+    ...record,
+    _warranty_claims: metricsByCustomer.get(record.id) ?? ZERO_WARRANTY_CLAIMS_PAYLOAD,
+  }))
+}
+
+export const warrantyClaimsPersonEnricher: ResponseEnricher<CustomerRecord, WarrantyClaimsEnrichment> = {
+  id: 'warranty_claims.customer-claim-metrics-person',
+  targetEntity: 'customers.person',
+  features: ['warranty_claims.claim.view'],
+  priority: 20,
+  timeout: 1500,
+  fallback: { _warranty_claims: ZERO_WARRANTY_CLAIMS_PAYLOAD },
+  critical: false,
+  cacheableOnListHit: false,
+
+  async enrichOne(record, context) {
+    const enriched = await this.enrichMany!([record], context)
+    return enriched[0]
+  },
+
+  async enrichMany(records, context) {
+    return enrichCustomerClaimMetrics(records, context)
+  },
+}
+
+export const warrantyClaimsCompanyEnricher: ResponseEnricher<CustomerRecord, WarrantyClaimsEnrichment> = {
+  id: 'warranty_claims.customer-claim-metrics-company',
+  targetEntity: 'customers.company',
+  features: ['warranty_claims.claim.view'],
+  priority: 20,
+  timeout: 1500,
+  fallback: { _warranty_claims: ZERO_WARRANTY_CLAIMS_PAYLOAD },
+  critical: false,
+  cacheableOnListHit: false,
+
+  async enrichOne(record, context) {
+    const enriched = await this.enrichMany!([record], context)
+    return enriched[0]
+  },
+
+  async enrichMany(records, context) {
+    return enrichCustomerClaimMetrics(records, context)
+  },
+}
+
+export const enrichers: ResponseEnricher[] = [warrantyClaimsPersonEnricher, warrantyClaimsCompanyEnricher]