@stacksjs/defaults 0.70.229 → 0.70.231

package/app/Actions/Dashboard/Commerce/CommerceCustomersAction.ts

@@ -1,48 +1,33 @@
 import { Action } from '@stacksjs/actions'
+import { config } from '@stacksjs/config'
 import { Customer } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import {
+  normalizeCommerceCustomerCurrency,
+  normalizeCommerceCustomerRecord,
+  summarizeCommerceCustomers,
+} from './commerce-customer-records'
 
 export default new Action({
-  name: 'CommerceCustomers',
-  description: 'Returns customers list with stats.',
+  name: 'CommerceCustomersAction',
+  description: 'Returns persisted Customer records and summary values for dashboard management.',
   method: 'GET',
+  apiResponse: true,
+
   async handle() {
     try {
-      const allCustomers = await Customer.all()
-      const totalCustomers = await Customer.count()
-
-      const customers = allCustomers.map(c => ({
-        name: String(c.get('name') || 'Unknown'),
-        email: String(c.get('email') || 'N/A'),
-        orders: Number(c.get('order_count') || 0),
-        spent: `$${(Number(c.get('total_spent') || 0)).toFixed(2)}`,
-        lastOrder: 'Recently',
-        status: (Number(c.get('total_spent') || 0)) > 500 ? 'vip' : (Number(c.get('order_count') || 0)) > 0 ? 'active' : 'inactive',
-      }))
-
-      const activeCustomers = customers.filter(c => c.status === 'active' || c.status === 'vip').length
-      const vipCustomers = customers.filter(c => c.status === 'vip').length
-      const totalSpent = allCustomers.reduce((sum, c) => sum + (Number(c.get('total_spent') || 0)), 0)
-      const avgLifetimeValue = totalCustomers > 0 ? totalSpent / totalCustomers : 0
-
-      const stats = [
-        { label: 'Total Customers', value: String(totalCustomers) },
-        { label: 'Active', value: String(activeCustomers) },
-        { label: 'VIP', value: String(vipCustomers) },
-        { label: 'Avg Lifetime Value', value: `$${avgLifetimeValue.toFixed(2)}` },
-      ]
-
-      return { customers, stats }
-    }
-    catch {
+      const customers = await Customer.orderBy('name', 'asc').limit(500).get()
+      const records = customers.map(normalizeCommerceCustomerRecord)
       return {
-        customers: [],
-        stats: [
-          { label: 'Total Customers', value: '0' },
-          { label: 'Active', value: '0' },
-          { label: 'VIP', value: '0' },
-          { label: 'Avg Lifetime Value', value: '$0.00' },
-        ],
+        records,
+        summary: summarizeCommerceCustomers(records),
+        currency: normalizeCommerceCustomerCurrency((config as any).commerce?.currency),
       }
     }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'Customer records could not be read.',
+      }, 503)
+    }
   },
 })

package/app/Actions/Dashboard/Commerce/CommerceDashboardAction.ts

@@ -1,98 +1,64 @@
+import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
-import { orders, payments } from '@stacksjs/commerce'
+import { Customer, Order, OrderItem, Product } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import {
+  buildCommerceDashboard,
+  commerceDashboardQueryStart,
+  normalizeCommerceDashboardCustomer,
+  normalizeCommerceDashboardOrder,
+  normalizeCommerceDashboardOrderItem,
+  normalizeCommerceDashboardProduct,
+  normalizeCommerceDashboardRange,
+} from './commerce-dashboard'
 
