@teincfood/core 0.7.8 → 0.8.0

package/dist/sync/transport-rest.js

@@ -5,9 +5,12 @@
  * resulting domain events. This transport is used when the cloud API is
  * reachable.
  */
-import { posService, sellerService, kioskService, menuService } from "../adapters/services";
+import { sellerService, kioskService, menuService } from "../adapters/services";
 import { syncLogger } from "../utils/sync-logger";
 import { generateEventId } from "../utils/uuid";
+import { createLocalOrder, transitionLocalOrder } from "../domain/orders/service";
+import { openSyncDatabase } from "../db/connection";
+import { getOrderById, updateOrderStatus } from "../db/operations";
 export class RestTransport {
     constructor() {
         this.name = "rest";
@@ -45,40 +48,38 @@ export class RestTransport {
     }
     async dispatchCommand(command) {
         const { command_type, business_id, entity_id, payload } = command;
-        const timestamp = new Date().toISOString();
+        // Use the command's original timestamp (set at creation time) so the event
+        // reflects when the mutation actually happened, not when it was dispatched.
+        const timestamp = command.timestamp || new Date().toISOString();
         switch (command_type) {
+            // Single create path — createLocalOrder owns SQLite + sync_jobs + the
+            // operating-hours gate. No direct-REST fallback: guard rejections
+            // (BUSINESS_CLOSED / HOURS_NOT_SYNCED) must stand, never be bypassed.
             case "order:create": {
-                const posPayload = {
-                    ...payload,
+                const order = await createLocalOrder(business_id, {
+                    ...(payload ?? {}),
                     command_id: command.command_id,
-                    local_order_number: payload.order_number,
-                };
-                const response = await posService.createPOSOrder(business_id, posPayload);
-                return this.wrapResponse("order.created", response.data, entity_id, timestamp, command);
+                    id: entity_id ?? command.command_id,
+                });
+                return this.wrapResponse("order.created", order, order.id, timestamp, command);
             }
             case "order:accept": {
-                const response = await sellerService.acceptOrder(entity_id);
-                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+                return this.executeOrderTransition(command, "accept", timestamp, () => sellerService.acceptOrder(entity_id));
             }
             case "order:reject": {
-                const response = await sellerService.rejectOrder(entity_id);
-                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+                return this.executeOrderTransition(command, "reject", timestamp, () => sellerService.rejectOrder(entity_id));
             }
             case "order:start_preparing": {
-                const response = await sellerService.startPreparingOrder(entity_id);
-                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+                return this.executeOrderTransition(command, "start_preparing", timestamp, () => sellerService.startPreparingOrder(entity_id));
             }
             case "order:mark_ready": {
-                const response = await sellerService.markOrderReady(entity_id);
-                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+                return this.executeOrderTransition(command, "mark_ready", timestamp, () => sellerService.markOrderReady(entity_id));
             }
             case "order:complete_pickup": {
-                const response = await sellerService.completeOrderPickup(entity_id);
-                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+                return this.executeOrderTransition(command, "complete_pickup", timestamp, () => sellerService.completeOrderPickup(entity_id));
             }
             case "order:cancel": {
-                const response = await sellerService.cancelOrder(entity_id);
-                return this.wrapResponse("order.status_changed", response.data, entity_id, timestamp, command);
+                return this.executeOrderTransition(command, "cancel", timestamp, () => sellerService.cancelOrder(entity_id));
             }
             case "delivery:assign": {
                 const response = await kioskService.assignKioskOrderToRider(entity_id, payload.rider_id);
@@ -89,11 +90,18 @@ export class RestTransport {
                 return this.wrapResponse("delivery.status_changed", response, entity_id, timestamp, command);
             }
             case "menu:create_item": {
-                const response = await menuService.createMenuItem(business_id, payload);
-                return this.wrapResponse("menu.item_created", response, entity_id, timestamp, command);
+                // cacheRecord is local-cache only — strip it so the backend receives
+                // the flat wire payload it accepts (it owns canonical on converge).
+                const { cacheRecord: _omitCreate, ...wireCreate } = payload;
+                void _omitCreate;
+                const createPayload = { ...wireCreate, id: wireCreate.id ?? command.command_id, command_id: command.command_id };
+                const response = await menuService.createMenuItem(business_id, createPayload);
+                return this.wrapResponse("menu.item_created", response, command.command_id, timestamp, command);
             }
             case "menu:update_item": {
-                const response = await menuService.updateMenuItem(entity_id, payload);
+                const { cacheRecord: _omitUpdate, ...wireUpdate } = payload;
+                void _omitUpdate;
+                const response = await menuService.updateMenuItem(entity_id, wireUpdate);
                 return this.wrapResponse("menu.item_updated", response, entity_id, timestamp, command);
             }
             case "menu:delete_item": {
@@ -101,13 +109,70 @@ export class RestTransport {
                 return this.wrapResponse("menu.item_deleted", response, entity_id, timestamp, command);
             }
             case "menu:create_category": {
-                const response = await menuService.createCategory(business_id, payload);
-                return this.wrapResponse("menu.category_created", response, entity_id, timestamp, command);
+                const { cacheRecord: _omitCatCreate, ...wireCatCreate } = payload;
+                void _omitCatCreate;
+                const createPayload = { ...wireCatCreate, id: wireCatCreate.id ?? command.command_id, command_id: command.command_id };
+                const response = await menuService.createCategory(business_id, createPayload);
+                return this.wrapResponse("menu.category_created", response, command.command_id, timestamp, command);
+            }
+            case "menu:update_category": {
+                const { cacheRecord: _omitCatUpdate, ...wireCatUpdate } = payload;
+                void _omitCatUpdate;
+                const response = await menuService.updateCategory(entity_id, wireCatUpdate);
+                return this.wrapResponse("menu.category_updated", response, entity_id, timestamp, command);
+            }
+            case "menu:delete_category": {
+                const response = await menuService.deleteCategory(entity_id);
+                return this.wrapResponse("menu.category_deleted", response, entity_id, timestamp, command);
+            }
+            case "payment:confirm_cash": {
+                return this.executeOrderTransition(command, "confirm_cash", timestamp, () => sellerService.confirmCashPayment(entity_id), "payment.completed");
             }
             default:
                 throw new Error(`RestTransport: unsupported command type ${command_type}`);
         }
     }
+    /**
+     * Order transitions go through the domain service first (single write path:
+     * SQLite + sync_jobs). If this device never saw the order (e.g. a LAN node
+     * handling a cloud-created order before its first pull), fall back to the
+     * previous direct-REST behavior so availability never regresses.
+     */
+    async executeOrderTransition(command, action, timestamp, restFallback, eventType = "order.status_changed") {
+        const { business_id, entity_id } = command;
+        try {
+            const order = await transitionLocalOrder(business_id, entity_id, action);
+            const data = { ...order, order_id: order.id };
+            return this.wrapResponse(eventType, data, order.id, timestamp, command);
+        }
+        catch (error) {
+            syncLogger.warn("RestTransport", "domain transition unavailable, REST fallback", {
+                command_type: command.command_type,
+                entity_id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            const response = await restFallback();
+            const raw = response.data;
+            const data = { ...raw };
+            const orderId = data.id ?? entity_id;
+            if (!data.order_id)
+                data.order_id = orderId;
+            if (business_id && orderId) {
+                try {
+                    const db = await openSyncDatabase();
+                    const existing = await getOrderById(db, business_id, orderId);
+                    if (existing) {
+                        const newStatus = data.status ?? existing.status;
+                        if (newStatus !== existing.status) {
+                            await updateOrderStatus(db, business_id, orderId, newStatus);
+                        }
+                    }
+                }
+                catch { }
+            }
+            return this.wrapResponse(eventType, data, orderId, timestamp, command);
+        }
+    }
     wrapResponse(eventType, data, entityId, timestamp, command) {
         return {
             event_id: generateEventId(),

package/dist/sync/use-sync-reconciliation.js

@@ -10,12 +10,14 @@
 import { useEffect } from "react";
 import { useQueryClient } from "@tanstack/react-query";
 import { syncEngine } from "./engine";
+import { getActiveBusiness } from "../adapters/business";
 import { applyPendingOrderEvent, applyOrderStateChangeEvent, registerPendingOrdersInvalidator, } from "./pending-orders.service";
 import { localNodeService } from "../adapters/local-node";
 import { getSyncDatabase } from "../db/connection";
 import { markEventsSynced } from "../db/operations";
 import { syncLogger } from "../utils/sync-logger";
-import { POS_KEYS, SELLER_KEYS, KIOSK_KEYS, SELLER_ORDERS_KEYS, BUSINESS_DELIVERIES_KEYS, MENU_KEYS, REFERENCE_KEYS, } from "../adapters/query-keys";
+import { subscribeDbChanges } from "../db/operations";
+import { POS_KEYS, SELLER_KEYS, KIOSK_KEYS, SELLER_ORDERS_KEYS, BUSINESS_DELIVERIES_KEYS, MENU_KEYS, REFERENCE_KEYS, SELLER_DASHBOARD_KEYS, } from "../adapters/query-keys";
 import { applyReferenceChangeEvent, registerReferenceInvalidator, registerReferenceEventEngine, REFERENCE_CHANGED_EVENT_TYPE, } from "../reference/events";
 function isLocalOrderEvent(event) {
     const payload = event.payload;
@@ -24,16 +26,44 @@ function isLocalOrderEvent(event) {
     const localOrderNumber = payload.local_order_number;
     return typeof localOrderNumber === "string" && /^[0-9]{2}-[0-9]{3}-[0-9]{3}$/.test(localOrderNumber);
 }
+const RECONCILE_DEBOUNCE_MS = 400;
 export function useSyncReconciliation() {
     const queryClient = useQueryClient();
     useEffect(() => {
+        let timer;
+        const pending = new Set();
+        const flush = () => {
+            timer = undefined;
+            if (pending.has("reference")) {
+                queryClient.invalidateQueries({ queryKey: MENU_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: REFERENCE_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: SELLER_DASHBOARD_KEYS.all });
+            }
+            if (pending.has("pending")) {
+                queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: KIOSK_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: SELLER_ORDERS_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: BUSINESS_DELIVERIES_KEYS.all });
+                queryClient.invalidateQueries({ queryKey: SELLER_DASHBOARD_KEYS.all });
+            }
+            if (pending.has("order")) {
+                // order.created with local number already covered by pending, but keep fine-grained
+                // POS.orders(businessId) is also covered by pending's broad POS.all, no extra needed.
+            }
+            pending.clear();
+        };
+        const schedule = (kind) => {
+            pending.add(kind);
+            if (!timer)
+                timer = setTimeout(flush, RECONCILE_DEBOUNCE_MS);
+        };
         // Reference changes re-sync offline data and refresh caches on this device
         // and (via the LAN relay) on every connected terminal.
         const unregisterReferenceInvalidator = registerReferenceInvalidator(() => {
-            queryClient.invalidateQueries({ queryKey: MENU_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: REFERENCE_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+            schedule("reference");
         });
         // Pending-order reconciliation invalidates POS + seller order lists so the
         // server-confirmed order replaces the optimistic one. Invalidate from the
@@ -42,17 +72,21 @@ export function useSyncReconciliation() {
         // keys. Also cover kiosk/seller-orders/business-deliveries so boards
         // refresh even when there is no Local Node (offline queue + Phoenix).
         const unregisterInvalidator = registerPendingOrdersInvalidator(() => {
-            queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: KIOSK_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: SELLER_ORDERS_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: BUSINESS_DELIVERIES_KEYS.all });
+            schedule("pending");
         });
         // Reference-change events are published through the Sync Engine but are
         // not backed by a command, so the engine has no transport dependency on
         // the reference module. Register the singleton once.
         registerReferenceEventEngine(syncEngine);
         const unsubscribe = syncEngine.subscribe(async (event) => {
+            // LAN strict: ignore events for other business on same subnet
+            try {
+                const activeId = getActiveBusiness()?.id;
+                const payloadBid = event.payload?.business_id;
+                if (activeId && payloadBid && payloadBid !== activeId)
+                    return;
+            }
+            catch { }
             syncLogger.event(event, "received");
             // The node relays engine events (e.g. order.created when a queued
             // command is replayed) to LAN clients so they reconcile their pending
@@ -74,6 +108,10 @@ export function useSyncReconciliation() {
             // Order/delivery state changed: refresh order caches so this terminal
             // shows the same order states as the device that made the change.
             await applyOrderStateChangeEvent(event, "local");
+            // Any order/delivery event should refresh dashboard recent orders immediately (fresh on transition)
+            if (event.event_type.startsWith("order.") || event.event_type.startsWith("delivery.")) {
+                schedule("pending");
+            }
             // Route both queued (optimistic) and reconciled (created) order events
             // into the pending-orders store.
             if (event.event_type === "order.create_queued" ||
@@ -90,18 +128,22 @@ export function useSyncReconciliation() {
                         error: String(error),
                     });
                 }
-                const payload = event.payload;
-                const businessId = payload.business_id;
-                if (businessId) {
-                    queryClient.invalidateQueries({ queryKey: POS_KEYS.orders(businessId) });
-                    queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
-                }
+                schedule("pending");
             }
         });
+        const dbUnsub = subscribeDbChanges((info) => {
+            if (info.table.startsWith("reference_data"))
+                schedule("reference");
+            else if (info.table === "orders" || info.table.startsWith("entity_snapshots"))
+                schedule("pending");
+        });
         return () => {
+            if (timer)
+                clearTimeout(timer);
             unsubscribe();
             unregisterInvalidator();
             unregisterReferenceInvalidator();
+            dbUnsub();
         };
     }, [queryClient]);
 }

package/dist/test-helpers/memory-driver.js

@@ -5,6 +5,8 @@ export function createMemoryDriver() {
         entity_snapshots: [],
         commands: [],
         events: [],
+        orders: [],
+        sync_jobs: [],
     };
     let autoId = { commands: 1, events: 1, migrations: 1 };
     const driver = {
@@ -93,9 +95,13 @@ export function createMemoryDriver() {
                     tables.commands.push(row);
                 return { lastInsertRowId: row.id, changes: 1 };
             }
-            // commands update status
+            // commands update status (4- or 5-placeholder variants — always take the
+            // LAST arg as command_id; older code assumed 5).
             if (s.includes("UPDATE commands SET status = ?")) {
-                const [status, error, _now, _now2, command_id] = args;
+                const argv = args;
+                const status = argv[0];
+                const error = argv[1];
+                const command_id = argv[argv.length - 1];
                 // also handles variants with retry_count increment
                 const row = tables.commands.find((r) => r.command_id === command_id);
                 if (row) {
@@ -126,10 +132,17 @@ export function createMemoryDriver() {
                 return { lastInsertRowId: 0, changes: 1 };
             }
             if (s.includes("UPDATE commands SET payload")) {
-                const [payload, command_id] = args;
+                // handles both old (payload, command_id) and new (payload, error, updated_at, command_id)
+                const payload = args[0];
+                const command_id = args[args.length - 1];
                 const row = tables.commands.find((r) => r.command_id === command_id);
-                if (row)
+                if (row) {
                     row.payload = payload;
+                    if (args.length === 4) {
+                        row.error = args[1];
+                        row.updated_at = args[2];
+                    }
+                }
                 return { lastInsertRowId: 0, changes: 1 };
             }
             // events insert
@@ -162,6 +175,101 @@ export function createMemoryDriver() {
                         row.synced_to_cloud = 1;
                 return { lastInsertRowId: 0, changes: ids.length };
             }
+            // orders insert (primary DB)
+            if (s.includes("INSERT INTO orders")) {
+                const [id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, hlc] = args;
+                const existing = tables.orders.find((r) => r.id === id);
+                // LWW check via hlc (if existing and incoming older, skip)
+                if (existing) {
+                    if (hlc && existing.hlc && hlc < existing.hlc)
+                        return { lastInsertRowId: 0, changes: 0 };
+                    Object.assign(existing, { business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, hlc });
+                    return { lastInsertRowId: 0, changes: 1 };
+                }
+                tables.orders.push({ id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, hlc, deleted_at: null });
+                return { lastInsertRowId: 1, changes: 1 };
+            }
+            // sync_jobs insert
+            if (s.includes("INSERT OR IGNORE INTO sync_jobs")) {
+                const [id, business_id, command_type, entity_id, payload, created_at, updated_at] = args;
+                if (tables.sync_jobs.find((r) => r.id === id))
+                    return { lastInsertRowId: 0, changes: 0 };
+                tables.sync_jobs.push({ id, business_id, command_type, entity_id, payload, status: "pending", attempts: 0, created_at, updated_at });
+                return { lastInsertRowId: 1, changes: 1 };
+            }
+            // sync_jobs update status=completed
+            if (s.includes("UPDATE sync_jobs SET status='completed'")) {
+                const [updated_at, id] = args;
+                const row = tables.sync_jobs.find((r) => r.id === id);
+                if (row) {
+                    row.status = "completed";
+                    row.updated_at = updated_at;
+                }
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            if (s.includes("UPDATE sync_jobs SET payload=")) {
+                const [payload, updated_at, id] = args;
+                const row = tables.sync_jobs.find((r) => r.id === id);
+                if (row) {
+                    row.payload = payload;
+                    row.updated_at = updated_at;
+                }
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            if (s.includes("UPDATE sync_jobs SET attempts = attempts + 1")) {
+                const [last_error, updated_at, id] = args;
+                const row = tables.sync_jobs.find((r) => r.id === id);
+                if (row) {
+                    row.attempts = (row.attempts ?? 0) + 1;
+                    row.last_error = last_error;
+                    row.updated_at = updated_at;
+                }
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            // orders updates
+            if (s.includes("UPDATE orders SET status = ?")) {
+                const [status, hlc, business_id, id1, id2] = args;
+                const row = tables.orders.find((r) => r.business_id === business_id && (r.id === id1 || r.order_number === id2));
+                if (row) {
+                    row.status = status;
+                    row.hlc = hlc;
+                }
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            if (s.includes("UPDATE orders SET payment = ?")) {
+                const [payment, hlc, business_id, id1, id2] = args;
+                const row = tables.orders.find((r) => r.business_id === business_id && (r.id === id1 || r.order_number === id2));
+                if (row) {
+                    row.payment = payment;
+                    row.hlc = hlc;
+                }
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            if (s.includes("UPDATE orders SET order_number=")) {
+                const [order_number, hlc, business_id, id] = args;
+                const row = tables.orders.find((r) => r.business_id === business_id && r.id === id);
+                if (row) {
+                    row.order_number = order_number;
+                    row.hlc = hlc;
+                }
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            // cleanup deletes for v7
+            if (s.includes("DELETE FROM orders WHERE order_number = '[object Object]'")) {
+                const before = tables.orders.length;
+                tables.orders = tables.orders.filter((r) => r.order_number !== "[object Object]");
+                return { lastInsertRowId: 0, changes: before - tables.orders.length };
+            }
+            if (s.includes("DELETE FROM sync_jobs WHERE payload LIKE")) {
+                const before = tables.sync_jobs.length;
+                tables.sync_jobs = tables.sync_jobs.filter((r) => !String(r.payload).includes("[object Object]"));
+                return { lastInsertRowId: 0, changes: before - tables.sync_jobs.length };
+            }
+            if (s.includes("DELETE FROM entity_snapshots WHERE payload LIKE")) {
+                const before = tables.entity_snapshots.length;
+                tables.entity_snapshots = tables.entity_snapshots.filter((r) => !String(r.payload).includes("[object Object]"));
+                return { lastInsertRowId: 0, changes: before - tables.entity_snapshots.length };
+            }
             return { lastInsertRowId: 0, changes: 0 };
         },
         async getFirstAsync(sql, ...args) {
@@ -186,6 +294,11 @@ export function createMemoryDriver() {
                 const row = tables.entity_snapshots.find((r) => r.entity_type === entity_type && r.entity_id === entity_id);
                 return (row ? { last_event_timestamp: row.last_event_timestamp } : null);
             }
+            if (s.includes("SELECT * FROM entity_snapshots WHERE entity_type = ? AND entity_id = ? AND business_id =")) {
+                const [entity_type, entity_id, business_id] = args;
+                const row = tables.entity_snapshots.find((r) => r.entity_type === entity_type && r.entity_id === entity_id && r.business_id === business_id);
+                return row ?? null;
+            }
             if (s.includes("SELECT * FROM entity_snapshots WHERE entity_type = ? AND entity_id =")) {
                 const [entity_type, entity_id] = args;
                 const row = tables.entity_snapshots.find((r) => r.entity_type === entity_type && r.entity_id === entity_id);
@@ -196,6 +309,25 @@ export function createMemoryDriver() {
                 const row = tables.commands.find((r) => r.id === id);
                 return row ?? null;
             }
+            // orders count
+            if (s.includes("SELECT COUNT(*) as c FROM orders WHERE")) {
+                const business_id = args[0];
+                const c = tables.orders.filter((r) => r.business_id === business_id).length;
+                return { c };
+            }
+            // orders get by id or order_number
+            if (s.includes("SELECT * FROM orders WHERE business_id = ? AND (id = ? OR order_number = ?)")) {
+                const [business_id, id1, id2] = args;
+                const row = tables.orders.find((r) => r.business_id === business_id && (r.id === id1 || r.order_number === id2));
+                return row ?? null;
+            }
+            // sync_jobs pending single
+            if (s.includes("SELECT * FROM sync_jobs WHERE business_id = ? AND entity_id = ? AND status='pending'")) {
+                const [business_id, entity_id] = args;
+                const row = tables.sync_jobs.find((r) => r.business_id === business_id && r.entity_id === entity_id && r.status === "pending");
+                return row ?? null;
+            }
+            // generic orders exists check for migrations backfill: SELECT * FROM orders WHERE business_id=? (not needed)
             return null;
         },
         async getAllAsync(sql, ...args) {
@@ -204,6 +336,11 @@ export function createMemoryDriver() {
                 const [business_id] = args;
                 return tables.reference_data.filter((r) => r.business_id === business_id).map((r) => ({ key: r.key }));
             }
+            if (s.includes("SELECT * FROM entity_snapshots WHERE entity_type = ? AND business_id = ? ORDER BY last_event_timestamp DESC")) {
+                const [entity_type, business_id] = args;
+                const rows = tables.entity_snapshots.filter((r) => r.entity_type === entity_type && r.business_id === business_id).sort((a, b) => (a.last_event_timestamp < b.last_event_timestamp ? 1 : -1));
+                return rows;
+            }
             if (s.includes("SELECT * FROM entity_snapshots WHERE entity_type = ? ORDER BY last_event_timestamp DESC")) {
                 const [entity_type] = args;
                 const rows = tables.entity_snapshots.filter((r) => r.entity_type === entity_type).sort((a, b) => (a.last_event_timestamp < b.last_event_timestamp ? 1 : -1));
@@ -230,6 +367,47 @@ export function createMemoryDriver() {
                     rows = rows.slice(0, limit);
                 return rows;
             }
+            // orders list with filters (simple business_id filter + pagination)
+            if (s.includes("SELECT * FROM orders WHERE")) {
+                const business_id = args[0];
+                // args includes where-clause params plus LIMIT and OFFSET at end
+                // For test, just filter by business_id and apply basic status/q if present in sql string via args slicing?
+                // Simpler: return all orders for that business, sorted by inserted_at desc, handle LIMIT/OFFSET manually
+                let rows = tables.orders.filter((r) => r.business_id === business_id);
+                // handle status filter if sql contains status IN
+                if (s.includes("status IN")) {
+                    // find args that are status values (excluding business_id, limit, offset)
+                    // Our sql: SELECT * FROM orders WHERE business_id = ? AND status IN (?,?) ... LIMIT ? OFFSET ?
+                    // So statuses are args[1]..args[?]
+                    // Count statuses by parsing SQL placeholder count?
+                    // For test, just extract known statuses from args that look like status strings
+                    const possibleStatuses = ["pending", "awaiting_payment", "accepted", "preparing", "ready", "waiting_pickup", "on_the_way", "arrived", "delivered", "cancelled", "assigned", "picked_up", "en_route", "failed"];
+                    const statusArgs = args.filter((v) => possibleStatuses.includes(String(v)));
+                    if (statusArgs.length)
+                        rows = rows.filter((r) => statusArgs.includes(r.status));
+                }
+                rows = rows.sort((a, b) => (a.inserted_at < b.inserted_at ? 1 : -1));
+                const limit = args[args.length - 2];
+                const offset = args[args.length - 1];
+                if (typeof limit === "number" && typeof offset === "number") {
+                    rows = rows.slice(offset, offset + limit);
+                }
+                return rows;
+            }
+            // sync_jobs pending list (generic, handles LIMIT 1/20)
+            if (s.includes("SELECT entity_id FROM sync_jobs") && s.includes("status='pending'")) {
+                const [business_id] = args;
+                const m = s.match(/LIMIT\s+(\d+)/);
+                const lim = m ? parseInt(m[1], 10) : 20;
+                let rows = tables.sync_jobs.filter((r) => r.business_id === business_id && r.status === "pending").sort((a, b) => (a.created_at < b.created_at ? -1 : 1)).map((r) => ({ entity_id: r.entity_id }));
+                rows = rows.slice(0, lim);
+                return rows;
+            }
+            if (s.includes("SELECT * FROM sync_jobs WHERE") || s.includes("SELECT id, command_type, status, created_at FROM sync_jobs")) {
+                const [business_id] = args;
+                const rows = tables.sync_jobs.filter((r) => r.business_id === business_id);
+                return rows;
+            }
             return [];
         },
     };

package/dist/test-helpers/seed-hours.d.ts

@@ -0,0 +1 @@
+export declare function seedOpenHours(businessId: string): Promise<void>;

package/dist/test-helpers/seed-hours.js

@@ -0,0 +1,23 @@
+/**
+ * Test helper — seeds 24/7 operating hours into SQLite reference_data.
+ * Creation is fail-closed: without cached hours every create throws
+ * HOURS_NOT_SYNCED, so tests that create orders must seed first.
+ */
+import { openSyncDatabase } from "../db/connection";
+import { setReferenceData } from "../reference/operations";
+export async function seedOpenHours(businessId) {
+    const db = await openSyncDatabase();
+    const entries = Array.from({ length: 7 }, (_, dayOfWeek) => ({
+        day_of_week: dayOfWeek,
+        // "24:00:00" close keeps string-compare open for the whole UTC day.
+        open_time: "00:00:00",
+        close_time: "24:00:00",
+        is_closed: false,
+    }));
+    await setReferenceData(db, businessId, {
+        key: "operating-hours",
+        version: "test-open",
+        payload: { data: entries },
+        downloadedAt: new Date().toISOString(),
+    });
+}

package/dist/types/api/business.api.d.ts

@@ -8,6 +8,8 @@ export interface Business {
     status: string;
     currency: string;
     is_open: boolean;
+    /** Seller-facing open/close toggle (present when backend serializes it). */
+    manually_closed?: boolean;
     owner_id: string;
     business_number: string;
     latitude: number;
@@ -135,3 +137,43 @@ export interface TaxRuleRequest {
         display_order?: number;
     };
 }
+export interface BusinessMemberInvitation {
+    id: string;
+    business_id: string;
+    invited_email: string;
+    role: string;
+    status: string;
+    expires_at: string;
+    inserted_at: string;
+    invited_by?: {
+        id: string;
+        full_name: string;
+        email: string;
+    } | null;
+}
+export interface BusinessMemberInvitationListResponse {
+    data: BusinessMemberInvitation[];
+}
+export interface UserInvitation {
+    id: string;
+    type: 'business_owner' | 'fleet_rider' | 'business_member' | 'rider_linked';
+    status: string;
+    business_name: string | null;
+    business_id: string | null;
+    code: string | null;
+    role?: string;
+    is_fleet_managed: boolean;
+    created_at: string | null;
+}
+export interface RoleCapabilityItem {
+    key: string;
+    label: string;
+    description?: string;
+}
+export interface RoleCapability {
+    label: string;
+    capabilities: RoleCapabilityItem[];
+}
+export interface RolesResponse {
+    data: Record<string, RoleCapability>;
+}

package/dist/types/api/menu.api.d.ts

@@ -78,13 +78,28 @@ export interface CatalogItemRequest {
     currency_code: string;
     dietary_tags?: string[];
     variants: {
+        id?: string;
         name: string;
         price_adjustment: number;
     }[];
     extras: {
+        id?: string;
         name: string;
         price_minor: number;
     }[];
     available: boolean;
     image_url?: string | null;
 }
+/** menu:create_item / menu:update_item command payload. */
+export interface MenuItemCommandPayload extends CatalogItemRequest {
+    cacheRecord: MenuItem;
+}
+/** menu:create_category / menu:update_category command payload. */
+export interface MenuCategoryCommandPayload {
+    name: string;
+    description?: string;
+    sort_order?: number;
+    categoryId?: string;
+    id?: string;
+    cacheRecord: MenuCategory;
+}