@open-mercato/core 0.6.8-develop.6998.1.d2bc46c56c → 0.6.8-develop.7000.1.0ae682bad1

package/src/modules/warranty_claims/lib/emailIntake.ts

@@ -0,0 +1,123 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { AwilixContainer } from 'awilix'
+import type { CommandBus, CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { WarrantyClaim } from '../data/entities'
+import type { ClaimCreateInput } from '../data/validators'
+import { isUniqueViolation } from './externalIntake'
+
+type EmailIntakeScope = {
+  tenantId: string
+  organizationId: string
+}
+
+export type CreateOrGetClaimFromInboundMessageArgs = {
+  em: EntityManager
+  container: AwilixContainer
+  scope: EmailIntakeScope
+  contactEmail: string
+  customerName?: string | null
+  subject?: string | null
+  body?: string | null
+  intakeMessageRef: string
+}
+
+export type EmailIntakeResult = {
+  claimId: string
+  created: boolean
+}
+
+function normalizeRequired(value: string, fieldName: string): string {
+  const normalized = value.trim()
+  if (!normalized) throw new Error(`[internal] ${fieldName} is required for warranty claim email intake`)
+  return normalized
+}
+
+function trimOptional(value: string | null | undefined): string | null {
+  if (typeof value !== 'string') return null
+  const normalized = value.trim()
+  return normalized.length > 0 ? normalized : null
+}
+
+function buildNotes(subject: string | null, body: string | null): string | null {
+  const parts: string[] = []
+  if (subject) parts.push(`Subject: ${subject}`)
+  if (body) parts.push(body)
+  const notes = parts.join('\n\n').trim()
+  return notes.length > 0 ? notes.slice(0, 8000) : null
+}
+
+async function loadClaimByIntakeMessageRef(
+  em: EntityManager,
+  scope: EmailIntakeScope,
+  intakeMessageRef: string,
+): Promise<WarrantyClaim | null> {
+  return findOneWithDecryption(
+    em,
+    WarrantyClaim,
+    {
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      intakeMessageRef,
+      deletedAt: null,
+    },
+    {},
+    scope,
+  )
+}
+
+function buildCommandCtx(container: AwilixContainer, scope: EmailIntakeScope): CommandRuntimeContext {
+  return {
+    container,
+    auth: null,
+    organizationScope: null,
+    selectedOrganizationId: scope.organizationId,
+    organizationIds: [scope.organizationId],
+    syncOrigin: 'warranty_claims.email_intake',
+    systemActor: true,
+  }
+}
+
+export async function createOrGetClaimFromInboundMessage(
+  args: CreateOrGetClaimFromInboundMessageArgs,
+): Promise<EmailIntakeResult> {
+  const contactEmail = normalizeRequired(args.contactEmail, 'contactEmail')
+  const intakeMessageRef = normalizeRequired(args.intakeMessageRef, 'intakeMessageRef')
+
+  const existing = await loadClaimByIntakeMessageRef(args.em, args.scope, intakeMessageRef)
+  if (existing) return { claimId: existing.id, created: false }
+
+  const commandBus = args.container.resolve<CommandBus>('commandBus')
+  const commandCtx = buildCommandCtx(args.container, args.scope)
+  const subject = trimOptional(args.subject)
+  const body = trimOptional(args.body)
+  const createInput: ClaimCreateInput = {
+    tenantId: args.scope.tenantId,
+    organizationId: args.scope.organizationId,
+    claimType: 'warranty',
+    channel: 'api',
+    priority: 'normal',
+    customerId: null,
+    customerName: trimOptional(args.customerName) ?? contactEmail,
+    contactEmail,
+    intakeMessageRef,
+    notes: buildNotes(subject, body),
+  }
+
+  try {
+    const { result } = await commandBus.execute<ClaimCreateInput, { claimId: string }>(
+      'warranty_claims.claim.create',
+      { input: createInput, ctx: commandCtx },
+    )
+    if (!result?.claimId) {
+      throw new Error('[internal] warranty claim email intake create failed')
+    }
+    return { claimId: result.claimId, created: true }
+  } catch (err) {
+    if (isUniqueViolation(err)) {
+      const winner = await loadClaimByIntakeMessageRef(args.em, args.scope, intakeMessageRef)
+      if (winner) return { claimId: winner.id, created: false }
+    }
+    throw err
+  }
+}

package/src/modules/warranty_claims/lib/escalation.ts

@@ -0,0 +1,83 @@
+import type { WarrantyClaimStatus } from '../data/validators'
+
+export type EscalationTier = {
+  atPct: number
+  action: 'notify' | 'reassign'
+  toUserId?: string
+}
+
+export type SlaEscalationCandidateInput = {
+  status: WarrantyClaimStatus
+  slaPausedAt?: Date | string | null
+  slaDueAt?: Date | string | null
+  submittedAt?: Date | string | null
+}
+
+const SLA_TERMINAL_STATUSES = new Set<WarrantyClaimStatus>([
+  'resolved',
+  'closed',
+  'cancelled',
+  'rejected',
+])
+
+function toRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null
+}
+
+function parseAction(value: unknown): EscalationTier['action'] | null {
+  return value === 'notify' || value === 'reassign' ? value : null
+}
+
+function parseAtPct(value: unknown): number | null {
+  const parsed = typeof value === 'number' ? value : typeof value === 'string' ? Number(value) : Number.NaN
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null
+}
+
+function parseUserId(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const trimmed = value.trim()
+  return trimmed.length > 0 ? trimmed : undefined
+}
+
+export function parseEscalationTiers(raw: unknown): EscalationTier[] {
+  if (!Array.isArray(raw)) return []
+  const tiers: EscalationTier[] = []
+
+  for (const item of raw) {
+    const record = toRecord(item)
+    if (!record) continue
+    const atPct = parseAtPct(record.atPct)
+    const action = parseAction(record.action)
+    if (atPct === null || action === null) continue
+
+    const toUserId = parseUserId(record.toUserId)
+    if (action === 'reassign' && !toUserId) continue
+    tiers.push(toUserId ? { atPct, action, toUserId } : { atPct, action })
+  }
+
+  return tiers.sort((left, right) => left.atPct - right.atPct)
+}
+
+export function tiersToFire(
+  progressPct: number,
+  currentLevel: number,
+  tiers: EscalationTier[],
+): { tierIndex: number; tier: EscalationTier }[] {
+  if (!Number.isFinite(progressPct)) return []
+  const normalizedLevel = Number.isFinite(currentLevel) ? Math.max(0, Math.floor(currentLevel)) : 0
+  return tiers
+    .map((tier, index) => ({ tierIndex: index + 1, tier }))
+    .filter((entry) => entry.tier.atPct <= progressPct && entry.tierIndex > normalizedLevel)
+}
+
+export function isSlaEscalationTerminalStatus(status: WarrantyClaimStatus): boolean {
+  return SLA_TERMINAL_STATUSES.has(status)
+}
+
+export function isSlaEscalationCandidate(claim: SlaEscalationCandidateInput): boolean {
+  if (isSlaEscalationTerminalStatus(claim.status)) return false
+  if (claim.slaPausedAt !== null && claim.slaPausedAt !== undefined) return false
+  if (claim.slaDueAt === null || claim.slaDueAt === undefined) return false
+  if (claim.submittedAt === null || claim.submittedAt === undefined) return false
+  return true
+}

