@stacksjs/defaults 0.70.229 → 0.70.231

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

@@ -0,0 +1,97 @@
+import {
+  commerceBoolean,
+  commerceIdentifier,
+  commerceOptionalIdentifier,
+  commerceOptionalString,
+  commerceRequiredString,
+  commerceTimestamp,
+  commerceValue,
+} from './commerce-record'
+
+export interface ProductUnitRecord {
+  id: string
+  name: string
+  abbreviation: string
+  type: string
+  description: string
+  isDefault: boolean
+  productId: string
+  productName: string
+  createdAt: string
+}
+
+export interface ProductUnitOption {
+  id: string
+  name: string
+}
+
+export interface ProductUnitSummary {
+  total: number
+  defaults: number
+  types: number
+  linkedProducts: number
+  defaultConflicts: number
+}
+
+export function productUnitOptions(products: any[]): ProductUnitOption[] {
+  return products
+    .map((product) => {
+      const id = commerceIdentifier(commerceValue(product, 'id', 'uuid'), 'Product')
+      return {
+        id,
+        name: commerceRequiredString(commerceValue(product, 'name'), `Product ${id}`, 'name'),
+      }
+    })
+    .sort((left, right) => left.name.localeCompare(right.name))
+}
+
+export function normalizeProductUnitRecord(
+  record: any,
+  products = new Map<string, string>(),
+): ProductUnitRecord {
+  const id = commerceIdentifier(commerceValue(record, 'id', 'uuid'), 'ProductUnit')
+  const source = `ProductUnit ${id}`
+  const productId = commerceOptionalIdentifier(
+    commerceValue(record, 'product_id', 'productId'),
+    source,
+    'product_id',
+  )
+  const productName = productId ? products.get(productId) : undefined
+  if (productId && !productName)
+    throw new TypeError(`${source}.product_id references missing Product ${productId}.`)
+  return {
+    id,
+    name: commerceRequiredString(commerceValue(record, 'name'), source, 'name'),
+    abbreviation: commerceRequiredString(
+      commerceValue(record, 'abbreviation'),
+      source,
+      'abbreviation',
+    ),
+    type: commerceRequiredString(commerceValue(record, 'type'), source, 'type'),
+    description: commerceOptionalString(commerceValue(record, 'description'), source, 'description'),
+    isDefault: commerceBoolean(
+      commerceValue(record, 'is_default', 'isDefault'),
+      source,
+      'is_default',
+    ),
+    productId,
+    productName: productName || '',
+    createdAt: commerceTimestamp(commerceValue(record, 'created_at', 'createdAt'), source),
+  }
+}
+
+export function summarizeProductUnits(records: ProductUnitRecord[]): ProductUnitSummary {
+  const defaultsByType = new Map<string, number>()
+  for (const record of records) {
+    if (record.isDefault && record.type)
+      defaultsByType.set(record.type, (defaultsByType.get(record.type) ?? 0) + 1)
+  }
+
+  return {
+    total: records.length,
+    defaults: records.filter(record => record.isDefault).length,
+    types: new Set(records.map(record => record.type).filter(Boolean)).size,
+    linkedProducts: new Set(records.map(record => record.productId).filter(Boolean)).size,
+    defaultConflicts: [...defaultsByType.values()].filter(count => count > 1).length,
+  }
+}

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

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  normalizeProductVariantRecord,
+  parseVariantOptions,
+  productVariantOptions,
+  summarizeProductVariants,
+} from './product-variant-records'
+
+function variant(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    id: 8,
+    variant: 'Large',
+    type: 'size',
+    description: null,
+    options: null,
+    status: 'active',
+    product_id: null,
+    created_at: '2026-07-29 10:00:00',
+    ...overrides,
+  }
+}
+
+describe('dashboard product variant records', () => {
+  it('parses persisted JSON and declared legacy comma options', () => {
+    expect(parseVariantOptions('["Small","Large"]')).toEqual(['Small', 'Large'])
+    expect(parseVariantOptions('Red, Blue')).toEqual(['Red', 'Blue'])
+    expect(() => parseVariantOptions('{"invalid":true}')).toThrow('JSON array')
+  })
+
+  it('normalizes model columns and Product relationships', () => {
+    expect(normalizeProductVariantRecord(variant({
+      description: 'Large configuration',
+      options: '["Large","XL"]',
+      status: 'draft',
+      product_id: 3,
+    }), new Map([['3', 'Coffee']])))
+      .toEqual({
+        id: '8',
+        variant: 'Large',
+        type: 'size',
+        description: 'Large configuration',
+        options: ['Large', 'XL'],
+        status: 'draft',
+        productId: '3',
+        productName: 'Coffee',
+        createdAt: '2026-07-29T10:00:00.000Z',
+      })
+  })
+
+  it('rejects malformed state and missing Product relationships', () => {
+    expect(() => normalizeProductVariantRecord(variant({
+      status: 'legacy',
+    }))).toThrow('ProductVariant 8.status must be active or inactive or draft')
+    expect(() => normalizeProductVariantRecord(variant({
+      product_id: 9,
+    }), new Map())).toThrow('ProductVariant 8.product_id references missing Product 9')
+  })
+
+  it('summarizes persisted variant states', () => {
+    const productNames = new Map([['2', 'Coffee'], ['4', 'Tea']])
+    const records = [
+      normalizeProductVariantRecord(variant({ id: 1, status: 'active', product_id: 2 }), productNames),
+      normalizeProductVariantRecord(variant({ id: 2, status: 'draft', product_id: 2 }), productNames),
+      normalizeProductVariantRecord(variant({ id: 3, status: 'inactive', product_id: 4 }), productNames),
+    ]
+    expect(summarizeProductVariants(records)).toEqual({
+      total: 3,
+      active: 1,
+      draft: 1,
+      linkedProducts: 2,
+    })
+  })
+
+  it('builds validated Product options', () => {
+    expect(productVariantOptions([
+      { id: 2, name: 'Tea' },
+      { id: 1, name: 'Coffee' },
+    ])).toEqual([
+      { id: '1', name: 'Coffee' },
+      { id: '2', name: 'Tea' },
+    ])
+    expect(() => productVariantOptions([{ id: 3, name: '' }]))
+      .toThrow('Product 3.name must be a non-empty string')
+  })
+})

