@stacksjs/defaults 0.70.228 → 0.70.230

package/app/Actions/Dashboard/Commerce/payment-records.ts

@@ -0,0 +1,227 @@
+import {
+  commerceCurrency,
+  commerceEnum,
+  commerceIdentifier,
+  commerceNumber,
+  commerceOptionalEmail,
+  commerceOptionalIdentifier,
+  commerceOptionalString,
+  commerceTimestamp,
+  commerceValue,
+} from './commerce-record'
+
+export type PaymentMethod = 'cash' | 'creditCard' | 'debitCard' | 'paypal' | 'applePay' | 'googlePay' | 'bankTransfer' | 'giftCard'
+export type PaymentStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'refunded' | 'partiallyRefunded' | 'succeeded'
+
+export interface PaymentRecord {
+  id: string
+  amount: number
+  refundAmount: number
+  refundRecorded: boolean
+  method: PaymentMethod
+  status: PaymentStatus
+  currency: string
+  referenceNumber: string
+  cardLastFour: string
+  cardBrand: string
+  billingEmail: string
+  transactionId: string
+  paymentProvider: string
+  notes: string
+  orderId: string
+  customerId: string
+  createdAt: string
+}
+
+export interface PaymentSummary {
+  total: number
+  successful: number
+  currencies: string[]
+  capturedByCurrency: Record<string, number>
+  refundedByCurrency: Record<string, number>
+  successRate: number
+}
+
+export interface PaymentRelationshipContext {
+  orderIds?: Set<string>
+  customerIds?: Set<string>
+}
+
+function rawValue(record: any, ...keys: string[]): unknown {
+  for (const key of keys) {
+    const result = typeof record?.get === 'function' ? record.get(key) : record?.[key]
+    if (result !== undefined)
+      return result
+  }
+  return undefined
+}
+
+export function normalizeCardLastFour(input: unknown): string {
+  const raw = commerceOptionalString(input, 'Payment', 'card_last_four')
+  if (!raw)
+    return ''
+  if (!/^[\d -]+$/.test(raw))
+    throw new TypeError('Payment.card_last_four must contain only card digits and separators.')
+  const digits = raw.replace(/\D/g, '')
+  if (digits.length < 4 || digits.length > 19)
+    throw new TypeError('Payment.card_last_four must contain between 4 and 19 card digits.')
+  return digits.slice(-4)
+}
+
+export function normalizePaymentRecord(
+  record: any,
+  relationships: PaymentRelationshipContext = {},
+): PaymentRecord {
+  const id = commerceIdentifier(commerceValue(record, 'id', 'uuid'), 'Payment')
+  const source = `Payment ${id}`
+  const amount = commerceNumber(commerceValue(record, 'amount'), source, 'amount', {
+    min: 1,
+    integer: true,
+  })
+  const rawRefund = rawValue(record, 'refund_amount', 'refundAmount')
+  const refundRecorded = rawRefund !== null && rawRefund !== undefined && rawRefund !== ''
+  const refundAmount = refundRecorded
+    ? commerceNumber(rawRefund, source, 'refund_amount', { min: 0, integer: true })
+    : 0
+  if (refundAmount > amount)
+    throw new TypeError(`${source}.refund_amount must not exceed amount.`)
+  const orderId = commerceOptionalIdentifier(
+    commerceValue(record, 'order_id', 'orderId'),
+    source,
+    'order_id',
+  )
+  if (orderId && relationships.orderIds && !relationships.orderIds.has(orderId))
+    throw new TypeError(`${source}.order_id references missing Order ${orderId}.`)
+  const customerId = commerceOptionalIdentifier(
+    commerceValue(record, 'customer_id', 'customerId'),
+    source,
+    'customer_id',
+  )
+  if (customerId && relationships.customerIds && !relationships.customerIds.has(customerId))
+    throw new TypeError(`${source}.customer_id references missing Customer ${customerId}.`)
+
+  return {
+    id,
+    amount,
+    refundAmount,
+    refundRecorded,
+    method: commerceEnum(commerceValue(record, 'method'), source, 'method', [
+      'cash',
+      'creditCard',
+      'debitCard',
+      'paypal',
+      'applePay',
+      'googlePay',
+      'bankTransfer',
+      'giftCard',
+    ]),
+    status: commerceEnum(commerceValue(record, 'status'), source, 'status', [
+      'pending',
+      'processing',
+      'completed',
+      'failed',
+      'refunded',
+      'partiallyRefunded',
+      'succeeded',
+    ]),
+    currency: commerceCurrency(commerceValue(record, 'currency'), source),
+    referenceNumber: commerceOptionalString(
+      commerceValue(record, 'reference_number', 'referenceNumber'),
+      source,
+      'reference_number',
+    ),
+    cardLastFour: normalizeCardLastFour(commerceValue(record, 'card_last_four', 'cardLastFour')),
+    cardBrand: commerceOptionalString(
+      commerceValue(record, 'card_brand', 'cardBrand'),
+      source,
+      'card_brand',
+    ),
+    billingEmail: commerceOptionalEmail(
+      commerceValue(record, 'billing_email', 'billingEmail'),
+      source,
+      'billing_email',
+    ),
+    transactionId: commerceOptionalString(
+      commerceValue(record, 'transaction_id', 'transactionId'),
+      source,
+      'transaction_id',
+    ),
+    paymentProvider: commerceOptionalString(
+      commerceValue(record, 'payment_provider', 'paymentProvider'),
+      source,
+      'payment_provider',
+    ),
+    notes: commerceOptionalString(commerceValue(record, 'notes'), source, 'notes'),
+    orderId,
+    customerId,
+    createdAt: commerceTimestamp(commerceValue(record, 'created_at', 'createdAt'), source),
+  }
+}
+
+export function isSuccessfulPayment(record: PaymentRecord): boolean {
+  return ['completed', 'succeeded', 'partiallyRefunded', 'refunded'].includes(record.status)
+}
+
+export function isRefundablePayment(record: PaymentRecord): boolean {
+  return ['completed', 'succeeded', 'partiallyRefunded'].includes(record.status)
+}
+
+export function summarizePayments(records: PaymentRecord[]): PaymentSummary {
+  const successful = records.filter(isSuccessfulPayment)
+  const settled = records.filter(record => isSuccessfulPayment(record) || record.status === 'failed')
+  const capturedByCurrency: Record<string, number> = {}
+  const refundedByCurrency: Record<string, number> = {}
+  for (const record of successful)
+    capturedByCurrency[record.currency] = (capturedByCurrency[record.currency] || 0) + record.amount
+  for (const record of records) {
+    if (record.refundAmount > 0)
+      refundedByCurrency[record.currency] = (refundedByCurrency[record.currency] || 0) + record.refundAmount
+  }
+  return {
+    total: records.length,
+    successful: successful.length,
+    currencies: [...new Set(records.map(record => record.currency).filter(Boolean))].sort(),
+    capturedByCurrency,
+    refundedByCurrency,
+    successRate: settled.length
+      ? Math.round((successful.length / settled.length) * 1000) / 10
+      : 0,
+  }
+}
+
+function csvCell(value: unknown): string {
+  const textValue = String(value ?? '')
+  return /[",\n]/.test(textValue) ? `"${textValue.replaceAll('"', '""')}"` : textValue
+}
+
+export function paymentsToCsv(records: PaymentRecord[]): string {
+  const header = [
+    'ID',
+    'Created',
+    'Status',
+    'Method',
+    'Amount',
+    'Refund amount',
+    'Currency',
+    'Reference',
+    'Provider',
+    'Transaction ID',
+    'Billing email',
+    'Order ID',
+  ]
+  const rows = records.map(record => [
+    record.id,
+    record.createdAt,
+    record.status,
+    record.method,
+    record.amount,
+    record.refundAmount,
+    record.currency,
+    record.referenceNumber,
+    record.paymentProvider,
+    record.transactionId,
+    record.billingEmail,
+    record.orderId,
+  ])
+  return [header, ...rows].map(row => row.map(csvCell).join(',')).join('\n')
+}

package/app/Actions/Dashboard/Commerce/print-device-records.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  normalizePrintDeviceRecord,
+  summarizePrintDevices,
+} from './print-device-records'
+
+describe('dashboard print device records', () => {
+  test('normalizes persisted model columns and Unix timestamps', () => {
+    expect(normalizePrintDeviceRecord({
+      id: 7,
+      name: 'Kitchen printer',
+      mac_address: '00:11:22:33:44:55',
+      location: 'Kitchen',
+      terminal: 'KDS-1',
+      status: 'warning',
+      last_ping: 1785360000,
+      print_count: '81',
+      created_at: '2026-07-29 10:00:00',
+    })).toEqual({
+      id: '7',
+      name: 'Kitchen printer',
+      macAddress: '00:11:22:33:44:55',
+      location: 'Kitchen',
+      terminal: 'KDS-1',
+      status: 'warning',
+      lastPing: 1785360000000,
+      printCount: 81,
+      createdAt: '2026-07-29T10:00:00.000Z',
+    })
+  })
+
+  test('rejects invalid operational values', () => {
+    const base = {
+      id: 8,
+      name: 'Kitchen printer',
+      macAddress: '00:11:22:33:44:55',
+      location: 'Kitchen',
+      terminal: 'KDS-1',
+      status: 'online',
+      lastPing: 0,
+      printCount: 0,
+      createdAt: '2026-07-29 10:00:00',
+    }
+    expect(() => normalizePrintDeviceRecord({ ...base, status: 'unknown' }))
+      .toThrow('PrintDevice 8.status must be online or offline or warning')
+    expect(() => normalizePrintDeviceRecord({ ...base, lastPing: 'not-a-date' }))
+      .toThrow('PrintDevice 8.last_ping must be a valid timestamp')
+    expect(() => normalizePrintDeviceRecord({ ...base, printCount: -2 }))
+      .toThrow('PrintDevice 8.print_count must be at least 0')
+  })
+
+  test('summarizes only persisted print device fields', () => {
+    expect(summarizePrintDevices([
+      { id: '1', name: 'One', macAddress: '', location: 'North', terminal: '', status: 'online', lastPing: 0, printCount: 10, createdAt: '' },
+      { id: '2', name: 'Two', macAddress: '', location: 'North', terminal: '', status: 'warning', lastPing: 0, printCount: 20, createdAt: '' },
+      { id: '3', name: 'Three', macAddress: '', location: 'South', terminal: '', status: 'offline', lastPing: 0, printCount: 30, createdAt: '' },
+    ])).toEqual({
+      total: 3,
+      online: 1,
+      offline: 1,
+      warning: 1,
+      locations: 2,
+      totalPrints: 60,
+    })
+  })
+})