package/src/modules/warranty_claims/lib/externalIntake.ts

@@ -0,0 +1,362 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import type { TenantDataEncryptionService } from '@open-mercato/shared/lib/encryption/tenantDataEncryptionService'
+import { isPotentialEncryptedPayload } from './decryptionSafety'
+import type { ClaimCreateInput, ExternalClaimIntakeInput } from '../data/validators'
+
+type Translate = (key: string, fallback?: string) => string
+
+export type ExternalLookupTable = 'sales_orders' | 'customer_entities' | 'catalog_products'
+
+export type ExternalLookupRows = (
+  table: ExternalLookupTable,
+  where: Record<string, string>,
+  select: string[],
+  limit: number,
+) => Promise<Array<Record<string, unknown>> | null>
+
+type ExternalIntakeDeps = {
+  lookupRows: ExternalLookupRows
+  translate: Translate
+}
+
+type ExternalLookupDb = {
+  sales_orders: {
+    id: string
+    order_number: string
+    customer_entity_id: string | null
+    currency_code: string
+    placed_at: Date | null
+    tenant_id: string | null
+    organization_id: string | null
+    deleted_at: Date | null
+  }
+  customer_entities: {
+    id: string
+    display_name: string | null
+    tenant_id: string | null
+    organization_id: string | null
+    deleted_at: Date | null
+  }
+  catalog_products: {
+    id: string
+    title: string | null
+    sku: string | null
+    tenant_id: string | null
+    organization_id: string | null
+    deleted_at: Date | null
+  }
+}
+
+function isMissingTableError(err: unknown): 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('does not exist'))
+}
+
+export function createExternalIntakeDeps(
+  em: EntityManager,
+  translate: Translate,
+  scope: { tenantId: string; organizationId: string },
+  encryption?: TenantDataEncryptionService | null,
+): ExternalIntakeDeps {
+  const scrubEncryptedCustomerName = (row: Record<string, unknown>): Record<string, unknown> => {
+    if (!isPotentialEncryptedPayload(row.display_name) && !isPotentialEncryptedPayload(row.displayName)) return row
+    return { ...row, display_name: null, displayName: null }
+  }
+  const decryptCustomerRow = async (row: Record<string, unknown>): Promise<Record<string, unknown>> => {
+    if (!encryption) return scrubEncryptedCustomerName(row)
+    try {
+      const decrypted = await encryption.decryptEntityPayload('customers:customer_entity', row, scope.tenantId, scope.organizationId)
+      return scrubEncryptedCustomerName(decrypted)
+    } catch {
+      return { ...row, display_name: null, displayName: null }
+    }
+  }
+  const lookupRows: ExternalLookupRows = async (table, where, select, limit) => {
+    const db = em.getKysely<ExternalLookupDb>()
+    try {
+      let query = db
+        .selectFrom(table)
+        .select(select as never[])
+        .where('tenant_id' as never, '=', scope.tenantId as never)
+        .where('organization_id' as never, '=', scope.organizationId as never)
+        .where('deleted_at' as never, 'is', null)
+      for (const [column, value] of Object.entries(where)) {
+        query = query.where(column as never, '=', value as never)
+      }
+      const rows = (await query.limit(limit).execute()) as Array<Record<string, unknown>>
+      if (table === 'customer_entities') {
+        return Promise.all(rows.map((row) => decryptCustomerRow(row)))
+      }
+      return rows
+    } catch (err) {
+      if (isMissingTableError(err)) return null
+      throw err
+    }
+  }
+  return { lookupRows, translate }
+}
+
+type ExternalScope = {
+  tenantId: string
+  organizationId: string
+}
+
+export type ExternalResolutionResult = {
+  orderId: string | null
+  customerId: string | null
+  customerName: string | null
+  currencyCode: string | null
+  orderPlacedAt: Date | null
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {}
+}
+
+function readString(row: Record<string, unknown>, ...keys: string[]): string | null {
+  for (const key of keys) {
+    const value = row[key]
+    if (typeof value === 'string' && value.trim().length > 0) return value.trim()
+  }
+  return null
+}
+
+function readDate(row: Record<string, unknown>, ...keys: string[]): Date | null {
+  for (const key of keys) {
+    const value = row[key]
+    if (value instanceof Date && !Number.isNaN(value.getTime())) return value
+    if (typeof value === 'string' || typeof value === 'number') {
+      const parsed = new Date(value)
+      if (!Number.isNaN(parsed.getTime())) return parsed
+    }
+  }
+  return null
+}
+
+function dateOnly(value: Date): Date {
+  return new Date(Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate()))
+}
+
+function customerDisplayName(row: Record<string, unknown> | null): string | null {
+  if (!row) return null
+  return readString(row, 'display_name', 'displayName', 'name')
+}
+
+function productDisplayName(row: Record<string, unknown> | null): string | null {
+  if (!row) return null
+  return readString(row, 'title', 'name', 'display_name', 'displayName')
+}
+
+async function lookupCustomer(
+  deps: ExternalIntakeDeps,
+  customerId: string,
+): Promise<Record<string, unknown> | null | undefined> {
+  const rows = await deps.lookupRows('customer_entities', { id: customerId }, ['id', 'display_name'], 1)
+  if (rows === null) return undefined
+  return rows[0] ?? null
+}
+
+function orderNotFound(deps: ExternalIntakeDeps): CrudHttpError {
+  return new CrudHttpError(400, {
+    error: deps.translate('warranty_claims.errors.orderNotFound', 'Order not found'),
+  })
+}
+
+function customerOrderMismatch(deps: ExternalIntakeDeps): CrudHttpError {
+  return new CrudHttpError(400, {
+    error: deps.translate('warranty_claims.errors.customerOrderMismatch', 'Customer does not match the order'),
+  })
+}
+
+function invalidCustomerReference(deps: ExternalIntakeDeps): CrudHttpError {
+  return new CrudHttpError(400, {
+    error: deps.translate('warranty_claims.errors.invalidReference', 'The referenced customer could not be found.'),
+  })
+}
+
+export async function resolveExternalReferences(
+  deps: ExternalIntakeDeps,
+  input: ExternalClaimIntakeInput,
+): Promise<ExternalResolutionResult> {
+  let orderId: string | null = null
+  let orderCustomerId: string | null = null
+  let currencyCode: string | null = null
+  let orderPlacedAt: Date | null = null
+
+  if (input.orderId || input.orderNumber) {
+    const where: Record<string, string> = input.orderId
+      ? { id: input.orderId }
+      : { order_number: input.orderNumber as string }
+    const rows = await deps.lookupRows(
+      'sales_orders',
+      where,
+      ['id', 'customer_entity_id', 'currency_code', 'placed_at', 'order_number'],
+      1,
+    )
+    const order = rows?.[0] ?? null
+    if (!order) throw orderNotFound(deps)
+    orderId = readString(order, 'id')
+    if (!orderId) throw orderNotFound(deps)
+    orderCustomerId = readString(order, 'customer_entity_id', 'customerEntityId')
+    currencyCode = readString(order, 'currency_code', 'currencyCode')
+    orderPlacedAt = readDate(order, 'placed_at', 'placedAt')
+  }
+
+  let customerId = orderCustomerId
+  let customerName: string | null = null
+
+  if (orderCustomerId && input.customerId && input.customerId !== orderCustomerId) {
+    throw customerOrderMismatch(deps)
+  }
+
+  if (!orderCustomerId && input.customerId) {
+    const customer = await lookupCustomer(deps, input.customerId)
+    if (!customer) throw invalidCustomerReference(deps)
+    customerId = input.customerId
+    customerName = customerDisplayName(customer)
+  } else if (orderCustomerId) {
+    const customer = await lookupCustomer(deps, orderCustomerId)
+    customerName = customerDisplayName(customer ?? null)
+  }
+
+  if (!customerId) {
+    customerName = input.contactName ?? null
+  }
+
+  return {
+    orderId,
+    customerId,
+    customerName,
+    currencyCode,
+    orderPlacedAt,
+  }
+}
+
+export async function resolveSkuProduct(
+  deps: ExternalIntakeDeps,
+  sku: string,
+): Promise<{ productId: string; productName: string | null } | null> {
+  const normalizedSku = sku.trim()
+  if (!normalizedSku) return null
+  const rows = await deps.lookupRows('catalog_products', { sku: normalizedSku }, ['id', 'title', 'sku'], 2)
+  if (!rows || rows.length !== 1) return null
+  const productId = readString(rows[0], 'id')
+  if (!productId) return null
+  return { productId, productName: productDisplayName(rows[0]) }
+}
+
+export function buildExternalClaimCreateInput(
+  input: ExternalClaimIntakeInput,
+  resolution: ExternalResolutionResult,
+  settings: { defaultWarrantyMonths: number | null },
+  scope: ExternalScope,
+): ClaimCreateInput {
+  const orderPurchaseDate = resolution.orderPlacedAt ? dateOnly(resolution.orderPlacedAt) : null
+  return {
+    organizationId: scope.organizationId,
+    tenantId: scope.tenantId,
+    claimType: 'warranty',
+    channel: 'api',
+    priority: 'normal',
+    externalRef: input.externalRef,
+    contactEmail: input.contactEmail ?? null,
+    customerId: resolution.customerId,
+    customerName: resolution.customerName,
+    orderId: resolution.orderId,
+    reasonCode: input.reasonCode ?? null,
+    notes: input.notes ?? null,
+    currencyCode: resolution.currencyCode,
+    lines: input.lines.map((line, index) => ({
+      lineNo: index + 1,
+      productId: line.productId ?? null,
+      variantId: null,
+      sku: line.sku ?? null,
+      productName: line.productName ?? null,
+      orderLineId: null,
+      serialNumber: line.serialNumber ?? null,
+      purchaseDate: line.purchaseDate ?? orderPurchaseDate,
+      warrantyMonths: line.warrantyMonths ?? settings.defaultWarrantyMonths,
+      faultCode: line.faultCode ?? null,
+      faultDescription: line.faultDescription,
+      qtyClaimed: line.qtyClaimed ?? 1,
+    })),
+  }
+}
+
+
+export type ExternalIntakeCommandBus = {
+  execute: (commandId: string, args: { input: unknown; ctx: unknown }) => Promise<{ result?: unknown }>
+}
+
+export type ExternalIntakeExecution =
+  | { outcome: 'created'; claimId: string }
+  | { outcome: 'existing' }
+
+type ExistingExternalClaim = {
+  id: string
+  status: string
+}
+
+export async function createAndSubmitExternalClaim(input: {
+  commandBus: ExternalIntakeCommandBus
+  commandCtx: unknown
+  createInput: ClaimCreateInput
+  scope: ExternalScope
+  externalRef: string
+  loadExistingByExternalRef: (externalRef: string) => Promise<ExistingExternalClaim | null>
+  saveFailedError: () => Error
+}): Promise<ExternalIntakeExecution> {
+  let claimId: string
+  try {
+    const createResult = await input.commandBus.execute('warranty_claims.claim.create', {
+      input: input.createInput,
+      ctx: input.commandCtx,
+    })
+    const createdClaimId = (createResult.result as { claimId?: unknown } | undefined)?.claimId
+    if (typeof createdClaimId !== 'string') throw input.saveFailedError()
+    claimId = createdClaimId
+  } catch (err) {
+    if (!isUniqueViolation(err)) throw err
+    const existing = await input.loadExistingByExternalRef(input.externalRef)
+    if (!existing) throw err
+    if (existing.status === 'draft') {
+      const scopedInput = { id: existing.id, organizationId: input.scope.organizationId, tenantId: input.scope.tenantId }
+      try {
+        await input.commandBus.execute('warranty_claims.claim.submit', { input: scopedInput, ctx: input.commandCtx })
+      } catch (submitError) {
+        const refreshed = await input.loadExistingByExternalRef(input.externalRef)
+        if (!refreshed || refreshed.status === 'draft') throw submitError
+      }
+    }
+    return { outcome: 'existing' }
+  }
+  const scopedInput = { id: claimId, organizationId: input.scope.organizationId, tenantId: input.scope.tenantId }
+  try {
+    await input.commandBus.execute('warranty_claims.claim.submit', { input: scopedInput, ctx: input.commandCtx })
+  } catch (submitError) {
+    await input.commandBus
+      .execute('warranty_claims.claim.delete', { input: scopedInput, ctx: input.commandCtx })
+      .catch(() => undefined)
+    throw submitError
+  }
+  return { outcome: 'created', claimId }
+}
+
+export function isUniqueViolation(err: unknown): boolean {
+  const visited = new Set<unknown>()
+  const inspect = (value: unknown, depth: number): boolean => {
+    if (depth > 4 || !value || typeof value !== 'object' || visited.has(value)) return false
+    visited.add(value)
+    const record = asRecord(value)
+    if (record.code === '23505' || record.sqlState === '23505') return true
+    return inspect(record.driverError, depth + 1)
+      || inspect(record.cause, depth + 1)
+      || inspect(record.originalError, depth + 1)
+      || inspect(record.original, depth + 1)
+      || inspect(record.parent, depth + 1)
+  }
+  return inspect(err, 0)
+}