package/app/Actions/Dashboard/Commerce/product-variant-records.ts

@@ -0,0 +1,90 @@
+import {
+  commerceEnum,
+  commerceIdentifier,
+  commerceOptionalIdentifier,
+  commerceOptionalString,
+  commerceRequiredString,
+  commerceStringList,
+  commerceTimestamp,
+  commerceValue,
+} from './commerce-record'
+
+export interface ProductVariantRecord {
+  id: string
+  variant: string
+  type: string
+  description: string
+  options: string[]
+  status: 'active' | 'inactive' | 'draft'
+  productId: string
+  productName: string
+  createdAt: string
+}
+
+export interface ProductVariantOption {
+  id: string
+  name: string
+}
+
+export interface ProductVariantSummary {
+  total: number
+  active: number
+  draft: number
+  linkedProducts: number
+}
+
+export function parseVariantOptions(input: unknown): string[] {
+  return commerceStringList(input, 'ProductVariant', 'options')
+}
+
+export function productVariantOptions(products: any[]): ProductVariantOption[] {
+  return products
+    .map((product) => {
+      const id = commerceIdentifier(commerceValue(product, 'id', 'uuid'), 'Product')
+      return {
+        id,
+        name: commerceRequiredString(commerceValue(product, 'name'), `Product ${id}`, 'name'),
+      }
+    })
+    .sort((left, right) => left.name.localeCompare(right.name))
+}
+
+export function normalizeProductVariantRecord(
+  record: any,
+  productNames = new Map<string, string>(),
+): ProductVariantRecord {
+  const id = commerceIdentifier(commerceValue(record, 'id', 'uuid'), 'ProductVariant')
+  const source = `ProductVariant ${id}`
+  const productId = commerceOptionalIdentifier(
+    commerceValue(record, 'product_id', 'productId'),
+    source,
+    'product_id',
+  )
+  const productName = productId ? productNames.get(productId) : undefined
+  if (productId && !productName)
+    throw new TypeError(`${source}.product_id references missing Product ${productId}.`)
+  return {
+    id,
+    variant: commerceRequiredString(commerceValue(record, 'variant'), source, 'variant'),
+    type: commerceRequiredString(commerceValue(record, 'type'), source, 'type'),
+    description: commerceOptionalString(commerceValue(record, 'description'), source, 'description'),
+    options: commerceStringList(commerceValue(record, 'options'), source, 'options'),
+    status: commerceEnum(commerceValue(record, 'status'), source, 'status', [
+      'active',
+      'inactive',
+      'draft',
+    ]),
+    productId,
+    productName: productName || '',
+    createdAt: commerceTimestamp(commerceValue(record, 'created_at', 'createdAt'), source),
+  }
+}
+
+export function summarizeProductVariants(records: ProductVariantRecord[]): ProductVariantSummary {
+  return {
+    total: records.length,
+    active: records.filter(record => record.status === 'active').length,
+    draft: records.filter(record => record.status === 'draft').length,
+    linkedProducts: new Set(records.map(record => record.productId).filter(Boolean)).size,
+  }
+}

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

