fix(dashboard): Orders reads the customers and coupons its orders reference

The Orders endpoint read the first 500 customers by name and the first 500
coupons by id, and normalizeCommerceOrderRecord refuses an order whose
customer or coupon is not among what it was given. So with more than 500
customers, one order from a customer past the 500th failed the whole page,
and the same for coupons.

The action now reads exactly the customers and coupons its orders reference,
by id (`referencedIds`). The order dialog's customer choices keep their own
read, which the next slice replaces with a search.

The test shows both halves: an order whose customer is the 704th normalizes
from the referenced read, and is refused without it. Live with every feature
on (STACKS_CANONICAL_FEATURES=1, no config change), Orders answers 200 with
all 20 dev orders and the same summary as before.

Refs #3218

Author: glennmichael123

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

@@ -8,6 +8,7 @@ import {
   normalizeOrderCouponId,
   normalizeOrderCustomerContext,
   normalizeOrderCustomerOption,
+  referencedIds,
   summarizeCommerceOrders,
 } from './commerce-order-records'
 import { commerceCurrency, commerceIdentifier, commerceValue } from './commerce-record'
@@ -25,12 +26,18 @@ export default new Action({
         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(),
+      // Exactly the customers and coupons these orders reference, so no order
+      // points at one that was not read (commerce-order-records.ts).
+      const customerIds = referencedIds(orders, 'customer_id', 'customerId')
+      const couponReferences = referencedIds(orders, 'coupon_id', 'couponId')
+      const [referencedCustomers, coupons, items, customers] = await Promise.all([
+        customerIds.length > 0 ? Customer.whereIn('id', customerIds).get() : [],
+        couponReferences.length > 0 ? Coupon.whereIn('id', couponReferences).get() : [],
         numericOrderIds.length > 0 ? OrderItem.whereIn('order_id', numericOrderIds).get() : [],
+        // The order dialog's customer choices.
+        Customer.orderBy('name', 'asc').limit(500).get(),
       ])
-      const customerContexts = customers.map(normalizeOrderCustomerContext)
+      const customerContexts = referencedCustomers.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>()

storage/framework/defaults/app/Actions/Dashboard/Commerce/commerce-order-records.test.ts

@@ -4,6 +4,7 @@ import {
   normalizeCommerceOrderRecord,
   normalizeOrderCustomerContext,
   normalizeOrderCustomerOption,
+  referencedIds,
   summarizeCommerceOrders,
 } from './commerce-order-records'
 
@@ -134,3 +135,31 @@ describe('dashboard commerce order records', () => {
     })
   })
 })
+
+describe('the customers and coupons an order page reads', () => {
+  test('are exactly the ids the orders reference, once each, in order', () => {
+    const orders = [
+      order({ id: 1, customer_id: 704, coupon_id: null }),
+      order({ id: 2, customer_id: 12, coupon_id: 9 }),
+      order({ id: 3, customer_id: 704, coupon_id: '9' }),
+      order({ id: 4, customer_id: null, coupon_id: 3 }),
+    ]
+    expect(referencedIds(orders, 'customer_id', 'customerId')).toEqual([12, 704])
+    expect(referencedIds(orders, 'coupon_id', 'couponId')).toEqual([3, 9])
+  })
+
+  test('cover every order, so none is refused for a customer that was not read', () => {
+    // The 704th customer by name is past any fixed first-500 read. The map
+    // built from the referenced ids still holds it, so the order normalizes.
+    const orders = [order({ id: 1, customer_id: 704 })]
+    const ids = referencedIds(orders, 'customer_id')
+    const customers = new Map(ids.map(id => [String(id), { name: `Customer ${id}`, email: `c${id}@example.com` }]))
+    expect(normalizeCommerceOrderRecord(orders[0], customers, new Map()).customerName).toBe('Customer 704')
+    // And the refusal it prevents is real: without that customer the order is rejected.
+    expect(() => normalizeCommerceOrderRecord(orders[0], new Map(), new Map())).toThrow('references missing Customer 704')
+  })
+
+  test('ignore empty, zero and non-numeric references', () => {
+    expect(referencedIds([order({ customer_id: '' }), order({ customer_id: 0 }), order({ customer_id: 'abc' }), order({ customer_id: -4 })], 'customer_id')).toEqual([])
+  })
+})

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

@@ -169,6 +169,25 @@ export function normalizeOrderCustomerContext(customer: any): { id: string, cont
   }
 }
 
+/**
+ * The ids a set of records points at through one field, as integers, once
+ * each. Orders are read with exactly the customers and coupons they reference,
+ * not the first 500 of each: `normalizeCommerceOrderRecord` refuses an order
+ * whose customer or coupon is missing from what it was given, so with more
+ * than 500 customers a single order from one past the 500th by name failed the
+ * whole Orders page.
+ */
+export function referencedIds(records: unknown[], ...keys: string[]): number[] {
+  const ids = new Set<number>()
+  for (const record of records) {
+    const value = commerceValue(record, ...keys)
+    const id = Number(value)
+    if (value !== undefined && value !== null && value !== '' && Number.isSafeInteger(id) && id > 0)
+      ids.add(id)
+  }
+  return [...ids].sort((left, right) => left - right)
+}
+
 export function normalizeOrderCouponId(coupon: any): string {
   return commerceIdentifier(commerceValue(coupon, 'id', 'uuid'), 'Coupon')
 }