package/src/modules/warranty_claims/lib/grading.ts

@@ -0,0 +1,23 @@
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+
+export type ConditionGrade = 'A' | 'B' | 'C' | 'D'
+
+export function isRestockableGrade(grade: ConditionGrade | null | undefined): boolean {
+  return grade === 'A' || grade === 'B'
+}
+
+export function assertDispositionAllowedForGrade(
+  grade: ConditionGrade | null | undefined,
+  disposition: string | null | undefined,
+): void {
+  if (disposition === 'restock' && (grade === 'C' || grade === 'D')) {
+    throw new CrudHttpError(400, { error: 'warranty_claims.errors.dispositionGradeConflict' })
+  }
+}
+
+export function suggestedDispositionForGrade(grade: ConditionGrade | null | undefined): string | null {
+  if (grade === 'A') return 'restock'
+  if (grade === 'B') return 'repair'
+  if (grade === 'C' || grade === 'D') return 'scrap'
+  return null
+}

package/src/modules/warranty_claims/lib/listSegments.ts

@@ -0,0 +1,19 @@
+import type { WarrantyClaimStatus } from '../data/validators'
+
+export type VendorPolicySegment = 'all' | 'active' | 'automatic' | 'manual' | 'inactive'
+export type PortalClaimStateGroup = 'open' | 'resolved'
+
+export function vendorPolicySegmentQuery(segment: VendorPolicySegment): Record<string, string> {
+  if (segment === 'active') return { isActive: 'true' }
+  if (segment === 'inactive') return { isActive: 'false' }
+  if (segment === 'automatic') return { autoGenerateRecovery: 'true' }
+  if (segment === 'manual') return { autoGenerateRecovery: 'false' }
+  return {}
+}
+
+export function portalClaimStatusesForStateGroup(group: PortalClaimStateGroup): WarrantyClaimStatus[] {
+  if (group === 'open') {
+    return ['draft', 'submitted', 'in_review', 'info_requested', 'approved', 'awaiting_return', 'received', 'inspecting']
+  }
+  return ['resolved', 'closed', 'rejected', 'cancelled']
+}