@@ -0,0 +1,101 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  normalizeProductWaitlistCustomerOption,
+  normalizeProductWaitlistOption,
+  normalizeProductWaitlistRecord,
+  summarizeProductWaitlist,
+} from './product-waitlist-records'
+
+function entry(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    id: 4,
+    name: 'Chris',
+    email: 'chris@example.com',
+    phone: null,
+    quantity: 3,
+    notification_preference: 'email',
+    source: 'website',
+    notes: null,
+    status: 'waiting',
+    product_id: 8,
+    customer_id: null,
+    created_at: '2026-07-28T12:00:00.000Z',
+    ...overrides,
+  }
+}
+
+describe('dashboard product waitlist records', () => {
+  it('normalizes database and model attribute names', () => {
+    expect(normalizeProductWaitlistRecord(
+      entry({ quantity: '3', customer_id: 9 }),
+      new Set(['8']),
+      new Set(['9']),
+    )).toMatchObject({
+      id: '4',
+      quantity: 3,
+      notificationPreference: 'email',
+      productId: '8',
+      customerId: '9',
+      status: 'waiting',
+      createdAt: '2026-07-28T12:00:00.000Z',
+    })
+  })
+
+  it('rejects corrupt fields and missing relationships', () => {
+    expect(() => normalizeProductWaitlistRecord(
+      entry({ quantity: 0 }),
+      new Set(['8']),
+    )).toThrow('WaitlistProduct 4.quantity must be at least 1')
+    expect(() => normalizeProductWaitlistRecord(
+      entry({ product_id: 99 }),
+      new Set(),
+    )).toThrow('WaitlistProduct 4.product_id references missing Product 99')
+    expect(() => normalizeProductWaitlistRecord(
+      entry({ customer_id: 99 }),
+      new Set(['8']),
+      new Set(),
+    )).toThrow('WaitlistProduct 4.customer_id references missing Customer 99')
+  })
+
+  it('summarizes only native record states', () => {
+    const productIds = new Set(['8'])
+    const records = [
+      normalizeProductWaitlistRecord(entry({ id: 1, status: 'waiting' }), productIds),
+      normalizeProductWaitlistRecord(entry({ id: 2, status: 'notified' }), productIds),
+      normalizeProductWaitlistRecord(entry({ id: 3, status: 'purchased' }), productIds),
+      normalizeProductWaitlistRecord(entry({ id: 4, status: 'purchased' }), productIds),
+    ]
+    expect(summarizeProductWaitlist(records)).toEqual({
+      total: 4,
+      waiting: 1,
+      notified: 1,
+      purchased: 2,
+      conversionRate: 50,
+    })
+  })
+
+  it('normalizes persisted Product and Customer choices', () => {
+    expect(normalizeProductWaitlistOption({
+      id: 8,
+      name: 'Native Mug',
+      inventory_count: '12',
+    })).toEqual({
+      id: '8',
+      label: 'Native Mug',
+      detail: '12 in inventory',
+    })
+
+    expect(normalizeProductWaitlistCustomerOption({
+      id: 9,
+      name: 'Chris',
+      email: 'chris@example.com',
+      phone: '',
+    })).toEqual({
+      id: '9',
+      label: 'Chris',
+      detail: 'chris@example.com',
+      email: 'chris@example.com',
+      phone: '',
+    })
+  })
+})

package/app/Actions/Dashboard/Commerce/product-waitlist-records.ts