package/app/Actions/Dashboard/Commerce/print-device-records.ts

@@ -0,0 +1,76 @@
+import {
+  commerceEnum,
+  commerceIdentifier,
+  commerceNumber,
+  commerceRequiredString,
+  commerceTimestamp,
+  commerceValue,
+} from './commerce-record'
+
+export type PrintDeviceStatus = 'online' | 'offline' | 'warning'
+
+export interface PrintDeviceRecord {
+  id: string
+  name: string
+  macAddress: string
+  location: string
+  terminal: string
+  status: PrintDeviceStatus
+  lastPing: number
+  printCount: number
+  createdAt: string
+}
+export interface PrintDeviceSummary {
+  total: number
+  online: number
+  offline: number
+  warning: number
+  locations: number
+  totalPrints: number
+}
+
+function printDeviceTimestamp(input: unknown, source: string): number {
+  if (input === 0 || input === '0')
+    return 0
+  return new Date(commerceTimestamp(input, source, 'last_ping')).getTime()
+}
+
+export function normalizePrintDeviceRecord(record: any): PrintDeviceRecord {
+  const id = commerceIdentifier(commerceValue(record, 'id', 'uuid'), 'PrintDevice')
+  const source = `PrintDevice ${id}`
+  return {
+    id,
+    name: commerceRequiredString(commerceValue(record, 'name'), source, 'name'),
+    macAddress: commerceRequiredString(
+      commerceValue(record, 'mac_address', 'macAddress'),
+      source,
+      'mac_address',
+    ),
+    location: commerceRequiredString(commerceValue(record, 'location'), source, 'location'),
+    terminal: commerceRequiredString(commerceValue(record, 'terminal'), source, 'terminal'),
+    status: commerceEnum(commerceValue(record, 'status'), source, 'status', [
+      'online',
+      'offline',
+      'warning',
+    ]),
+    lastPing: printDeviceTimestamp(commerceValue(record, 'last_ping', 'lastPing'), source),
+    printCount: commerceNumber(
+      commerceValue(record, 'print_count', 'printCount'),
+      source,
+      'print_count',
+      { min: 0, integer: true },
+    ),
+    createdAt: commerceTimestamp(commerceValue(record, 'created_at', 'createdAt'), source),
+  }
+}
+
+export function summarizePrintDevices(records: PrintDeviceRecord[]): PrintDeviceSummary {
+  return {
+    total: records.length,
+    online: records.filter(record => record.status === 'online').length,
+    offline: records.filter(record => record.status === 'offline').length,
+    warning: records.filter(record => record.status === 'warning').length,
+    locations: new Set(records.map(record => record.location).filter(Boolean)).size,
+    totalPrints: records.reduce((sum, record) => sum + record.printCount, 0),
+  }
+}

