npm - @open-mercato/core - Versions diffs - 0.6.8-develop.6998.1.d2bc46c56c → 0.6.8-develop.7001.1.03608ab252 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (651) hide show

package/src/modules/warranty_claims/lib/portalAttachmentValidation.ts ADDED Viewed

@@ -0,0 +1,115 @@
+import type { TranslateFn } from '@open-mercato/shared/lib/i18n/context'
+export const DEFAULT_ATTACHMENT_MAX_UPLOAD_BYTES = 25 * 1024 * 1024
+export const ATTACHMENT_ACCEPT_TYPES = [
+  '.avif',
+  '.bmp',
+  '.csv',
+  '.docx',
+  '.gif',
+  '.jpeg',
+  '.jpg',
+  '.json',
+  '.md',
+  '.pdf',
+  '.png',
+  '.pptx',
+  '.txt',
+  '.webp',
+  '.xlsx',
+  '.zip',
+  'application/json',
+  'application/pdf',
+  'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  'application/zip',
+  'image/avif',
+  'image/bmp',
+  'image/gif',
+  'image/jpeg',
+  'image/png',
+  'image/webp',
+  'text/csv',
+  'text/markdown',
+  'text/plain',
+].join(',')
+const BLOCKED_ATTACHMENT_MIME_TYPES = new Set([
+  'application/xhtml+xml',
+  'application/xml',
+  'image/svg+xml',
+  'text/html',
+  'text/xml',
+])
+const ACTIVE_CONTENT_ATTACHMENT_EXTENSIONS = new Set([
+  'htm',
+  'html',
+  'svg',
+  'xhtml',
+  'xml',
+])
+const DANGEROUS_EXECUTABLE_EXTENSIONS = new Set([
+  'app',
+  'apk',
+  'bat',
+  'cmd',
+  'com',
+  'dll',
+  'exe',
+  'hta',
+  'htm',
+  'html',
+  'jar',
+  'js',
+  'jse',
+  'lnk',
+  'msi',
+  'pif',
+  'ps1',
+  'psm1',
+  'reg',
+  'scr',
+  'sh',
+  'vbe',
+  'vbs',
+  'wsf',
+  'wsh',
+])
+function getFileExtensionSegments(fileName: string): string[] {
+  const parts = fileName.trim().split('.').filter(Boolean)
+  if (parts.length < 2) return []
+  return parts.slice(1).map((part) => part.toLowerCase().replace(/[^a-z0-9]/g, '')).filter(Boolean)
+}
+async function fileLooksLikeActiveContent(file: File): Promise<boolean> {
+  try {
+    const sniff = (await file.slice(0, 512).text()).trimStart().toLowerCase()
+    return sniff.startsWith('<svg') || sniff.startsWith('<?xml') || sniff.startsWith('<!doctype html') || sniff.startsWith('<html')
+  } catch {
+    return false
+  }
+}
+export async function validateAttachmentFile(file: File, t: TranslateFn): Promise<string | null> {
+  if (file.size > DEFAULT_ATTACHMENT_MAX_UPLOAD_BYTES) {
+    return t('attachments.errors.maxUploadSize')
+  }
+  const extensionSegments = getFileExtensionSegments(file.name)
+  const mimeType = file.type.trim().toLowerCase()
+  if (extensionSegments.some((extension) => DANGEROUS_EXECUTABLE_EXTENSIONS.has(extension))) {
+    return t('attachments.errors.dangerousExecutable')
+  }
+  if (
+    extensionSegments.some((extension) => ACTIVE_CONTENT_ATTACHMENT_EXTENSIONS.has(extension)) ||
+    (mimeType && BLOCKED_ATTACHMENT_MIME_TYPES.has(mimeType)) ||
+    await fileLooksLikeActiveContent(file)
+  ) {
+    return t('attachments.errors.activeContentBlocked')
+  }
+  return null
+}

package/src/modules/warranty_claims/lib/portalClaimAccess.ts ADDED Viewed