@@ -0,0 +1,156 @@
+import {
+  commerceEmail,
+  commerceEnum,
+  commerceIdentifier,
+  commerceNumber,
+  commerceOptionalIdentifier,
+  commerceOptionalString,
+  commerceRequiredString,
+  commerceTimestamp,
+  commerceValue,
+} from './commerce-record'
+
+export interface ProductWaitlistRecord {
+  id: string
+  name: string
+  email: string
+  phone: string
+  quantity: number
+  notificationPreference: string
+  source: string
+  notes: string
+  status: string
+  productId: string
+  customerId: string
+  createdAt: string
+}
+
+export interface ProductWaitlistSummary {
+  total: number
+  waiting: number
+  notified: number
+  purchased: number
+  conversionRate: number
+}
+
+export interface ProductWaitlistOption {
+  id: string
+  label: string
+  detail: string
+}
+
+export interface ProductWaitlistCustomerOption extends ProductWaitlistOption {
+  email: string
+  phone: string
+}
+
+export interface ProductWaitlistOptions {
+  products: ProductWaitlistOption[]
+  customers: ProductWaitlistCustomerOption[]
+}
+
+export interface ProductWaitlistWritePayload {
+  productId: number
+  customerId: number | null
+  name: string
+  email: string
+  phone: string
+  quantity: number
+  notificationPreference: 'sms' | 'email' | 'both'
+  source: string
+  notes: string
+  status: 'waiting' | 'notified' | 'purchased' | 'cancelled'
+}
+
+export function normalizeProductWaitlistRecord(
+  record: any,
+  productIds?: Set<string>,
+  customerIds?: Set<string>,
+): ProductWaitlistRecord {
+  const id = commerceIdentifier(commerceValue(record, 'id', 'uuid'), 'WaitlistProduct')
+  const source = `WaitlistProduct ${id}`
+  const productId = commerceIdentifier(
+    commerceValue(record, 'product_id', 'productId'),
+    source,
+    'product_id',
+  )
+  if (productIds && !productIds.has(productId))
+    throw new TypeError(`${source}.product_id references missing Product ${productId}.`)
+  const customerId = commerceOptionalIdentifier(
+    commerceValue(record, 'customer_id', 'customerId'),
+    source,
+    'customer_id',
+  )
+  if (customerId && customerIds && !customerIds.has(customerId))
+    throw new TypeError(`${source}.customer_id references missing Customer ${customerId}.`)
+  return {
+    id,
+    name: commerceRequiredString(commerceValue(record, 'name'), source, 'name'),
+    email: commerceEmail(commerceValue(record, 'email'), source),
+    phone: commerceOptionalString(commerceValue(record, 'phone'), source, 'phone'),
+    quantity: commerceNumber(commerceValue(record, 'quantity'), source, 'quantity', {
+      min: 1,
+      integer: true,
+    }),
+    notificationPreference: commerceEnum(
+      commerceValue(record, 'notification_preference', 'notificationPreference'),
+      source,
+      'notification_preference',
+      ['sms', 'email', 'both'],
+    ),
+    source: commerceRequiredString(commerceValue(record, 'source'), source, 'source'),
+    notes: commerceOptionalString(commerceValue(record, 'notes'), source, 'notes'),
+    status: commerceEnum(commerceValue(record, 'status'), source, 'status', [
+      'waiting',
+      'notified',
+      'purchased',
+      'cancelled',
+    ]),
+    productId,
+    customerId,
+    createdAt: commerceTimestamp(commerceValue(record, 'created_at', 'createdAt'), source),
+  }
+}
+
+export function normalizeProductWaitlistOption(record: any): ProductWaitlistOption {
+  const id = commerceIdentifier(commerceValue(record, 'id', 'uuid'), 'Product')
+  const source = `Product ${id}`
+  const inventory = commerceNumber(
+    commerceValue(record, 'inventory_count', 'inventoryCount'),
+    source,
+    'inventory_count',
+    { min: 0, integer: true },
+  )
+  return {
+    id,
+    label: commerceRequiredString(commerceValue(record, 'name'), source, 'name'),
+    detail: `${inventory} in inventory`,
+  }
+}
+
+export function normalizeProductWaitlistCustomerOption(record: any): ProductWaitlistCustomerOption {
+  const id = commerceIdentifier(commerceValue(record, 'id', 'uuid'), 'Customer')
+  const source = `Customer ${id}`
+  const email = commerceEmail(commerceValue(record, 'email'), source)
+  const phone = commerceOptionalString(commerceValue(record, 'phone'), source, 'phone')
+  return {
+    id,
+    label: commerceRequiredString(commerceValue(record, 'name'), source, 'name'),
+    detail: email || phone,
+    email,
+    phone,
+  }
+}
+
+export function summarizeProductWaitlist(records: ProductWaitlistRecord[]): ProductWaitlistSummary {
+  const waiting = records.filter(record => record.status === 'waiting').length
+  const notified = records.filter(record => record.status === 'notified').length
+  const purchased = records.filter(record => record.status === 'purchased').length
+  return {
+    total: records.length,
+    waiting,
+    notified,
+    purchased,
+    conversionRate: records.length > 0 ? Math.round((purchased / records.length) * 100) : 0,
+  }
+}