package/app/Actions/Dashboard/Commerce/print-log-records.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, test } from 'bun:test'
+import Receipt from '../../../Models/commerce/Receipt'
+import {
+  normalizePrintLogRecord,
+  printLogsToCsv,
+  printLogTimestamp,
+  summarizePrintLogs,
+} from './print-log-records'
+
+function receipt(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    id: 4,
+    printer: null,
+    document: 'Receipt #44',
+    timestamp: '2026-07-29 18:30:00',
+    status: 'success',
+    size: 0,
+    pages: 0,
+    duration: 0,
+    metadata: '{}',
+    print_device_id: null,
+    created_at: '2026-07-29 18:30:00',
+    ...overrides,
+  }
+}
+
+describe('dashboard print log records', () => {
+  test('accepts API timestamps and normalizes them for persistence', async () => {
+    const timestamp = Receipt.attributes.timestamp.validation.rule
+
+    expect(timestamp.validate('2026-07-29T18:30:00.000Z').valid).toBe(true)
+    expect(timestamp.validate('2026-07-29 18:30:00').valid).toBe(false)
+    expect(await Receipt.set.timestamp({ timestamp: '2026-07-29T18:30:00.000Z' } as any)).toBe('2026-07-29 18:30:00')
+    expect(await Receipt.set.timestamp({ timestamp: 1785349800 } as any)).toBe('2026-07-29 18:30:00')
+  })
+
+  test('normalizes native receipt columns, relationships, and UTC timestamps', () => {
+    const record = normalizePrintLogRecord(receipt({
+      printer: 'Front Counter',
+      size: 12,
+      pages: 2,
+      duration: 1.5,
+      print_device_id: 8,
+    }), new Set(['8']))
+
+    expect(record).toMatchObject({
+      id: '4',
+      printer: 'Front Counter',
+      timestamp: '2026-07-29T18:30:00.000Z',
+      status: 'success',
+      sizeKb: 12,
+      pages: 2,
+      durationSeconds: 1.5,
+      printDeviceId: '8',
+      createdAt: '2026-07-29T18:30:00.000Z',
+    })
+    expect(printLogTimestamp(record.timestamp)).toBe(Date.parse('2026-07-29T18:30:00Z'))
+    expect(printLogTimestamp(1785349800)).toBe(Date.parse('2026-07-29T18:30:00Z'))
+    expect(printLogTimestamp('1785349800')).toBe(Date.parse('2026-07-29T18:30:00Z'))
+  })
+
+  test('rejects corrupt outcomes and missing PrintDevice relationships', () => {
+    expect(() => normalizePrintLogRecord(receipt({
+      status: 'SUCCESS',
+    }))).toThrow('Receipt 4.status must be success or failed or warning')
+    expect(() => normalizePrintLogRecord(receipt({
+      pages: 1.5,
+    }))).toThrow('Receipt 4.pages must be an integer')
+    expect(() => normalizePrintLogRecord(
+      receipt({ print_device_id: 9 }),
+      new Set(),
+    )).toThrow('Receipt 4.print_device_id references missing PrintDevice 9')
+    expect(() => printLogTimestamp('not-a-date')).toThrow('valid timestamp')
+  })
+
+  test('summarizes only persisted print outcomes', () => {
+    const records = [
+      normalizePrintLogRecord(receipt({ id: 1, status: 'success', pages: 1, duration: 2 })),
+      normalizePrintLogRecord(receipt({ id: 2, status: 'success', pages: 3, duration: 4 })),
+      normalizePrintLogRecord(receipt({ id: 3, status: 'warning', pages: 2, duration: 7 })),
+      normalizePrintLogRecord(receipt({ id: 4, status: 'failed', pages: 0, duration: 0 })),
+    ]
+
+    expect(summarizePrintLogs(records)).toEqual({
+      total: 4,
+      successful: 2,
+      failed: 1,
+      warnings: 1,
+      successRate: 50,
+      totalPages: 6,
+      averagePages: 1.5,
+      averageSuccessfulDuration: 3,
+    })
+  })
+
+  test('exports the current print log view as CSV', () => {
+    const csv = printLogsToCsv([
+      normalizePrintLogRecord(receipt({
+        id: 1,
+        printer: 'Front, Counter',
+        document: 'Receipt #1',
+        status: 'success',
+      })),
+    ])
+
+    expect(csv.split('\n')).toHaveLength(2)
+    expect(csv).toContain('"Front, Counter"')
+    expect(csv).toContain('Receipt #1')
+  })
+})