-interface ComparisonShape {
-  is_increase: boolean
-  percentage: number
-}
-
-function formatChange(comparison?: ComparisonShape): string {
-  if (!comparison) return ''
-  const sign = comparison.is_increase ? '+' : '-'
-  return `${sign}${Number(comparison.percentage).toFixed(1)}%`
-}
-
-function formatUSD(amount: number): string {
-  return `$${Number(amount || 0).toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`
-}
-
-function formatRelativeTime(iso: string | null | undefined): string {
-  if (!iso) return ''
-  const then = new Date(iso).getTime()
-  if (Number.isNaN(then)) return ''
-  const diff = Date.now() - then
-  const minutes = Math.floor(diff / 60000)
-  if (minutes < 1) return 'just now'
-  if (minutes < 60) return `${minutes}m ago`
-  const hours = Math.floor(minutes / 60)
-  if (hours < 24) return `${hours}h ago`
-  const days = Math.floor(hours / 24)
-  return `${days}d ago`
+function sqlTimestamp(date: Date): string {
+  return date.toISOString().slice(0, 19).replace('T', ' ')
 }
 
 export default new Action({
   name: 'CommerceDashboard',
-  description: 'Returns commerce dashboard stats, recent orders, and top products for the last 30 days.',
+  description: 'Returns range-aware commerce metrics, charts, recent orders, and top products from application models.',
   method: 'GET',
-  async handle() {
-    try {
-      const [paymentStats, orderStats] = await Promise.all([
-        payments.fetchPaymentStats(30),
-        orders.fetchStats(),
-      ])
-
-      // KPI tiles. The first three are real aggregates with period-over-period
-      // change. Conversion rate is intentionally a placeholder until we wire a
-      // session-tracking source — see TODO at the bottom of this file.
-      const stats = [
-        {
-          label: 'Revenue (30d)',
-          value: formatUSD(paymentStats.total_revenue),
-          change: formatChange(paymentStats.comparison?.revenue),
-        },
-        {
-          label: 'Orders',
-          value: String(orderStats.total),
-          change: formatChange(paymentStats.comparison?.transactions),
-        },
-        {
-          label: 'Avg Order Value',
-          value: formatUSD(paymentStats.average_transaction),
-          change: formatChange(paymentStats.comparison?.average),
-        },
-        // Conversion rate stays canned — we don't track sessions yet,
-        // so we cannot compute orders / sessions. See TODO below.
-        { label: 'Conversion Rate', value: '—', change: '' },
-      ]
+  apiResponse: true,
 
-      const recentOrders = (orderStats.recent ?? []).slice(0, 5).map((o: any) => ({
-        id: `ORD-${String(o.id).padStart(4, '0')}`,
-        customer: o.customer_id ? `#${o.customer_id}` : '—',
-        total: formatUSD(Number(o.total_amount) || 0),
-        status: String(o.status || 'pending'),
-        time: formatRelativeTime(o.created_at),
-      }))
+  async handle(request: RequestInstance) {
+    try {
+      const range = normalizeCommerceDashboardRange(request.get('range'))
+      const now = new Date()
+      const queryStart = commerceDashboardQueryStart(range, now)
+      const orders = queryStart
+        ? await Order.where('created_at', '>=', sqlTimestamp(queryStart)).orderByDesc('id').get()
+        : await Order.orderByDesc('id').get()
+      const orderRows = orders.map(normalizeCommerceDashboardOrder)
+      const orderIds = [...new Set(orderRows.map(order => order.id))]
+      const customerIds = [...new Set(orderRows
+        .map(order => order.customerId)
+        .filter(Boolean))]
+      const orderItems = orderIds.length > 0
+        ? await OrderItem.where('order_id', 'in', orderIds).get()
+        : []
+      const orderItemRows = orderItems.map(normalizeCommerceDashboardOrderItem)
+      const productIds = [...new Set(orderItemRows.map(item => item.productId))]
 
-      // TODO: top products needs an order_items × products aggregation
-      // (sum of quantity grouped by product, ordered desc, top N). The
-      // existing `Product.orderByDesc('price')` was wrong — that returns
-      // most-expensive products, not best sellers. Until that helper is
-      // written, return an empty list rather than misleading data.
-      const topProducts: Array<{ name: string, sales: number, revenue: string }> = []
+      const [products, customers] = await Promise.all([
+        productIds.length > 0 ? Product.where('id', 'in', productIds).get() : [],
+        customerIds.length > 0 ? Customer.where('id', 'in', customerIds).get() : [],
+      ])
 
-      return { stats, recentOrders, topProducts }
+      return buildCommerceDashboard(
+        orderRows,
+        orderItemRows,
+        products.map(normalizeCommerceDashboardProduct),
+        customers.map(normalizeCommerceDashboardCustomer),
+        range,
+        now,
+      )
     }
-    catch {
-      return {
-        stats: [
-          { label: 'Revenue (30d)', value: '$0.00', change: '' },
-          { label: 'Orders', value: '0', change: '' },
-          { label: 'Avg Order Value', value: '$0.00', change: '' },
-          { label: 'Conversion Rate', value: '—', change: '' },
-        ],
-        recentOrders: [],
-        topProducts: [],
-      }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'Commerce overview records could not be read.',
+      }, 503)
     }
   },
 })

package/app/Actions/Dashboard/Commerce/CommerceDeliveryAction.ts

@@ -1,65 +1,36 @@
 import { Action } from '@stacksjs/actions'
-import { ShippingMethod, DeliveryRoute, ShippingZone } from '@stacksjs/orm'
+import { config } from '@stacksjs/config'
+import { DeliveryRoute, Driver, ShippingMethod, ShippingZone } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import { buildDeliveryOverview } from './commerce-delivery'
 
 export default new Action({
   name: 'CommerceDelivery',
-  description: 'Returns shipping/delivery data including shipments, carriers, and zones.',
+  description: 'Returns the dashboard delivery overview from routes, drivers, shipping methods, and zones.',
   method: 'GET',
+  apiResponse: true,
+
   async handle() {
     try {
-      const [allMethods, allRoutes, allZones] = await Promise.all([
-        ShippingMethod.all(),
-        DeliveryRoute.all(),
-        ShippingZone.all(),
+      const [allMethods, allRoutes, allZones, allDrivers] = await Promise.all([
+        ShippingMethod.orderBy('id', 'asc').limit(500).get(),
+        DeliveryRoute.orderBy('id', 'asc').limit(500).get(),
+        ShippingZone.orderBy('id', 'asc').limit(500).get(),
+        Driver.orderBy('id', 'asc').limit(500).get(),
       ])
 
-      const carriers = allMethods.map(m => ({
-        name: String(m.get('name') || ''),
-        shipments: Number(m.get('shipment_count') || 0),
-        onTime: '-',
-        status: String(m.get('status') || 'active'),
-      }))
-
-      const shipments = allRoutes.map(r => ({
-        id: `SHP-${String(r.get('id')).padStart(4, '0')}`,
-        order: String(r.get('order_id') ? `ORD-${r.get('order_id')}` : '-'),
-        carrier: String(r.get('carrier') || r.get('name') || ''),
-        tracking: String(r.get('tracking_number') || '-'),
-        status: String(r.get('status') || 'processing'),
-        eta: String(r.get('estimated_delivery') || '-'),
-      }))
-
-      const zones = allZones.map(z => ({
-        name: String(z.get('name') || ''),
-        rate: String(z.get('rate') || '-'),
-        delivery: String(z.get('delivery_time') || '-'),
-      }))
-
-      const inTransit = shipments.filter(s => s.status === 'in_transit').length
-      const delivered = shipments.filter(s => s.status === 'delivered').length
-      const exceptions = shipments.filter(s => s.status === 'exception').length
-
-      const stats = [
-        { label: 'In Transit', value: String(inTransit) },
-        { label: 'Delivered Today', value: String(delivered) },
-        { label: 'Exceptions', value: String(exceptions) },
-        { label: 'Avg Delivery Time', value: '-' },
-      ]
-
-      return { shipments, stats, carriers, zones }
+      return buildDeliveryOverview(
+        allMethods,
+        allRoutes,
+        allZones,
+        allDrivers,
+        (config as any).commerce?.currency,
+      )
     }
-    catch {
-      return {
-        shipments: [],
-        stats: [
-          { label: 'In Transit', value: '0' },
-          { label: 'Delivered Today', value: '0' },
-          { label: 'Exceptions', value: '0' },
-          { label: 'Avg Delivery Time', value: '-' },
-        ],
-        carriers: [],
-        zones: [],
-      }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'Delivery records could not be read.',
+      }, 503)
     }
   },
 })

package/app/Actions/Dashboard/Commerce/CommerceGiftCardsAction.ts

@@ -1,48 +1,34 @@
 import { Action } from '@stacksjs/actions'
-import { GiftCard } from '@stacksjs/orm'
+import { Customer, GiftCard } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import { normalizeGiftCardRecord, summarizeGiftCards } from './gift-card-records'
+import { commerceIdentifier, commerceValue } from './commerce-record'
 
 export default new Action({
-  name: 'CommerceGiftCards',
-  description: 'Returns gift cards list with stats and denominations.',
+  name: 'CommerceGiftCardsAction',
+  description: 'Returns persisted GiftCard records for dashboard management.',
   method: 'GET',
-  async handle() {
-    const denominations = ['$25', '$50', '$75', '$100', '$150', '$200', 'Custom']
+  apiResponse: true,
 
+  async handle() {
     try {
-      const allCards = await GiftCard.orderByDesc('id').limit(50).get()
-
-      const giftCards = allCards.map(r => ({
-        code: String(r.get('code') || ''),
-        balance: `$${Number(r.get('balance') || 0)}`,
-        initial: `$${Number(r.get('initial_value') || r.get('amount') || 0)}`,
-        recipient: r.get('recipient_email') || r.get('recipient') || null,
-        status: String(r.get('status') || 'active'),
-        created: String(r.get('created_at') || ''),
-      }))
-
-      const activeCards = giftCards.filter(c => c.status === 'active').length
-      const totalBalance = allCards.reduce((s, r) => s + (Number(r.get('balance') || 0)), 0)
-
-      const stats = [
-        { label: 'Outstanding Balance', value: `$${totalBalance.toLocaleString()}` },
-        { label: 'Active Cards', value: String(activeCards) },
-        { label: 'Redeemed Today', value: '-' },
-        { label: 'Sold This Month', value: '-' },
-      ]
-
-      return { giftCards, stats, denominations }
-    }
-    catch {
+      const [giftCards, customers] = await Promise.all([
+        GiftCard.orderByDesc('id').limit(500).get(),
+        Customer.orderBy('id', 'asc').limit(500).get(),
+      ])
+      const customerIds = new Set(customers.map(customer =>
+        commerceIdentifier(commerceValue(customer, 'id', 'uuid'), 'Customer'),
+      ))
+      const records = giftCards.map(giftCard => normalizeGiftCardRecord(giftCard, customerIds))
       return {
-        giftCards: [],
-        stats: [
-          { label: 'Outstanding Balance', value: '$0' },
-          { label: 'Active Cards', value: '0' },
-          { label: 'Redeemed Today', value: '-' },
-          { label: 'Sold This Month', value: '-' },
-        ],
-        denominations,
+        records,
+        summary: summarizeGiftCards(records),
       }
     }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'Gift card records could not be read.',
+      }, 503)
+    }
   },
 })