package/src/modules/warranty_claims/lib/orderOwnership.ts

@@ -0,0 +1,58 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+
+type SalesOrderOwnershipDb = {
+  sales_orders: {
+    id: string
+    customer_entity_id: string | null
+    tenant_id: string | null
+    organization_id: string | null
+    deleted_at: Date | null
+  }
+}
+
+export type OrderOwnershipScope = { tenantId: string; organizationId: string }
+
+function isMissingSalesOrdersTableError(err: unknown): 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('does not exist'))
+}
+
+/**
+ * Cross-customer integrity guard shared by staff claim writes and registrations.
+ *
+ * When a record references both a customer and a sales order, the order MUST belong to
+ * that customer. Skips silently when either side is absent, when the sales module/table
+ * is not present, or when the referenced order carries no customer — those cases cannot
+ * prove a mismatch. Throws only on a definite mismatch (both non-null and different),
+ * which is the leak reproduced in UI QA (WQA-001 / REG-03).
+ */
+export async function assertOrderBelongsToCustomer(
+  em: EntityManager,
+  scope: OrderOwnershipScope,
+  orderId: string | null | undefined,
+  customerId: string | null | undefined,
+): Promise<void> {
+  if (!orderId || !customerId) return
+  const db = em.fork().getKysely<SalesOrderOwnershipDb>()
+  let row: { customer_entity_id: string | null } | undefined
+  try {
+    row = await db
+      .selectFrom('sales_orders')
+      .select('customer_entity_id')
+      .where('id', '=', orderId)
+      .where('tenant_id', '=', scope.tenantId)
+      .where('organization_id', '=', scope.organizationId)
+      .where('deleted_at', 'is', null)
+      .executeTakeFirst()
+  } catch (err) {
+    if (isMissingSalesOrdersTableError(err)) return
+    throw err
+  }
+  if (!row) return
+  if (row.customer_entity_id && row.customer_entity_id !== customerId) {
+    throw new CrudHttpError(400, { error: 'warranty_claims.errors.customerOrderMismatch' })
+  }
+}

package/src/modules/warranty_claims/lib/portalAttachmentUpload.ts

@@ -0,0 +1,11 @@
+import type { ScopedAttachmentUploadService } from '@open-mercato/core/modules/attachments/lib/scoped-upload-service'
+
+export function resolvePortalAttachmentUploadService(
+  container: { resolve: <T = unknown>(name: string) => T },
+): ScopedAttachmentUploadService | null {
+  try {
+    return container.resolve<ScopedAttachmentUploadService>('attachmentScopedUploadService') ?? null
+  } catch {
+    return null
+  }
+}