u

src/automats/orderAutomat.js

@@ -3,9 +3,8 @@
  * @description Manages cached and paginated company sales orders (`GET /api/order`).
  *
  * Upstream Triggers:
- * - `authAutomat`: Triggers `actions.load()` on `'authed'` with a `selectedCompanyId`,
- *   and `actions.reset()` on `'anon'`.
- * - UI / Routes: Calls to `load({ offset, limit })`, `setPage(page)`, or `reload()`.
+ * - `authAutomat`: Triggers `actions.reset()` on `'anon'` or when `selectedCompanyId` changes.
+ * - UI / Routes: On-demand calls to `ensureLoaded()`, `load()`, or `reload()`.
  */
 
 import { Automat } from 'react-automat';
@@ -53,39 +52,25 @@ const initialState = {
   total: 0,
   offset: 0,
   limit: 20,
+  hasMore: false,
+  loadingMore: false,
   status: 'idle',
   error: null,
 };
 
 let automat;
 let inflightLoad = null;
+let inflightMore = null;
 const FETCH_PAGE_SIZE = 100;
 
-// MARK: pages through GET /api/order until every order is collected
-async function fetchAllOrders() {
-  let offset = 0;
-  let total = Infinity;
-  const collected = [];
-  while (offset === 0 || collected.length < total) {
-    const res = await orderApi.list({ offset, limit: FETCH_PAGE_SIZE });
-    if (offset === 0) total = Number(res?.total ?? res?.orders?.length ?? 0);
-    const page = Array.isArray(res?.orders) ? res.orders : [];
-    collected.push(...page);
-    offset += page.length;
-    if (page.length === 0) break;
-  }
-  return collected;
+// MARK: fetches a single page from GET /api/order
+async function fetchOrdersPage(offset = 0, limit = FETCH_PAGE_SIZE) {
+  const res = await orderApi.list({ offset, limit });
+  const orders = Array.isArray(res?.orders) ? res.orders : [];
+  const total = Number(res?.total ?? orders.length);
+  return { orders, total };
 }
 
-const applyAll = (orders) => ({
-  items: orders,
-  total: orders.length,
-  offset: 0,
-  limit: Math.max(orders.length, 1),
-  status: 'ready',
-  error: null,
-});
-
 /**
  * Client-side filter over number, external reference and (resolved) customer name.
  * @param {Order[]} items
@@ -107,16 +92,43 @@ const actions = {
   },
 
   /**
-   * Loads all orders, deduplicating concurrent callers.
+   * Synchronously returns current items and triggers loading if idle.
+   * On remounts, directly returns cached items from the automat.
+   *
+   * @param {(order: Order) => string} [nameOf] Optional customer name resolver.
+   * @returns {Order[]}
+   */
+  getOrLoad(nameOf) {
+    if (automat.state.status === 'idle') {
+      void actions.load().catch(() => {});
+    }
+    const { items, filter } = automat.state;
+    if (filter) {
+      return filterOrders(items, filter, nameOf);
+    }
+    return items;
+  },
+
+  /**
+   * Loads the initial 100 orders, deduplicating concurrent callers.
    *
    * @returns {Promise<Order[]>}
    */
   load() {
     if (inflightLoad) return inflightLoad;
     automat.setState({ status: 'loading', error: null });
-    inflightLoad = fetchAllOrders()
-      .then((orders) => {
-        automat.setState(applyAll(orders));
+    inflightLoad = fetchOrdersPage(0, FETCH_PAGE_SIZE)
+      .then(({ orders, total }) => {
+        automat.setState({
+          items: orders,
+          total,
+          offset: 0,
+          limit: FETCH_PAGE_SIZE,
+          hasMore: orders.length < total && orders.length >= FETCH_PAGE_SIZE,
+          loadingMore: false,
+          status: 'ready',
+          error: null,
+        });
         return orders;
       })
       .catch((error) => {
@@ -128,14 +140,61 @@ const actions = {
   },
 
   /**
-   * Silently re-fetches all orders without flashing loading state.
+   * Loads the next batch of 100 orders when pagination approaches the end.
+   *
+   * @returns {Promise<Order[]>}
+   */
+  loadMore() {
+    const { items, total, status, loadingMore } = automat.state;
+    if (status !== 'ready' || loadingMore) return Promise.resolve(items);
+    if (total > 0 && items.length >= total) return Promise.resolve(items);
+    if (inflightMore) return inflightMore;
+
+    automat.setState({ loadingMore: true });
+    const offset = items.length;
+    inflightMore = fetchOrdersPage(offset, FETCH_PAGE_SIZE)
+      .then(({ orders: nextBatch, total: newTotal }) => {
+        const existingIds = new Set(automat.state.items.map((o) => o.id));
+        const uniqueNext = nextBatch.filter((o) => !existingIds.has(o.id));
+        const merged = [...automat.state.items, ...uniqueNext];
+        const finalTotal = Math.max(newTotal, merged.length);
+        automat.setState({
+          items: merged,
+          total: finalTotal,
+          hasMore: nextBatch.length > 0 && merged.length < finalTotal,
+          loadingMore: false,
+        });
+        return merged;
+      })
+      .catch((err) => {
+        console.error('[orderAutomat] loadMore error:', err);
+        automat.setState({ loadingMore: false });
+        return automat.state.items;
+      })
+      .finally(() => {
+        inflightMore = null;
+      });
+
+    return inflightMore;
+  },
+
+  /**
+   * Silently re-fetches loaded orders without flashing loading state.
    *
    * @returns {Promise<Order[]>}
    */
   async reload() {
     try {
-      const orders = await fetchAllOrders();
-      automat.setState(applyAll(orders));
+      const currentCount = Math.max(FETCH_PAGE_SIZE, automat.state.items.length);
+      const { orders, total } = await fetchOrdersPage(0, currentCount);
+      automat.setState({
+        items: orders,
+        total,
+        hasMore: orders.length < total,
+        loadingMore: false,
+        status: 'ready',
+        error: null,
+      });
       return orders;
     } catch (error) {
       automat.setState({ error });
@@ -143,7 +202,6 @@ const actions = {
     }
   },
 
-
   /**
    * Ensures orders are loaded once the selected company is known.
    *
@@ -166,17 +224,35 @@ const actions = {
     automat.setState({
       items,
       total: items.length,
+      hasMore: false,
+      loadingMore: false,
       status: 'ready',
       error: null,
     });
     return items;
   },
 
+  /**
+   * Patches an order locally in the automat items cache.
+   *
+   * @param {number|string} id Order ID.
+   * @param {Partial<Order>} patch Partial properties to update.
+   * @returns {Order[]}
+   */
+  patchOrder(id, patch) {
+    const items = automat.state.items.map((o) =>
+      o.id === id ? { ...o, ...patch } : o,
+    );
+    automat.setState({ items });
+    return items;
+  },
+
   /**
    * Resets to idle state (called on logout).
    */
   reset() {
     inflightLoad = null;
+    inflightMore = null;
     automat.setState(initialState);
   },
 };
@@ -184,13 +260,20 @@ const actions = {
 export const orderAutomat = new Automat(initialState, actions, { name: 'order' });
 automat = orderAutomat;
 
-// Load on session/company establishment, reset on logout.
+// Reset on logout or company change (lazy-loaded on demand by views via ensureLoaded).
+let lastCompanyId = null;
 authAutomat.subscribe((auth) => {
-  const companyId = auth.user?.selectedCompanyId;
-  if (auth.status === 'authed' && companyId) {
-    void actions.load().catch(() => {});
-  } else if (auth.status === 'anon') {
+  const companyId = auth.user?.selectedCompanyId ?? null;
+  if (auth.status === 'anon') {
     actions.reset();
+    lastCompanyId = null;
+    return;
+  }
+  if (lastCompanyId !== null && companyId !== lastCompanyId) {
+    actions.reset();
+  }
+  if (auth.status === 'authed' && companyId != null) {
+    lastCompanyId = companyId;
   }
 });
 
@@ -204,6 +287,16 @@ export function selectOrderTotal(state = automat.state) {
   return state.total;
 }
 
+/** Selects whether more orders can be fetched from backend */
+export function selectHasMoreOrders(state = automat.state) {
+  return state.hasMore;
+}
+
+/** Selects whether an incremental fetch is currently in flight */
+export function selectIsLoadingMoreOrders(state = automat.state) {
+  return state.loadingMore;
+}
+
 /**
  * Calculates client pagination metadata.
  * Current Page: Math.floor(offset / limit) + 1