package/app/Actions/Dashboard/Commerce/CommerceOrdersAction.ts

@@ -1,51 +1,62 @@
 import { Action } from '@stacksjs/actions'
-import { Order } from '@stacksjs/orm'
+import { config } from '@stacksjs/config'
+import { Coupon, Customer, Order, OrderItem } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import {
+  addOrderItemQuantity,
+  normalizeCommerceOrderRecord,
+  normalizeOrderCouponId,
+  normalizeOrderCustomerContext,
+  normalizeOrderCustomerOption,
+  summarizeCommerceOrders,
+} from './commerce-order-records'
+import { commerceCurrency, commerceIdentifier, commerceValue } from './commerce-record'
 
 export default new Action({
-  name: 'CommerceOrders',
-  description: 'Returns orders list with stats and filters.',
+  name: 'CommerceOrdersAction',
+  description: 'Returns persisted Order records with customer context and item counts for dashboard management.',
   method: 'GET',
-  async handle() {
-    const filters = ['All', 'Pending', 'Processing', 'Shipped', 'Delivered', 'Cancelled']
+  apiResponse: true,
 
+  async handle() {
     try {
-      const allOrders = await Order.orderBy('created_at', 'desc').get()
-
-      const orders = allOrders.map(o => ({
-        id: `ORD-${String(o.get('id')).padStart(4, '0')}`,
-        customer: String(o.get('customer_name') || 'Guest'),
-        items: Number(o.get('item_count') || 1),
-        total: `$${(Number(o.get('total_amount')) || 0).toFixed(2)}`,
-        status: String(o.get('status') || 'pending'),
-        payment: o.get('status') === 'completed' ? 'paid' : o.get('status') === 'cancelled' ? 'refunded' : 'pending',
-        date: o.get('created_at') ? String(o.get('created_at')).split('T')[0] : 'N/A',
-      }))
-
-      const totalOrders = orders.length
-      const pendingOrders = orders.filter(o => o.status === 'pending').length
-      const processingOrders = orders.filter(o => o.status === 'processing').length
-      const completedOrders = orders.filter(o => o.status === 'completed' || o.status === 'shipped' || o.status === 'delivered').length
+      const orders = await Order.orderBy('created_at', 'desc').limit(500).get()
+      const orderIds = new Set(orders.map(order =>
+        commerceIdentifier(commerceValue(order, 'id', 'uuid'), 'Order'),
+      ))
+      const numericOrderIds = [...orderIds].map(Number).filter(Number.isSafeInteger)
+      const [customers, coupons, items] = await Promise.all([
+        Customer.orderBy('name', 'asc').limit(500).get(),
+        Coupon.orderBy('id', 'asc').limit(500).get(),
+        numericOrderIds.length > 0 ? OrderItem.where('order_id', 'in', numericOrderIds).get() : [],
+      ])
+      const customerContexts = customers.map(normalizeOrderCustomerContext)
+      const customerMap = new Map(customerContexts.map(customer => [customer.id, customer.context]))
+      const couponIds = new Set(coupons.map(normalizeOrderCouponId))
+      const itemCounts = new Map<string, number>()
+      for (const item of items)
+        addOrderItemQuantity(item, orderIds, itemCounts)
 
-      const stats = [
-        { label: 'Total Orders', value: String(totalOrders) },
-        { label: 'Pending', value: String(pendingOrders) },
-        { label: 'Processing', value: String(processingOrders) },
-        { label: 'Completed', value: String(completedOrders) },
-      ]
-
-      return { orders, stats, filters }
-    }
-    catch {
+      const records = orders.map(order =>
+        normalizeCommerceOrderRecord(order, customerMap, itemCounts, couponIds),
+      )
+      const defaultStatuses = ['PENDING', 'PREPARING', 'READY', 'DELIVERED', 'CANCELED']
+      const defaultTypes = ['DINE_IN', 'TAKEOUT', 'DELIVERY']
       return {
-        orders: [],
-        stats: [
-          { label: 'Total Orders', value: '0' },
-          { label: 'Pending', value: '0' },
-          { label: 'Processing', value: '0' },
-          { label: 'Completed', value: '0' },
-        ],
-        filters,
+        records,
+        summary: summarizeCommerceOrders(records),
+        customers: customers
+          .map(normalizeOrderCustomerOption)
+          .sort((left, right) => left.label.localeCompare(right.label)),
+        statuses: [...new Set([...defaultStatuses, ...records.map(record => record.status)])],
+        orderTypes: [...new Set([...defaultTypes, ...records.map(record => record.orderType)])],
+        defaultCurrency: commerceCurrency((config as any).commerce?.currency, 'Commerce configuration'),
       }
     }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'Order records could not be read.',
+      }, 503)
+    }
   },
 })

