fix(dashboard): the point of sale searches every product and customer

The point of sale read the first 500 products, categories, manufacturers,
customers and tax rates by name or id with every load. A product past the
500th could not be found or rung up; a product whose category or
manufacturer was past the 500th failed the whole screen; the checkout could
not be given a later customer; and the summary counted those 500.

GET /api/dashboard/commerce/pos/products is the catalogue now, searched and
paged by the database: q (name, description, category, manufacturer,
allergens), category, availability (sellable or unsellable), page and
per_page, by name ignoring case. Its categories and manufacturers are read
by exactly the ids the page references. With `ids=1,2,3` it answers exactly
those products, which is how the cart brings its lines up to date after a
reload or a sale: before, a line was checked against the 500 products the
screen held, and a cart line outside a page would now have been dropped.

GET /api/dashboard/commerce/pos keeps the settings: the categories some
product is in (read whole), the tax rate (the default active rate, else the
first active one, chosen in SQL), the currency, the payment methods, and the
summary counted over every product.

The checkout searches Active customers by name, email or phone through
GET /api/dashboard/commerce/customer-choices?active=1, the shared customer
search (commerce-choices.ts) with a new active-only option. The POS customer
normalizer and its Active check are gone with the list they served.

The catalogue reuses the Products list's search, so its availability filter
gains `sellable` and `unsellable`, and productRecordsFor is exported and can
skip the variant, unit and review counts the point of sale does not show.
The page pages the catalogue with useServerList and UI/Pagination.

Tested on SQLite, PostgreSQL and MySQL with 520 products, categories,
manufacturers and customers, BOOLEAN or TINYINT(1) availability and enum
statuses. Three controls went red on all three: reading the first 500
categories ("Product 511 references missing Category 515"), ignoring the
active-only filter, and ignoring the default tax rate.

Live: GET /commerce/pos answers 10 products, 10 sellable, 583 units, a 59%
tax rate and five categories, as SQL counts them, and the active customer
search finds the 11 Active customers. The catalogue itself answers 503 on
this dev database, whose products table has no slug column, which every
product read (Products, POS before this change) already fails on, so the
checkout was not exercised live.

Refs #3218

Author: glennmichael123

storage/framework/auto-imports/actions.ts