@@ -0,0 +1,37 @@
+import type { EntityManager, FilterQuery } from '@mikro-orm/postgresql'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { WarrantyClaim } from '../data/entities'
+export type PortalClaimOwnerScope = {
+  tenantId: string
+  organizationId: string
+  customerId: string
+}
+export function buildPortalOwnedClaimWhere(
+  scope: PortalClaimOwnerScope,
+  extra: Record<string, unknown> = {},
+): Record<string, unknown> & FilterQuery<WarrantyClaim> {
+  return {
+    ...extra,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    customerId: scope.customerId,
+    claimType: { $ne: 'vendor_recovery' },
+    deletedAt: null,
+  } as Record<string, unknown> & FilterQuery<WarrantyClaim>
+}
+export async function loadPortalOwnedClaim(
+  em: EntityManager,
+  scope: PortalClaimOwnerScope,
+  claimId: string,
+): Promise<WarrantyClaim | null> {
+  return findOneWithDecryption(
+    em,
+    WarrantyClaim,
+    buildPortalOwnedClaimWhere(scope, { id: claimId }),
+    {},
+    { tenantId: scope.tenantId, organizationId: scope.organizationId },
+  )
+}

package/src/modules/warranty_claims/lib/quantity.ts ADDED Viewed

@@ -0,0 +1,15 @@
+export function parseQuantity(value: string | number | null | undefined): number | null {
+  if (value === null || value === undefined) return null
+  const parsed = typeof value === 'number' ? value : value.trim().length ? Number(value) : Number.NaN
+  return Number.isFinite(parsed) ? parsed : null
+}
+export function formatQuantity(value: string | number | null | undefined, fallback: string): string {
+  const parsed = parseQuantity(value)
+  return parsed === null ? fallback : parsed.toLocaleString(undefined, { maximumFractionDigits: 4 })
+}
+export function quantityInputValue(value: string | number | null | undefined): string {
+  const parsed = parseQuantity(value)
+  return parsed === null ? '' : String(parsed)
+}

package/src/modules/warranty_claims/lib/risk.ts ADDED Viewed