package/app/Actions/Dashboard/Commerce/restaurant-waitlist-records.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  normalizeRestaurantWaitlistCustomerOption,
+  normalizeRestaurantWaitlistRecord,
+  restaurantWaitlistDateTimeLocal,
+  restaurantWaitlistTimestamp,
+  summarizeRestaurantWaitlist,
+} from './restaurant-waitlist-records'
+
+function entry(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    id: 4,
+    customer_id: null,
+    name: 'Chris',
+    email: 'chris@example.com',
+    phone: null,
+    party_size: 3,
+    check_in_time: '2026-07-29 12:00:00',
+    table_preference: 'booth',
+    status: 'waiting',
+    quoted_wait_time: 25,
+    actual_wait_time: null,
+    queue_position: null,
+    created_at: '2026-07-29 12:00:00',
+    ...overrides,
+  }
+}
+
+describe('dashboard restaurant waitlist records', () => {
+  it('round-trips persisted UTC timestamps through local date inputs', () => {
+    const persisted = '2026-07-30 03:00:00'
+    const input = restaurantWaitlistDateTimeLocal(persisted)
+
+    expect(restaurantWaitlistTimestamp(persisted)).toBe(1785380400)
+    expect(restaurantWaitlistTimestamp(input)).toBe(1785380400)
+    expect(() => restaurantWaitlistTimestamp('not-a-date')).toThrow('valid timestamp')
+  })
+
+  it('normalizes model and database attribute names', () => {
+    expect(normalizeRestaurantWaitlistRecord(
+      entry({
+        customer_id: 8,
+        party_size: '3',
+        quoted_wait_time: '25',
+        queue_position: '2',
+      }),
+      new Set(['8']),
+    )).toMatchObject({
+      id: '4',
+      customerId: '8',
+      partySize: 3,
+      checkInTime: '2026-07-29T12:00:00.000Z',
+      tablePreference: 'booth',
+      status: 'waiting',
+      quotedWaitTime: 25,
+      actualWaitTime: null,
+      queuePosition: 2,
+      createdAt: '2026-07-29T12:00:00.000Z',
+    })
+  })
+
+  it('rejects corrupt fields and missing Customer relationships', () => {
+    expect(() => normalizeRestaurantWaitlistRecord(entry({
+      party_size: 0,
+    }))).toThrow('WaitlistRestaurant 4.party_size must be at least 1')
+    expect(() => normalizeRestaurantWaitlistRecord(entry({
+      queue_position: 0,
+    }))).toThrow('WaitlistRestaurant 4.queue_position must be at least 1')
+    expect(() => normalizeRestaurantWaitlistRecord(
+      entry({ customer_id: 99 }),
+      new Set(),
+    )).toThrow('WaitlistRestaurant 4.customer_id references missing Customer 99')
+  })
+
+  it('summarizes only persisted restaurant states and wait times', () => {
+    const records = [
+      normalizeRestaurantWaitlistRecord(entry({ id: 1, status: 'waiting', quoted_wait_time: 20 })),
+      normalizeRestaurantWaitlistRecord(entry({ id: 2, status: 'waiting', quoted_wait_time: 30 })),
+      normalizeRestaurantWaitlistRecord(entry({ id: 3, status: 'seated', quoted_wait_time: 10 })),
+      normalizeRestaurantWaitlistRecord(entry({ id: 4, status: 'no_show', quoted_wait_time: 15 })),
+    ]
+
+    expect(summarizeRestaurantWaitlist(records)).toEqual({
+      total: 4,
+      waiting: 2,
+      seated: 1,
+      cancelled: 0,
+      noShow: 1,
+      averageQuotedWait: 25,
+      seatingRate: 25,
+    })
+  })
+
+  it('normalizes persisted Customer choices', () => {
+    expect(normalizeRestaurantWaitlistCustomerOption({
+      id: 9,
+      name: 'Chris',
+      email: 'chris@example.com',
+      phone: '',
+    })).toEqual({
+      id: '9',
+      label: 'Chris',
+      detail: 'chris@example.com',
+      email: 'chris@example.com',
+      phone: '',
+    })
+  })
+})