@@ -300,6 +300,7 @@ export const actions = {
   'Actions/Dashboard/Commerce/CommercePaymentsExportAction': '../defaults/app/Actions/Dashboard/Commerce/CommercePaymentsExportAction.ts',
   'Actions/Dashboard/Commerce/CommercePosAction': '../defaults/app/Actions/Dashboard/Commerce/CommercePosAction.ts',
   'Actions/Dashboard/Commerce/CommercePosCheckoutAction': '../defaults/app/Actions/Dashboard/Commerce/CommercePosCheckoutAction.ts',
+  'Actions/Dashboard/Commerce/CommercePosProductsAction': '../defaults/app/Actions/Dashboard/Commerce/CommercePosProductsAction.ts',
   'Actions/Dashboard/Commerce/CommercePrintDevicesAction': '../defaults/app/Actions/Dashboard/Commerce/CommercePrintDevicesAction.ts',
   'Actions/Dashboard/Commerce/CommercePrintLogsAction': '../defaults/app/Actions/Dashboard/Commerce/CommercePrintLogsAction.ts',
   'Actions/Dashboard/Commerce/CommerceProductChoicesAction': '../defaults/app/Actions/Dashboard/Commerce/CommerceProductChoicesAction.ts',
@@ -338,6 +339,7 @@ export const actions = {
   'Actions/Dashboard/Commerce/commerce-order-list': '../defaults/app/Actions/Dashboard/Commerce/commerce-order-list.ts',
   'Actions/Dashboard/Commerce/commerce-order-records': '../defaults/app/Actions/Dashboard/Commerce/commerce-order-records.ts',
   'Actions/Dashboard/Commerce/commerce-payment-list': '../defaults/app/Actions/Dashboard/Commerce/commerce-payment-list.ts',
+  'Actions/Dashboard/Commerce/commerce-pos-catalog': '../defaults/app/Actions/Dashboard/Commerce/commerce-pos-catalog.ts',
   'Actions/Dashboard/Commerce/commerce-pos': '../defaults/app/Actions/Dashboard/Commerce/commerce-pos.ts',
   'Actions/Dashboard/Commerce/commerce-product-list': '../defaults/app/Actions/Dashboard/Commerce/commerce-product-list.ts',
   'Actions/Dashboard/Commerce/commerce-product-records': '../defaults/app/Actions/Dashboard/Commerce/commerce-product-records.ts',

storage/framework/auto-imports/sources.json

@@ -1,3 +1,3 @@
 {
-  "fingerprint": "3369da254f6f8132820989bb681ba828a81fff16f8ee7e1ab66e697182ffbfe6"
+  "fingerprint": "35affd5a7d4523633fb5959e5bac5010f999e2e083e3ed5e3cf88e3496b0a509"
 }

storage/framework/defaults/app/Actions/Dashboard/Commerce/CommerceCustomerChoicesAction.ts

@@ -22,7 +22,9 @@ export default new Action({
       return response.json({ message: query.error }, 422)
 
     try {
-      const { choices, total } = await searchCustomerChoices(query)
+      // `active=1` keeps to Active customers, as the point of sale offers them.
+      const activeOnly = ['1', 'true'].includes(String(request.get<unknown>('active', '') ?? '').trim())
+      const { choices, total } = await searchCustomerChoices(query, undefined, undefined, { activeOnly })
       return { choices, total, limit: query.limit }
     }
     catch (error) {

storage/framework/defaults/app/Actions/Dashboard/Commerce/CommercePosAction.ts

@@ -1,65 +1,35 @@
 import { Action } from '@stacksjs/actions/runtime'
 import { config } from '@stacksjs/config'
-import { Category, Customer, Manufacturer, Product, TaxRate } from '@stacksjs/orm'
 import { dashboardOperationalError } from '../dashboard-response'
-import {
-  isCommercePosCustomerActive,
-  normalizeCommercePosCustomer,
-  normalizeCommercePosProduct,
-  selectCommercePosTaxRate,
-} from './commerce-pos'
-import {
-  normalizeCommerceProductRecord,
-  normalizeCommerceCurrency,
-  normalizeManufacturerOption,
-  normalizeProductOption,
-} from './commerce-product-records'
+import { readPosSettings } from './commerce-pos-catalog'
+import { normalizeCommerceCurrency } from './commerce-product-records'
 
+/**
+ * `GET /api/dashboard/commerce/pos` - the point of sale's settings: the
+ * categories in use, the tax rate, the currency, the payment methods and the
+ * catalogue summary, counted over every product (commerce-pos-catalog.ts,
+ * stacksjs/stacks#3218).
+ *
+ * The catalogue itself is GET /commerce/pos/products, searched and paged, and
+ * the checkout searches customers through GET /commerce/customer-choices.
+ * This used to send the first 500 products, categories, manufacturers,
+ * customers and tax rates.
+ */
 export default new Action({
   name: 'CommercePosAction',
-  description: 'Returns persisted products, customers, and tax configuration for the native point of sale.',
+  description: 'Returns the native point of sale settings and catalogue summary.',
   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))
-
+      const settings = await readPosSettings()
       return {
-        products: records,
-        categories: categoryOptions.filter(category => usedCategoryIds.has(category.id)),
-        customers: customers
-          .filter(isCommercePosCustomerActive)
-          .map(normalizeCommercePosCustomer),
-        taxRate: selectCommercePosTaxRate(taxRates),
+        categories: settings.categories,
+        taxRate: settings.taxRate,
         defaultCurrency: normalizeCommerceCurrency(config.commerce?.currency),
         paymentMethods: [{ id: 'cash', label: 'Cash' }],
-        summary: {
-          products: records.length,
-          sellable: sellable.length,
-          inventory: records.reduce((sum, record) => sum + record.inventoryCount, 0),
-        },
+        summary: settings.summary,
       }
     }
     catch (error) {

storage/framework/defaults/app/Actions/Dashboard/Commerce/CommercePosProductsAction.ts

@@ -0,0 +1,39 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions/runtime'
+import { response } from '@stacksjs/router'
+import { dashboardOperationalError } from '../dashboard-response'
+import { parsePosCatalogQuery, parsePosIds, readPosCatalogPage, readPosProducts } from './commerce-pos-catalog'
+
+/**
+ * `GET /api/dashboard/commerce/pos/products` - the point of sale catalogue,
+ * searched and paged by the database (commerce-pos-catalog.ts,
+ * stacksjs/stacks#3218): `q`, `category`, `availability` (sellable or
+ * unsellable), `page` and `per_page`. With `ids=1,2,3` it answers exactly
+ * those products instead, which is how the cart checks its lines.
+ */
+export default new Action({
+  name: 'CommercePosProductsAction',
+  description: 'Searches and pages the point of sale catalogue, or reads the products a cart holds.',
+  method: 'GET',
+  apiResponse: true,
+
+  async handle(request: RequestInstance) {
+    const read = (key: string) => request.get<unknown>(key, '')
+    const ids = parsePosIds(read)
+    if ('error' in ids)
+      return response.json({ message: ids.error }, 422)
+    const query = parsePosCatalogQuery(read)
+    if ('error' in query)
+      return response.json({ message: query.error }, 422)
+
+    try {
+      if (ids.length > 0)
+        return { records: await readPosProducts(ids) }
+      const catalog = await readPosCatalogPage(query)
+      return { records: catalog.products, total: catalog.total, page: catalog.page, perPage: query.perPage }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Point of sale products could not be read.', 'CommercePosProductsAction')
+    }
+  },
+})

storage/framework/defaults/app/Actions/Dashboard/Commerce/commerce-choices.ts

@@ -28,13 +28,15 @@ async function search<T>(
   normalize: (row: Record<string, unknown>) => T,
   run: CommerceSqlRunner,
   dialect: QueryBuilderDialect,
+  only: string[] = [],
 ): Promise<{ choices: T[], total: number }> {
   const { bind, values } = binder(dialect)
-  let where = ''
+  const clauses = [...only]
   if (query.search) {
     const pattern = containsPattern(query.search)
-    where = ` WHERE ${searched.map(column => `LOWER(${column}) LIKE ${bind(pattern)} ESCAPE '!'`).join(' OR ')}`
+    clauses.push(`(${searched.map(column => `LOWER(${column}) LIKE ${bind(pattern)} ESCAPE '!'`).join(' OR ')})`)
   }
+  const where = clauses.length > 0 ? ` WHERE ${clauses.join(' AND ')}` : ''
   const [counted, found] = await Promise.all([
     run.unsafe(`SELECT COUNT(*) AS total_count FROM ${table}${where}`, values).execute(),
     // LOWER, so the order is the same on every dialect: each collates case its own way.
@@ -52,11 +54,17 @@ export function searchProductChoices(
   return search('products', 'id, name, inventory_count', [`COALESCE(name, '')`, asText('id', dialect)], query, normalizeProductChoice, run, dialect)
 }
 
-/** Customers by name, email or phone. */
+/**
+ * Customers by name, email or phone. `activeOnly` keeps to customers whose
+ * status is Active, as the point of sale offers them.
+ */
 export function searchCustomerChoices(
   query: NamedSearchQuery,
   run: CommerceSqlRunner = db,
   dialect: QueryBuilderDialect = getDatabaseDialect(),
+  options: { activeOnly?: boolean } = {},
 ): Promise<{ choices: CustomerChoice[], total: number }> {
-  return search('customers', 'id, name, email, phone', [`COALESCE(name, '')`, `COALESCE(email, '')`, `COALESCE(phone, '')`], query, normalizeCustomerChoice, run, dialect)
+  // A text comparison: PostgreSQL keeps the status as an enum.
+  const only = options.activeOnly ? [`${asText('status', dialect)} = 'Active'`] : []
+  return search('customers', 'id, name, email, phone', [`COALESCE(name, '')`, `COALESCE(email, '')`, `COALESCE(phone, '')`], query, normalizeCustomerChoice, run, dialect, only)
 }