package/app/Actions/Dashboard/Commerce/print-log-records.ts

@@ -0,0 +1,121 @@
+import {
+  commerceEnum,
+  commerceIdentifier,
+  commerceNumber,
+  commerceOptionalIdentifier,
+  commerceOptionalString,
+  commerceRequiredString,
+  commerceTimestamp,
+  commerceValue,
+} from './commerce-record'
+
+export type PrintLogStatus = 'success' | 'failed' | 'warning'
+
+export interface PrintLogRecord {
+  id: string
+  printer: string
+  document: string
+  timestamp: string
+  status: PrintLogStatus
+  sizeKb: number
+  pages: number
+  durationSeconds: number
+  metadata: string
+  printDeviceId: string
+  createdAt: string
+}
+
+export interface PrintLogSummary {
+  total: number
+  successful: number
+  failed: number
+  warnings: number
+  successRate: number
+  totalPages: number
+  averagePages: number
+  averageSuccessfulDuration: number
+}
+
+export function printLogTimestamp(input: unknown): number {
+  return new Date(commerceTimestamp(input, 'Receipt', 'timestamp')).getTime()
+}
+
+export function normalizePrintLogRecord(
+  record: any,
+  printDeviceIds = new Set<string>(),
+): PrintLogRecord {
+  const id = commerceIdentifier(commerceValue(record, 'id', 'uuid'), 'Receipt')
+  const source = `Receipt ${id}`
+  const printDeviceId = commerceOptionalIdentifier(
+    commerceValue(record, 'print_device_id', 'printDeviceId'),
+    source,
+    'print_device_id',
+  )
+  if (printDeviceId && !printDeviceIds.has(printDeviceId))
+    throw new TypeError(`${source}.print_device_id references missing PrintDevice ${printDeviceId}.`)
+  return {
+    id,
+    printer: commerceOptionalString(commerceValue(record, 'printer'), source, 'printer'),
+    document: commerceRequiredString(commerceValue(record, 'document'), source, 'document'),
+    timestamp: commerceTimestamp(commerceValue(record, 'timestamp'), source, 'timestamp'),
+    status: commerceEnum(commerceValue(record, 'status'), source, 'status', [
+      'success',
+      'failed',
+      'warning',
+    ]),
+    sizeKb: commerceNumber(commerceValue(record, 'size'), source, 'size', { min: 0, max: 100 }),
+    pages: commerceNumber(commerceValue(record, 'pages'), source, 'pages', {
+      min: 0,
+      max: 50,
+      integer: true,
+    }),
+    durationSeconds: commerceNumber(commerceValue(record, 'duration'), source, 'duration', {
+      min: 0,
+      max: 50,
+    }),
+    metadata: commerceOptionalString(commerceValue(record, 'metadata'), source, 'metadata'),
+    printDeviceId,
+    createdAt: commerceTimestamp(commerceValue(record, 'created_at', 'createdAt'), source),
+  }
+}
+
+export function summarizePrintLogs(records: PrintLogRecord[]): PrintLogSummary {
+  const successful = records.filter(record => record.status === 'success')
+  const totalPages = records.reduce((total, record) => total + record.pages, 0)
+  const successfulDuration = successful.reduce((total, record) => total + record.durationSeconds, 0)
+  return {
+    total: records.length,
+    successful: successful.length,
+    failed: records.filter(record => record.status === 'failed').length,
+    warnings: records.filter(record => record.status === 'warning').length,
+    successRate: records.length ? Math.round((successful.length / records.length) * 1000) / 10 : 0,
+    totalPages,
+    averagePages: records.length ? Math.round((totalPages / records.length) * 10) / 10 : 0,
+    averageSuccessfulDuration: successful.length
+      ? Math.round((successfulDuration / successful.length) * 10) / 10
+      : 0,
+  }
+}
+
+function csvCell(input: unknown): string {
+  const raw = String(input ?? '')
+  return /[",\n]/.test(raw) ? `"${raw.replaceAll('"', '""')}"` : raw
+}
+
+export function printLogsToCsv(records: PrintLogRecord[]): string {
+  const rows: unknown[][] = [
+    ['ID', 'Printer', 'Document', 'Timestamp', 'Status', 'Size KB', 'Pages', 'Duration seconds', 'Print device ID'],
+    ...records.map(record => [
+      record.id,
+      record.printer,
+      record.document,
+      record.timestamp,
+      record.status,
+      record.sizeKb,
+      record.pages,
+      record.durationSeconds,
+      record.printDeviceId,
+    ]),
+  ]
+  return rows.map(row => row.map(csvCell).join(',')).join('\n')
+}

package/app/Actions/Dashboard/Commerce/product-unit-records.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  normalizeProductUnitRecord,
+  productUnitOptions,
+  summarizeProductUnits,
+} from './product-unit-records'
+
+function unit(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    id: 12,
+    name: 'Kilogram',
+    abbreviation: 'kg',
+    type: 'Weight',
+    description: null,
+    is_default: false,
+    product_id: null,
+    created_at: '2026-07-29 10:00:00',
+    ...overrides,
+  }
+}
+
+describe('dashboard product unit records', () => {
+  it('normalizes model columns and resolves linked products', () => {
+    const record = normalizeProductUnitRecord(unit({
+      description: 'Metric weight',
+      is_default: 1,
+      product_id: 7,
+    }), new Map([['7', 'Coffee beans']]))
+
+    expect(record).toEqual({
+      id: '12',
+      name: 'Kilogram',
+      abbreviation: 'kg',
+      type: 'Weight',
+      description: 'Metric weight',
+      isDefault: true,
+      productId: '7',
+      productName: 'Coffee beans',
+      createdAt: '2026-07-29T10:00:00.000Z',
+    })
+  })
+
+  it('rejects invalid values and missing Product relationships', () => {
+    expect(() => normalizeProductUnitRecord(unit({
+      is_default: 'yes',
+    }))).toThrow('ProductUnit 12.is_default must be a boolean')
+    expect(() => normalizeProductUnitRecord(unit({
+      product_id: 9,
+    }), new Map())).toThrow('ProductUnit 12.product_id references missing Product 9')
+  })
+
+  it('summarizes persisted units without double-counting linked products', () => {
+    const productNames = new Map([['2', 'Coffee'], ['4', 'Milk']])
+    const records = [
+      normalizeProductUnitRecord(unit({ id: 1, name: 'Gram', is_default: true, product_id: 2 }), productNames),
+      normalizeProductUnitRecord(unit({ id: 2, name: 'Kilogram', is_default: false, product_id: 2 }), productNames),
+      normalizeProductUnitRecord(unit({ id: 3, name: 'Liter', type: 'Volume', is_default: true, product_id: 4 }), productNames),
+    ]
+
+    expect(summarizeProductUnits(records)).toEqual({
+      total: 3,
+      defaults: 2,
+      types: 2,
+      linkedProducts: 2,
+      defaultConflicts: 0,
+    })
+  })
+
+  it('reports unit types with competing defaults', () => {
+    const records = [
+      normalizeProductUnitRecord(unit({ id: 1, name: 'Liter', type: 'Volume', is_default: true })),
+      normalizeProductUnitRecord(unit({ id: 2, name: 'Milliliter', type: 'Volume', is_default: true })),
+      normalizeProductUnitRecord(unit({ id: 3, name: 'Gram', type: 'Weight', is_default: true })),
+    ]
+
+    expect(summarizeProductUnits(records).defaultConflicts).toBe(1)
+  })
+
+  it('builds stable, validated product options from model rows', () => {
+    expect(productUnitOptions([
+      { id: 2, name: 'Tea' },
+      { id: 1, name: 'Coffee' },
+    ])).toEqual([
+      { id: '1', name: 'Coffee' },
+      { id: '2', name: 'Tea' },
+    ])
+    expect(() => productUnitOptions([{ id: 3, name: '' }]))
+      .toThrow('Product 3.name must be a non-empty string')
+  })
+})