@teincfood/core 0.10.8 → 0.10.10

package/dist/adapters/pending-orders.d.ts

@@ -14,6 +14,13 @@ export declare const usePendingOrdersStore: {
         hydrated: boolean;
         orders: SellerOrder[];
         addOrder: (order: SellerOrder) => void;
+        /**
+         * Replace an existing pending order in place. Used for queued
+         * transitions/payments so the optimistic overlay reflects the new state
+         * immediately. Unknown orders are ignored (a transition must never
+         * resurrect an order that was already reconciled).
+         */
+        updateOrder: (order: SellerOrder) => void;
         removeByOrderNumber: (orderNumber: string) => void;
         removeByOrderId: (orderId: string) => void;
         setHydrated: (v: boolean) => void;

package/dist/adapters/pending-orders.js

@@ -30,6 +30,25 @@ export const usePendingOrdersStore = {
                 notify();
             }
         },
+        /**
+         * Replace an existing pending order in place. Used for queued
+         * transitions/payments so the optimistic overlay reflects the new state
+         * immediately. Unknown orders are ignored (a transition must never
+         * resurrect an order that was already reconciled).
+         */
+        updateOrder: (order) => {
+            const index = orders.findIndex((o) => o.id === order.id || o.order_number === order.order_number);
+            if (index === -1)
+                return;
+            const current = orders[index];
+            if (current.status === order.status &&
+                current.is_paid === order.is_paid &&
+                current.paid_at === order.paid_at) {
+                return;
+            }
+            orders = orders.map((o, i) => (i === index ? order : o));
+            notify();
+        },
         removeByOrderNumber: (orderNumber) => {
             const next = orders.filter((o) => o.order_number !== orderNumber);
             if (next.length !== orders.length) {

package/dist/db/operations.d.ts

@@ -112,6 +112,15 @@ export declare function upsertServerOrder(db: SQLiteDatabase, order: import("../
     preserveStatus?: boolean;
     preservePayment?: boolean;
 }): Promise<void>;
+/**
+ * Recent orders plus their local HLC, for LAN catch-up.
+ *
+ * The HLC must travel with the row: `insertOrder` is HLC-guarded, so a peer
+ * replaying an older snapshot can never overwrite a newer local status.
+ */
+export declare function listOrdersWithHlc(db: SQLiteDatabase, businessId: string, limit?: number): Promise<Array<import("../types/api/seller.api").SellerOrder & {
+    hlc?: string;
+}>>;
 export declare function listOrders(db: SQLiteDatabase, businessId: string, filters?: {
     status?: string;
     q?: string;

package/dist/db/operations.js

@@ -376,6 +376,19 @@ export async function upsertServerOrder(db, order, opts = {}) {
      ON CONFLICT(id) DO UPDATE SET business_id=excluded.business_id, order_number=excluded.order_number, callout_number=excluded.callout_number, status=excluded.status, order_type=excluded.order_type, is_pos=excluded.is_pos, items=excluded.items, subtotal_minor=excluded.subtotal_minor, total_minor=excluded.total_minor, tax_minor=excluded.tax_minor, tax_lines=excluded.tax_lines, payment=excluded.payment, paid_at=COALESCE(excluded.paid_at, orders.paid_at), customer_name=excluded.customer_name, customer_phone=excluded.customer_phone, pos_payment_method=excluded.pos_payment_method, delivery_id=excluded.delivery_id, business=excluded.business, user=excluded.user, updated_at=excluded.updated_at, hlc=excluded.hlc, sync_failed_at=NULL, sync_error=NULL;`, order.id, order.business_id, order.order_number, order.callout_number, status, order.order_type, order.is_pos ? 1 : 0, JSON.stringify(order.items ?? []), order.subtotal_minor ?? 0, order.total_minor ?? 0, order.tax_minor ?? 0, JSON.stringify(order.tax_lines ?? []), JSON.stringify(payment), paidAt, order.customer_name, order.customer_phone, order.pos_payment_method, order.delivery_id, order.business ? JSON.stringify(order.business) : null, order.user ? JSON.stringify(order.user) : null, order.inserted_at, updatedAt, hlc);
     notifyDbChange(order.business_id, "orders");
 }
+/**
+ * Recent orders plus their local HLC, for LAN catch-up.
+ *
+ * The HLC must travel with the row: `insertOrder` is HLC-guarded, so a peer
+ * replaying an older snapshot can never overwrite a newer local status.
+ */
+export async function listOrdersWithHlc(db, businessId, limit = 200) {
+    const rows = await db.getAllAsync(`SELECT * FROM orders WHERE business_id = ? AND deleted_at IS NULL ORDER BY inserted_at DESC LIMIT ?;`, businessId, limit);
+    return rows.map((row) => ({
+        ...orderRowToSellerOrder(row),
+        hlc: row.hlc ?? row.updated_at ?? row.inserted_at,
+    }));
+}
 export async function listOrders(db, businessId, filters, page = 1, pageSize = 20) {
     const where = ["business_id = ?"];
     const args = [businessId];

package/dist/hooks/orders.hooks.d.ts

@@ -22,7 +22,7 @@ export interface SellerOrderFilters {
     date_to?: string;
 }
 export declare function useSellerOrdersQuery(enabled?: boolean, filters?: SellerOrderFilters): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error>;
-export declare function useSellerOrderQuery(orderId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
+export declare function useSellerOrderQuery(orderId: string, enabled?: boolean, placeholder?: SellerOrder | null): import("@tanstack/react-query").UseQueryResult<{
     data: SellerOrder;
 }, Error>;
 export declare function useCreatePOSOrderMutation(): import("@tanstack/react-query").UseMutationResult<SellerOrder, Error, POSOrderCreateRequest, unknown>;

package/dist/hooks/orders.hooks.js

@@ -81,7 +81,7 @@ export function useSellerOrdersQuery(enabled = true, filters) {
         select: (data) => data.pages.flatMap((p) => p.data),
     });
 }
-export function useSellerOrderQuery(orderId, enabled = true) {
+export function useSellerOrderQuery(orderId, enabled = true, placeholder) {
     const bid = useBusinessId();
     return useQuery({
         queryKey: SELLER_KEYS.order(orderId, bid),
@@ -94,6 +94,12 @@ export function useSellerOrderQuery(orderId, enabled = true) {
             return { data: order };
         },
         enabled: enabled && !!orderId && !!bid,
+        // The order list already has the full row. Seed the dialog with it so
+        // opening details is instant; the DB read still runs and replaces it.
+        placeholderData: placeholder ? { data: placeholder } : undefined,
+        // Local SQLite reads cannot recover from a transient network error; a
+        // missing row should surface immediately instead of retrying for seconds.
+        retry: false,
         staleTime: 5 * 1000,
     });
 }

package/dist/local-node/service.d.ts

@@ -24,6 +24,18 @@ declare class LocalNodeServiceCore {
     init(deps: LocalNodeDeps): void;
     private requestReferenceFromPeers;
     private requestAssetFromPeers;
+    /**
+     * Catch a newly connected peer up on orders created while the mesh was not
+     * connected (e.g. a sale rung up before Local Node was enabled).
+     *
+     * Live order events only cover changes that happen *after* the socket is
+     * up. Without this handshake a pre-existing offline sale stayed invisible
+     * on the other terminal forever. Both sides call this on connect; the
+     * cooldown dedupes the inbound/outbound callbacks for the same peer.
+     */
+    private orderCatchupAt;
+    private static readonly ORDER_CATCHUP_COOLDOWN_MS;
+    private publishOrderCatchup;
     private getDeps;
     private getDeviceId;
     private runLifecycle;

package/dist/local-node/service.js

@@ -12,7 +12,9 @@ import { REFERENCE_CHANGED_EVENT_TYPE } from "../reference/events";
 import { applyReferenceChangeEvent } from "../reference/events";
 import { referenceSyncService } from "../reference/service";
 import { openSyncDatabase } from "../db/connection";
-import { insertOrder } from "../db/operations";
+import { getUnsyncedEvents, insertOrder, listOrdersWithHlc } from "../db/operations";
+import { getPendingOrdersSnapshot } from "../adapters/pending-orders";
+import { generateEventId } from "../utils/uuid";
 import { createLocalOrder, transitionLocalOrder } from "../domain/orders/service";
 import { getConnectivityState } from "../adapters/connectivity";
 import { deriveLanSecret as deriveSecretCore } from "./security";
@@ -46,6 +48,16 @@ class LocalNodeServiceCore {
         this.published = false;
         /** Whether discovery scanning was successfully started. */
         this.discovering = false;
+        /**
+         * Catch a newly connected peer up on orders created while the mesh was not
+         * connected (e.g. a sale rung up before Local Node was enabled).
+         *
+         * Live order events only cover changes that happen *after* the socket is
+         * up. Without this handshake a pre-existing offline sale stayed invisible
+         * on the other terminal forever. Both sides call this on connect; the
+         * cooldown dedupes the inbound/outbound callbacks for the same peer.
+         */
+        this.orderCatchupAt = new Map();
         this.storeUnsub = null;
         this.dialInFlight = new Set();
         this.dialTimers = new Map();
@@ -89,6 +101,74 @@ class LocalNodeServiceCore {
         }
         return null;
     }
+    async publishOrderCatchup(peerDeviceId) {
+        if (!this.businessId)
+            return;
+        const now = Date.now();
+        const last = this.orderCatchupAt.get(peerDeviceId) ?? 0;
+        if (now - last < LocalNodeServiceCore.ORDER_CATCHUP_COOLDOWN_MS)
+            return;
+        this.orderCatchupAt.set(peerDeviceId, now);
+        try {
+            const db = await openSyncDatabase();
+            const rows = await listOrdersWithHlc(db, this.businessId, 200);
+            const byId = new Map();
+            for (const order of rows)
+                byId.set(order.id, order);
+            // Queued offline creations have no `orders` row yet; they live in the
+            // pending overlay and the durable event journal. Include both so a
+            // pre-linkup sale is shared even after an app restart.
+            for (const origin of ["local", "lan"]) {
+                const events = await getUnsyncedEvents(db, origin, Number.MAX_SAFE_INTEGER);
+                for (const event of events) {
+                    if (event.event_type !== "order.create_queued")
+                        continue;
+                    const order = event.payload;
+                    if (order?.id && order.order_number)
+                        byId.set(order.id, order);
+                }
+            }
+            for (const order of getPendingOrdersSnapshot().orders) {
+                if (order.business_id === this.businessId)
+                    byId.set(order.id, order);
+            }
+            const peer = this.peers.get(peerDeviceId);
+            const canTarget = !!peer?.isConnected() && typeof peer.publishEvent === "function";
+            for (const order of byId.values()) {
+                if (!order?.id || !order.order_number)
+                    continue;
+                const event = {
+                    event_id: generateEventId(),
+                    event_type: "order:sync",
+                    event_version: "1",
+                    entity_id: order.id,
+                    user_id: "",
+                    device_id: this.cachedDeviceId ?? "",
+                    payload: order,
+                    timestamp: order.updated_at ?? order.inserted_at ?? new Date().toISOString(),
+                };
+                if (canTarget) {
+                    await peer.publishEvent(event);
+                }
+                else {
+                    this.server?.broadcast(event);
+                }
+            }
+            syncLogger.info("LocalNodeService", "Order catch-up published", {
+                peer: peerDeviceId,
+                orders: byId.size,
+                targeted: canTarget,
+            });
+        }
+        catch (error) {
+            syncLogger.warn("LocalNodeService", "Order catch-up failed", {
+                peer: peerDeviceId,
+                error: String(error),
+            });
+            // Allow a later reconnect to retry after a transient DB/socket failure.
+            this.orderCatchupAt.delete(peerDeviceId);
+        }
+    }
     getDeps() {
         if (!this.deps)
             throw new Error("LocalNodeService not initialised: call initLocalNodeService(deps) first");
@@ -200,6 +280,7 @@ class LocalNodeServiceCore {
             catch { }
         this.peers.clear();
         this.peerInfos.clear();
+        this.orderCatchupAt.clear();
         if (this.server) {
             await withTimeout(this.server.stop(), LIFECYCLE_TIMEOUT_MS).catch((e) => syncLogger.warn("LocalNodeService", "Server stop timed out", { error: String(e) }));
             this.server = null;
@@ -359,6 +440,9 @@ class LocalNodeServiceCore {
             onClientConnected: (info) => {
                 localNodeStore.getState().addConnectedClient({ deviceId: info.deviceId, deviceName: info.deviceName, host: info.host, connectedAt: new Date().toISOString() });
                 syncLogger.info("LocalNodeService", "Client connected", { deviceId: info.deviceId, connected_clients: localNodeStore.getState().connectedClients.length });
+                // Inbound connect: push this node's pre-existing orders to the new
+                // peer (covers mDNS asymmetry where only one side dials).
+                void this.publishOrderCatchup(info.deviceId);
             },
             onClientDisconnected: (deviceId) => {
                 localNodeStore.getState().removeConnectedClient(deviceId);
@@ -602,6 +686,8 @@ class LocalNodeServiceCore {
                 syncLogger.info("LocalNodeService", "Connected to peer", { deviceId: node.deviceId });
                 this.peerInfos.set(node.deviceId, { deviceId: node.deviceId, host: node.host, port: node.port });
                 localNodeStore.getState().addConnectedClient({ deviceId: node.deviceId, deviceName: node.deviceName, host: node.host, connectedAt: new Date().toISOString() });
+                // Outbound connect: push orders created before this socket existed.
+                void this.publishOrderCatchup(node.deviceId);
                 // A terminal may have missed `reference_data.changed` while it was
                 // disconnected. Compare versions with the peer on reconnect so menu,
                 // members, hours and tax changes converge even on a dark LAN.
@@ -817,6 +903,7 @@ class LocalNodeServiceCore {
     }
     getState() { return { isLocalNode: this.isLocalNode(), isConnectedToNode: this.isConnectedToNode(), electedNode: this.getElectedNode(), client: this.getClient() }; }
 }
+LocalNodeServiceCore.ORDER_CATCHUP_COOLDOWN_MS = 10000;
 LocalNodeServiceCore.MISMATCH_BACKOFF_MS = 60000;
 export const localNodeService = new LocalNodeServiceCore();
 export function initLocalNodeService(deps) { localNodeService.init(deps); return localNodeService; }

package/dist/sync/command-queue.service.js

@@ -18,6 +18,7 @@ import { assertBusinessOpenForCreate } from "../utils/business-hours";
 import { extractApiErrorCode } from "../utils/error";
 import { generateEventId } from "../utils/uuid";
 import { buildItemSnapshots, snapshotsToOrderLines } from "../domain/orders/snapshots";
+import { DEFAULT_ORDER_FLOW_MODE, getBusinessOrderFlowMode, initialPosOrderStatus, } from "../domain/orders/order-flow";
 import { generateLocalCalloutNumber, generateOrderNumberForBusiness, generateOrderNumber, } from "./order-number";
 import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
 import { canBusinessSync } from "./sync-guard";
@@ -53,7 +54,7 @@ const PAYMENT_QUEUED_PAYLOAD = {
 export function getQueuedStatus(commandType) {
     return QUEUED_STATUS_BY_COMMAND[commandType] ?? null;
 }
-function buildOptimisticEvent(command) {
+function buildOptimisticEvent(command, flowMode = DEFAULT_ORDER_FLOW_MODE) {
     const payload = command.payload;
     if (command.command_type === "order:create") {
         return {
@@ -63,7 +64,7 @@ function buildOptimisticEvent(command) {
             entity_id: command.entity_id ?? command.command_id,
             user_id: command.user_id,
             device_id: command.device_id,
-            payload: buildOptimisticOrder(command, payload),
+            payload: buildOptimisticOrder(command, payload, flowMode),
             timestamp: new Date().toISOString(),
         };
     }
@@ -77,6 +78,7 @@ function buildOptimisticEvent(command) {
             device_id: command.device_id,
             payload: {
                 ...payload,
+                business_id: command.business_id,
                 command_id: command.command_id,
                 is_paid: true,
                 paid_at: new Date().toISOString(),
@@ -95,6 +97,9 @@ function buildOptimisticEvent(command) {
         device_id: command.device_id,
         payload: {
             ...payload,
+            // Required by the offline read-model patch so queued transitions update
+            // the canonical orders table (not just seller_orders snapshots).
+            business_id: command.business_id,
             command_id: command.command_id,
             status: "pending",
             // Used by offline read-model patching so the list reflects the queued transition.
@@ -106,7 +111,7 @@ function buildOptimisticEvent(command) {
         timestamp: new Date().toISOString(),
     };
 }
-function buildOptimisticOrder(command, payload) {
+function buildOptimisticOrder(command, payload, flowMode) {
     const snapshots = buildItemSnapshots((payload.item_snapshots ?? payload.items ?? []));
     const totalMinor = payload.total_minor ?? 0;
     const subtotalMinor = payload.subtotal_minor ?? totalMinor;
@@ -114,6 +119,8 @@ function buildOptimisticOrder(command, payload) {
     const taxLines = payload.tax_lines ?? [];
     const currencyCode = payload.currency_code ?? "GHS";
     const now = new Date().toISOString();
+    const method = payload.pos_payment_method ?? "cash";
+    const isCash = method === "cash";
     const orderNumber = payload.order_number ?? generateOrderNumberForBusiness(command.business_id);
     return {
         id: command.entity_id ?? command.command_id,
@@ -123,20 +130,23 @@ function buildOptimisticOrder(command, payload) {
         is_pos: true,
         customer_name: payload.customer_name ?? null,
         customer_phone: payload.customer_phone ?? null,
-        pos_payment_method: payload.pos_payment_method ?? "cash",
-        paid_at: null,
-        status: "accepted",
+        pos_payment_method: method,
+        paid_at: isCash ? now : null,
+        // Must match createLocalOrder: direct-flow cash sales are born delivered,
+        // even when the command is parked in the offline outbox. Hardcoding
+        // "accepted" made a completed sale show up on the preparing board.
+        status: initialPosOrderStatus(method, flowMode),
         delivery_id: null,
         delivery_status: null,
-        is_paid: payload.pos_payment_method === "cash",
+        is_paid: isCash,
         payment: {
-            is_paid: payload.pos_payment_method === "cash",
+            is_paid: isCash,
             reference: null,
             amount_minor: totalMinor,
             currency: currencyCode,
-            paid_at: payload.pos_payment_method === "cash" ? now : null,
+            paid_at: isCash ? now : null,
         },
-        payment_mode: "pos_cash",
+        payment_mode: isCash ? "pos_cash" : "prepaid",
         total_minor: totalMinor,
         subtotal_minor: subtotalMinor,
         delivery_fee_minor: payload.delivery_fee_minor ?? 0,
@@ -268,7 +278,13 @@ class CommandQueueService {
             order_number: preparedCommand.payload.order_number ?? null,
             outbox_size: pending.length,
         });
-        const event = buildOptimisticEvent(preparedCommand);
+        // Direct-flow cash sales are complete on creation. The optimistic order
+        // must use the same cached business setting as createLocalOrder, otherwise
+        // an offline direct sale appears as "accepted" and offers kitchen steps.
+        const flowMode = preparedCommand.command_type === "order:create"
+            ? await getBusinessOrderFlowMode(preparedCommand.business_id)
+            : DEFAULT_ORDER_FLOW_MODE;
+        const event = buildOptimisticEvent(preparedCommand, flowMode);
         syncLogger.info("CommandQueueService", "Optimistic event built", {
             event_type: event.event_type,
             entity_id: event.entity_id,

package/dist/sync/pending-orders.service.js

@@ -220,7 +220,7 @@ function patchPendingStatus(event) {
         if (!target)
             return;
         const patched = { ...target, status: toStatus };
-        store.addOrder(patched);
+        store.updateOrder(patched);
     }
     catch { }
 }
@@ -244,7 +244,7 @@ function patchPendingPaid(event) {
             paid_at: paidAt,
             payment: { ...t.payment, is_paid: true, paid_at: paidAt },
         };
-        store.addOrder(patched);
+        store.updateOrder(patched);
     }
     catch { }
 }
@@ -277,7 +277,7 @@ export async function applyPendingOrderEvent(event, origin = "local") {
                     const store = usePendingOrdersStore.getState();
                     const target = store.orders.find((o) => o.id === orderId || o.order_number === orderId);
                     if (target)
-                        store.addOrder({ ...target, status: toStatus });
+                        store.updateOrder({ ...target, status: toStatus });
                 }
             }
             catch { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teincfood/core",
-  "version": "0.10.8",
+  "version": "0.10.10",
   "description": "TeincFood shared offline-first core — types, sync engine, local DB, reference data, and repositories for mobile + desktop",
   "type": "module",
   "main": "dist/index.js",