package/app/Actions/Dashboard/Commerce/CommercePaymentsAction.ts

@@ -1,59 +1,40 @@
 import { Action } from '@stacksjs/actions'
-import { Payment, PaymentMethod } from '@stacksjs/orm'
+import { Customer, Order, Payment } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import { commerceIdentifier, commerceValue } from './commerce-record'
+import { normalizePaymentRecord, summarizePayments } from './payment-records'
 
 export default new Action({
-  name: 'CommercePayments',
-  description: 'Returns payments list with stats and payment methods.',
+  name: 'CommercePaymentsAction',
+  description: 'Returns persisted commerce payments and currency-safe summaries.',
   method: 'GET',
+  apiResponse: true,
+
   async handle() {
     try {
-      const [allPayments, allMethods] = await Promise.all([
-        Payment.orderByDesc('id').limit(50).get(),
-        PaymentMethod.all(),
+      const [paymentRows, orders, customers] = await Promise.all([
+        Payment.orderByDesc('id').limit(500).get(),
+        Order.orderBy('id', 'asc').limit(500).get(),
+        Customer.orderBy('id', 'asc').limit(500).get(),
       ])
-
-      const payments = allPayments.map(r => ({
-        id: r.get('id') ? `PAY-${r.get('id')}` : '',
-        order: r.get('order_id') ? `ORD-${r.get('order_id')}` : '',
-        amount: `$${Number(r.get('amount') || 0)}`,
-        method: String(r.get('method') || r.get('payment_method') || ''),
-        status: String(r.get('status') || ''),
-        date: String(r.get('created_at') || ''),
-      }))
-
-      const completed = allPayments.filter(r => r.get('status') === 'completed')
-      const totalRev = completed.reduce((s, r) => s + (Number(r.get('amount')) || 0), 0)
-      const pending = allPayments.filter(r => r.get('status') === 'pending').reduce((s, r) => s + (Number(r.get('amount')) || 0), 0)
-      const refunded = allPayments.filter(r => r.get('status') === 'refunded').reduce((s, r) => s + (Number(r.get('amount')) || 0), 0)
-      const failed = allPayments.filter(r => r.get('status') === 'failed').length
-
-      const stats = [
-        { label: 'Total Revenue', value: `$${totalRev.toLocaleString()}` },
-        { label: 'Pending', value: `$${pending.toLocaleString()}` },
-        { label: 'Refunded', value: `$${refunded.toLocaleString()}` },
-        { label: 'Failed', value: String(failed) },
-      ]
-
-      const paymentMethods = allMethods.map(m => ({
-        name: String(m.get('name') || m.get('type') || ''),
-        provider: String(m.get('provider') || ''),
-        status: String(m.get('status') || 'active'),
-        volume: '-',
-      }))
-
-      return { payments, stats, paymentMethods }
-    }
-    catch {
+      const orderIds = new Set(orders.map(order =>
+        commerceIdentifier(commerceValue(order, 'id', 'uuid'), 'Order'),
+      ))
+      const customerIds = new Set(customers.map(customer =>
+        commerceIdentifier(commerceValue(customer, 'id', 'uuid'), 'Customer'),
+      ))
+      const records = paymentRows.map(payment =>
+        normalizePaymentRecord(payment, { orderIds, customerIds }),
+      )
       return {
-        payments: [],
-        stats: [
-          { label: 'Total Revenue', value: '$0' },
-          { label: 'Pending', value: '$0' },
-          { label: 'Refunded', value: '$0' },
-          { label: 'Failed', value: '0' },
-        ],
-        paymentMethods: [],
+        records,
+        summary: summarizePayments(records),
       }
     }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'Payment records could not be read.',
+      }, 503)
+    }
   },
 })