@@ -0,0 +1,371 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { sql } from 'kysely'
+import { WarrantyClaim, WarrantyClaimLine } from '../data/entities'
+import { loadWarrantyClaimSettings } from './settings'
+export type ClaimRiskLevel = 'none' | 'low' | 'medium' | 'high'
+export type ClaimRiskSignal = {
+  id: 'duplicate_serial' | 'duplicate_order_claim' | 'outside_return_window' | 'over_quantity_claim' | 'repeat_claimer' | 'value_velocity'
+  level: 'low' | 'medium' | 'high'
+  messageKey: string
+  params?: Record<string, string | number>
+  relatedClaimNumbers?: string[]
+}
+export type ClaimRiskAssessment = { level: ClaimRiskLevel; signals: ClaimRiskSignal[] }
+type NumericAggregateValue = string | number | bigint | null
+type WarrantyClaimsTable = {
+  id: string
+  organization_id: string
+  tenant_id: string
+  claim_number: string
+  status: string
+  customer_id: string | null
+  order_id: string | null
+  currency_code: string | null
+  total_claimed_amount: string | number | null
+  created_at: Date
+  deleted_at: Date | null
+}
+type WarrantyClaimLinesTable = {
+  id: string
+  claim_id: string
+  organization_id: string
+  tenant_id: string
+  order_line_id: string | null
+  qty_claimed: string | number | null
+  line_status: string
+  serial_number: string | null
+  deleted_at: Date | null
+}
+type SalesOrderLinesTable = {
+  id: string
+  organization_id: string
+  tenant_id: string
+  quantity: string | number | null
+  deleted_at: Date | null
+}
+type SalesOrdersTable = {
+  id: string
+  organization_id: string
+  tenant_id: string
+  placed_at: Date | string | null
+  created_at: Date | string | null
+  deleted_at: Date | null
+}
+type WarrantyClaimsRiskDb = {
+  warranty_claims: WarrantyClaimsTable
+  warranty_claim_lines: WarrantyClaimLinesTable
+  sales_order_lines: SalesOrderLinesTable
+  sales_orders: SalesOrdersTable
+}
+const DUPLICATE_SERIAL_LEVEL = 'high' satisfies ClaimRiskSignal['level']
+const REPEAT_CLAIMER_MEDIUM_COUNT = 3
+const REPEAT_CLAIMER_HIGH_COUNT = 5
+const VALUE_VELOCITY_MEDIUM_TOTAL = 10000
+const VALUE_VELOCITY_HIGH_TOTAL = 50000
+const RISK_WINDOW_DAYS = 90
+const MILLISECONDS_PER_DAY = 86_400_000
+const QUANTITY_SCALE = 10_000
+const LEVEL_RANK: Record<ClaimRiskLevel, number> = { none: 0, low: 1, medium: 2, high: 3 }
+function parseNumeric(value: NumericAggregateValue): number {
+  if (value === null) return 0
+  const parsed = Number(value)
+  return Number.isFinite(parsed) ? parsed : 0
+}
+function parseNullableNumeric(value: NumericAggregateValue): number | null {
+  if (value === null) return null
+  const parsed = Number(value)
+  return Number.isFinite(parsed) ? parsed : null
+}
+function roundQuantity(value: number): number {
+  return Math.round((value + Number.EPSILON) * QUANTITY_SCALE) / QUANTITY_SCALE
+}
+function isMissingTableError(err: unknown, tableName: string): boolean {
+  if (typeof err !== 'object' || err === null) return false
+  const candidate = err as { code?: unknown; message?: unknown }
+  return candidate.code === '42P01'
+    || (typeof candidate.message === 'string'
+      && candidate.message.includes(tableName)
+      && candidate.message.includes('does not exist'))
+}
+function maxRiskLevel(signals: ClaimRiskSignal[]): ClaimRiskLevel {
+  let level: ClaimRiskLevel = 'none'
+  for (const signal of signals) {
+    if (LEVEL_RANK[signal.level] > LEVEL_RANK[level]) {
+      level = signal.level
+    }
+  }
+  return level
+}
+function riskWindowStart(now = new Date()): Date {
+  return new Date(now.getTime() - RISK_WINDOW_DAYS * 24 * 60 * 60 * 1000)
+}
+export async function evaluateClaimRisk(
+  em: EntityManager,
+  claim: WarrantyClaim,
+  lines: WarrantyClaimLine[],
+  now = new Date(),
+): Promise<ClaimRiskAssessment> {
+  const db = em.getKysely<WarrantyClaimsRiskDb>()
+  const signals: ClaimRiskSignal[] = []
+  const scope = { tenantId: claim.tenantId, organizationId: claim.organizationId }
+  const serials = Array.from(new Set(lines
+    .map((line) => line.serialNumber?.trim() ?? '')
+    .filter((serial): serial is string => serial.length > 0)))
+  if (serials.length > 0) {
+    const rows = await db
+      .selectFrom('warranty_claim_lines')
+      .innerJoin('warranty_claims', 'warranty_claims.id', 'warranty_claim_lines.claim_id')
+      .select([
+        'warranty_claim_lines.serial_number as serialNumber',
+        'warranty_claims.claim_number as claimNumber',
+      ])
+      .where('warranty_claim_lines.tenant_id', '=', scope.tenantId)
+      .where('warranty_claim_lines.organization_id', '=', scope.organizationId)
+      .where('warranty_claim_lines.deleted_at', 'is', null)
+      .where('warranty_claims.tenant_id', '=', scope.tenantId)
+      .where('warranty_claims.organization_id', '=', scope.organizationId)
+      .where('warranty_claims.deleted_at', 'is', null)
+      .where('warranty_claims.id', '!=', claim.id)
+      .where('warranty_claims.status', '!=', 'cancelled')
+      .where('warranty_claim_lines.serial_number', 'in', serials)
+      .execute()
+    const relatedBySerial = new Map<string, Set<string>>()
+    for (const row of rows) {
+      if (!row.serialNumber || !row.claimNumber) continue
+      const related = relatedBySerial.get(row.serialNumber) ?? new Set<string>()
+      related.add(row.claimNumber)
+      relatedBySerial.set(row.serialNumber, related)
+    }
+    for (const serial of serials) {
+      const related = relatedBySerial.get(serial)
+      if (!related || related.size === 0) continue
+      signals.push({
+        id: 'duplicate_serial',
+        level: DUPLICATE_SERIAL_LEVEL,
+        messageKey: 'warranty_claims.risk.duplicateSerial',
+        params: { serial, count: related.size },
+        relatedClaimNumbers: Array.from(related).sort((left, right) => left.localeCompare(right)),
+      })
+    }
+  }
+  const orderId = claim.orderId ?? null
+  if (orderId) {
+    const orderRows = await db
+      .selectFrom('warranty_claims')
+      .select('claim_number as claimNumber')
+      .where('tenant_id', '=', scope.tenantId)
+      .where('organization_id', '=', scope.organizationId)
+      .where('deleted_at', 'is', null)
+      .where('order_id', '=', orderId)
+      .where('status', '!=', 'cancelled')
+      .where('id', '!=', claim.id)
+      .execute()
+    const relatedOrderClaims = Array.from(new Set(
+      orderRows
+        .map((row) => row.claimNumber)
+        .filter((claimNumber): claimNumber is string => typeof claimNumber === 'string' && claimNumber.length > 0),
+    )).sort((left, right) => left.localeCompare(right))
+    if (relatedOrderClaims.length > 0) {
+      signals.push({
+        id: 'duplicate_order_claim',
+        level: 'medium',
+        messageKey: 'warranty_claims.risk.duplicateOrderClaim',
+        params: { count: relatedOrderClaims.length },
+        relatedClaimNumbers: relatedOrderClaims,
+      })
+    }
+  }
+  if (orderId && (claim.claimType === 'return' || claim.claimType === 'core_return')) {
+    const settings = await loadWarrantyClaimSettings(em, scope)
+    const returnWindowDays = settings?.returnWindowDays ?? null
+    if (returnWindowDays !== null && returnWindowDays > 0) {
+      let order: { placedAt: Date | string | null; createdAt: Date | string | null } | undefined
+      try {
+        order = await db
+          .selectFrom('sales_orders')
+          .select(['placed_at as placedAt', 'created_at as createdAt'])
+          .where('id', '=', orderId)
+          .where('tenant_id', '=', scope.tenantId)
+          .where('organization_id', '=', scope.organizationId)
+          .where('deleted_at', 'is', null)
+          .executeTakeFirst()
+      } catch (err) {
+        if (!isMissingTableError(err, 'sales_orders')) throw err
+      }
+      const anchorValue = order?.placedAt ?? order?.createdAt ?? null
+      if (anchorValue !== null) {
+        const anchor = anchorValue instanceof Date ? anchorValue : new Date(anchorValue)
+        if (!Number.isNaN(anchor.getTime())) {
+          const days = Math.floor((now.getTime() - anchor.getTime()) / MILLISECONDS_PER_DAY)
+          if (days > returnWindowDays) {
+            signals.push({
+              id: 'outside_return_window',
+              level: days > 2 * returnWindowDays ? 'high' : 'medium',
+              messageKey: 'warranty_claims.risk.outsideReturnWindow',
+              params: { days, window: returnWindowDays },
+            })
+          }
+        }
+      }
+    }
+  }
+  const currentQuantityByOrderLine = new Map<string, number>()
+  for (const line of lines) {
+    const orderLineId = line.orderLineId ?? null
+    if (!orderLineId || line.deletedAt || line.lineStatus === 'rejected') continue
+    const current = currentQuantityByOrderLine.get(orderLineId) ?? 0
+    currentQuantityByOrderLine.set(orderLineId, roundQuantity(current + parseNumeric(line.qtyClaimed)))
+  }
+  const orderLineIds = Array.from(currentQuantityByOrderLine.keys()).sort((left, right) => left.localeCompare(right))
+  if (orderLineIds.length > 0) {
+    let soldRows: Array<{ id: string; quantity: string | number | null }>
+    try {
+      soldRows = await db
+        .selectFrom('sales_order_lines')
+        .select(['id', 'quantity'])
+        .where('tenant_id', '=', scope.tenantId)
+        .where('organization_id', '=', scope.organizationId)
+        .where('deleted_at', 'is', null)
+        .where('id', 'in', orderLineIds)
+        .execute()
+    } catch (err) {
+      if (!isMissingTableError(err, 'sales_order_lines')) throw err
+      soldRows = []
+    }
+    const soldByOrderLine = new Map<string, number>()
+    for (const row of soldRows) {
+      const quantity = parseNullableNumeric(row.quantity)
+      if (quantity !== null) soldByOrderLine.set(row.id, roundQuantity(quantity))
+    }
+    const scopedOrderLineIds = orderLineIds.filter((id) => soldByOrderLine.has(id))
+    if (scopedOrderLineIds.length > 0) {
+      const otherRows = await db
+        .selectFrom('warranty_claim_lines')
+        .innerJoin('warranty_claims', 'warranty_claims.id', 'warranty_claim_lines.claim_id')
+        .select([
+          'warranty_claim_lines.order_line_id as orderLineId',
+          'warranty_claim_lines.qty_claimed as qtyClaimed',
+          'warranty_claims.claim_number as claimNumber',
+        ])
+        .where('warranty_claim_lines.tenant_id', '=', scope.tenantId)
+        .where('warranty_claim_lines.organization_id', '=', scope.organizationId)
+        .where('warranty_claim_lines.deleted_at', 'is', null)
+        .where('warranty_claim_lines.line_status', '!=', 'rejected')
+        .where('warranty_claim_lines.order_line_id', 'in', scopedOrderLineIds)
+        .where('warranty_claims.tenant_id', '=', scope.tenantId)
+        .where('warranty_claims.organization_id', '=', scope.organizationId)
+        .where('warranty_claims.deleted_at', 'is', null)
+        .where('warranty_claims.id', '!=', claim.id)
+        .where('warranty_claims.status', '!=', 'cancelled')
+        .execute()
+      const otherQuantityByOrderLine = new Map<string, number>()
+      const relatedClaimsByOrderLine = new Map<string, Set<string>>()
+      for (const row of otherRows) {
+        if (!row.orderLineId) continue
+        const current = otherQuantityByOrderLine.get(row.orderLineId) ?? 0
+        otherQuantityByOrderLine.set(row.orderLineId, roundQuantity(current + parseNumeric(row.qtyClaimed)))
+        if (row.claimNumber) {
+          const related = relatedClaimsByOrderLine.get(row.orderLineId) ?? new Set<string>()
+          related.add(row.claimNumber)
+          relatedClaimsByOrderLine.set(row.orderLineId, related)
+        }
+      }
+      for (const orderLineId of scopedOrderLineIds) {
+        const sold = soldByOrderLine.get(orderLineId)
+        if (sold === undefined) continue
+        const count = roundQuantity(
+          (currentQuantityByOrderLine.get(orderLineId) ?? 0)
+          + (otherQuantityByOrderLine.get(orderLineId) ?? 0),
+        )
+        if (count <= sold) continue
+        signals.push({
+          id: 'over_quantity_claim',
+          level: count >= sold * 2 ? 'high' : 'medium',
+          messageKey: 'warranty_claims.risk.overQuantityClaim',
+          params: { count, sold },
+          relatedClaimNumbers: Array.from(relatedClaimsByOrderLine.get(orderLineId) ?? [])
+            .sort((left, right) => left.localeCompare(right)),
+        })
+      }
+    }
+  }
+  const customerId = claim.customerId ?? null
+  if (customerId) {
+    const windowStart = riskWindowStart(now)
+    const repeatRow = await db
+      .selectFrom('warranty_claims')
+      .select(sql<NumericAggregateValue>`count(*)`.as('count'))
+      .where('tenant_id', '=', scope.tenantId)
+      .where('organization_id', '=', scope.organizationId)
+      .where('deleted_at', 'is', null)
+      .where('customer_id', '=', customerId)
+      .where('created_at', '>=', windowStart)
+      .where('status', '!=', 'cancelled')
+      .where('id', '!=', claim.id)
+      .executeTakeFirst()
+    const otherClaimCount = Math.trunc(parseNumeric(repeatRow?.count ?? null))
+    const windowClaimCount = otherClaimCount + 1
+    if (windowClaimCount >= REPEAT_CLAIMER_MEDIUM_COUNT) {
+      signals.push({
+        id: 'repeat_claimer',
+        level: windowClaimCount >= REPEAT_CLAIMER_HIGH_COUNT ? 'high' : 'medium',
+        messageKey: 'warranty_claims.risk.repeatClaimer',
+        params: { count: otherClaimCount },
+      })
+    }
+    const currencyCode = claim.currencyCode?.trim() || null
+    if (currencyCode) {
+      const valueRow = await db
+        .selectFrom('warranty_claims')
+        .select(sql<NumericAggregateValue>`coalesce(sum(total_claimed_amount), 0)`.as('total'))
+        .where('tenant_id', '=', scope.tenantId)
+        .where('organization_id', '=', scope.organizationId)
+        .where('deleted_at', 'is', null)
+        .where('customer_id', '=', customerId)
+        .where('currency_code', '=', currencyCode)
+        .where('created_at', '>=', windowStart)
+        .where('status', '!=', 'cancelled')
+        .executeTakeFirst()
+      const total = parseNumeric(valueRow?.total ?? null)
+      if (total >= VALUE_VELOCITY_MEDIUM_TOTAL) {
+        signals.push({
+          id: 'value_velocity',
+          level: total >= VALUE_VELOCITY_HIGH_TOTAL ? 'high' : 'medium',
+          messageKey: 'warranty_claims.risk.valueVelocity',
+          params: { total: Number(total.toFixed(2)), currencyCode },
+        })
+      }
+    }
+  }
+  return { level: maxRiskLevel(signals), signals }
+}