package/app/Actions/Dashboard/Commerce/CommercePosAction.ts

@@ -0,0 +1,71 @@
+import { Action } from '@stacksjs/actions'
+import { config } from '@stacksjs/config'
+import { Category, Customer, Manufacturer, Product, TaxRate } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import {
+  isCommercePosCustomerActive,
+  normalizeCommercePosCustomer,
+  normalizeCommercePosProduct,
+  selectCommercePosTaxRate,
+} from './commerce-pos'
+import {
+  normalizeCommerceProductRecord,
+  normalizeCommerceCurrency,
+  normalizeManufacturerOption,
+  normalizeProductOption,
+} from './commerce-product-records'
+
+export default new Action({
+  name: 'CommercePosAction',
+  description: 'Returns persisted products, customers, and tax configuration for the native point of sale.',
+  method: 'GET',
+  apiResponse: true,
+
+  async handle() {
+    try {
+      const [products, categories, manufacturers, customers, taxRates] = await Promise.all([
+        Product.orderBy('name', 'asc').limit(500).get(),
+        Category.orderBy('name', 'asc').limit(500).get(),
+        Manufacturer.orderBy('manufacturer', 'asc').limit(500).get(),
+        Customer.orderBy('name', 'asc').limit(500).get(),
+        TaxRate.orderBy('id', 'asc').limit(500).get(),
+      ])
+      const categoryOptions = categories.map(normalizeProductOption)
+      const manufacturerOptions = manufacturers.map(normalizeManufacturerOption)
+      const categoryMap = new Map(categoryOptions.map(option => [option.id, option.label]))
+      const manufacturerMap = new Map(manufacturerOptions.map(option => [option.id, option.label]))
+      const emptyCounts = new Map<string, number>()
+      const records = products.map(product => normalizeCommercePosProduct(normalizeCommerceProductRecord(
+        product,
+        categoryMap,
+        manufacturerMap,
+        emptyCounts,
+        emptyCounts,
+        emptyCounts,
+      )))
+      const sellable = records.filter(record => record.isAvailable && record.inventoryCount > 0)
+      const usedCategoryIds = new Set(records.map(record => record.categoryId).filter(Boolean))
+
+      return {
+        products: records,
+        categories: categoryOptions.filter(category => usedCategoryIds.has(category.id)),
+        customers: customers
+          .filter(isCommercePosCustomerActive)
+          .map(normalizeCommercePosCustomer),
+        taxRate: selectCommercePosTaxRate(taxRates),
+        defaultCurrency: normalizeCommerceCurrency((config as any).commerce?.currency),
+        paymentMethods: [{ id: 'cash', label: 'Cash' }],
+        summary: {
+          products: records.length,
+          sellable: sellable.length,
+          inventory: records.reduce((sum, record) => sum + record.inventoryCount, 0),
+        },
+      }
+    }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'Point of sale records could not be read.',
+      }, 503)
+    }
+  },
+})