package/src/modules/warranty_claims/lib/settings.ts ADDED Viewed

@@ -0,0 +1,76 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { DEFAULT_SLA_HOURS } from '../data/constants'
+import { WarrantyClaimSettings } from '../data/entities'
+export type WarrantyClaimEffectiveSettings = {
+  slaHours: number
+  slaPauseOnInfoRequested: boolean
+  slaAtRiskThresholdPct: number
+  autoApproveEnabled: boolean
+  autoApproveMaxAmount: number | null
+  autoApproveCurrencyCode: string | null
+  autoApproveRequireInWarranty: boolean
+  defaultWarrantyMonths: number | null
+  businessHours: Record<string, unknown> | null
+  escalationTiers: unknown[] | null
+  adjudicationUseRules: boolean
+  quarantineGrades: string[] | null
+  returnLabelProvider: string | null
+}
+export const WARRANTY_CLAIM_SETTINGS_DEFAULTS: WarrantyClaimEffectiveSettings = {
+  slaHours: DEFAULT_SLA_HOURS,
+  slaPauseOnInfoRequested: true,
+  slaAtRiskThresholdPct: 75,
+  autoApproveEnabled: false,
+  autoApproveMaxAmount: null,
+  autoApproveCurrencyCode: null,
+  autoApproveRequireInWarranty: true,
+  defaultWarrantyMonths: null,
+  businessHours: null,
+  escalationTiers: null,
+  adjudicationUseRules: false,
+  quarantineGrades: null,
+  returnLabelProvider: null,
+}
+function parseNullableNumber(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
+}
+export async function loadWarrantyClaimSettings(
+  em: EntityManager,
+  scope: { tenantId: string; organizationId: string | null },
+): Promise<WarrantyClaimSettings | null> {
+  if (!scope.organizationId) return null
+  return em.findOne(WarrantyClaimSettings, {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    deletedAt: null,
+  })
+}
+export async function resolveEffectiveWarrantyClaimSettings(
+  em: EntityManager,
+  scope: { tenantId: string; organizationId: string | null },
+): Promise<WarrantyClaimEffectiveSettings> {
+  const settings = await loadWarrantyClaimSettings(em, scope)
+  if (!settings) return WARRANTY_CLAIM_SETTINGS_DEFAULTS
+  return {
+    slaHours: settings.slaHours ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.slaHours,
+    slaPauseOnInfoRequested: settings.slaPauseOnInfoRequested ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.slaPauseOnInfoRequested,
+    slaAtRiskThresholdPct: settings.slaAtRiskThresholdPct ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.slaAtRiskThresholdPct,
+    autoApproveEnabled: settings.autoApproveEnabled ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.autoApproveEnabled,
+    autoApproveMaxAmount: parseNullableNumber(settings.autoApproveMaxAmount),
+    autoApproveCurrencyCode: settings.autoApproveCurrencyCode ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.autoApproveCurrencyCode,
+    autoApproveRequireInWarranty: settings.autoApproveRequireInWarranty ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.autoApproveRequireInWarranty,
+    defaultWarrantyMonths: settings.defaultWarrantyMonths ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.defaultWarrantyMonths,
+    businessHours: settings.businessHours ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.businessHours,
+    escalationTiers: settings.escalationTiers ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.escalationTiers,
+    adjudicationUseRules: settings.adjudicationUseRules ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.adjudicationUseRules,
+    quarantineGrades: settings.quarantineGrades ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.quarantineGrades,
+    returnLabelProvider: settings.returnLabelProvider ?? WARRANTY_CLAIM_SETTINGS_DEFAULTS.returnLabelProvider,
+  }
+}