@teincfood/core 0.7.7 → 0.7.9

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

@@ -36,6 +36,7 @@ const QUEUED_STATUS_EVENT_TYPES = new Set([
     "delivery.assign_queued",
     "delivery.confirm_handover_queued",
 ]);
+const PAYMENT_QUEUED_TYPES = new Set(["payment.completed_queued"]);
 let invalidator = null;
 /**
  * Register a callback used to invalidate TanStack Query caches when a pending
@@ -99,8 +100,12 @@ export async function hydratePendingOrders() {
 export async function applyOrderStateChangeEvent(event, origin = "local") {
     try {
         const isQueued = QUEUED_STATUS_EVENT_TYPES.has(event.event_type);
-        if (!ORDER_STATE_EVENT_TYPES.has(event.event_type) && !isQueued)
-            return;
+        const isPaymentQueued = PAYMENT_QUEUED_TYPES.has(event.event_type);
+        if (!ORDER_STATE_EVENT_TYPES.has(event.event_type) && !isQueued && !isPaymentQueued) {
+            // Also handle cloud payment.completed for is_paid patch
+            if (event.event_type !== "payment.completed")
+                return;
+        }
         syncLogger.debug("OrderState", "Order state changed", {
             origin,
             event_type: event.event_type,
@@ -111,6 +116,19 @@ export async function applyOrderStateChangeEvent(event, origin = "local") {
         // Queued transitions carry to_status/order_id so they patch instantly offline.
         if (isQueued) {
             await orderSnapshotsService.applyQueuedStatusEvent(event, origin);
+            patchPendingStatus(event);
+            invalidator?.();
+            return;
+        }
+        if (isPaymentQueued) {
+            await orderSnapshotsService.applyPaymentEvent(event, origin);
+            patchPendingPaid(event);
+            invalidator?.();
+            return;
+        }
+        if (event.event_type === "payment.completed") {
+            await orderSnapshotsService.applyPaymentEvent(event, origin);
+            patchPendingPaid(event);
             invalidator?.();
             return;
         }
@@ -124,6 +142,46 @@ export async function applyOrderStateChangeEvent(event, origin = "local") {
         });
     }
 }
+function patchPendingStatus(event) {
+    try {
+        const payload = event.payload;
+        const toStatus = payload.to_status || payload.status;
+        const orderId = payload.order_id || event.entity_id;
+        if (!toStatus || !orderId)
+            return;
+        const store = usePendingOrdersStore.getState();
+        const target = store.orders.find((o) => o.id === orderId || o.order_number === orderId);
+        if (!target)
+            return;
+        const patched = { ...target, status: toStatus };
+        store.addOrder(patched);
+    }
+    catch { }
+}
+function patchPendingPaid(event) {
+    try {
+        const payload = event.payload;
+        const orderId = payload.order_id || event.entity_id;
+        if (!orderId)
+            return;
+        const now = new Date().toISOString();
+        const store = usePendingOrdersStore.getState();
+        const target = store.orders.find((o) => o.id === orderId || o.order_number === payload.order_number || o.id === event.entity_id);
+        const altTarget = !target ? store.orders.find((o) => o.id === orderId) : null;
+        const t = target ?? altTarget;
+        if (!t)
+            return;
+        const paidAt = payload.paid_at || now;
+        const patched = {
+            ...t,
+            is_paid: true,
+            paid_at: paidAt,
+            payment: { ...t.payment, is_paid: true, paid_at: paidAt },
+        };
+        store.addOrder(patched);
+    }
+    catch { }
+}
 export async function applyPendingOrderEvent(event, origin = "local") {
     try {
         if (event.event_type === PENDING_EVENT_TYPE) {
@@ -144,6 +202,27 @@ export async function applyPendingOrderEvent(event, origin = "local") {
         if (QUEUED_STATUS_EVENT_TYPES.has(event.event_type)) {
             // Queued transitions: patch the read model so listing reflects new status offline.
             await orderSnapshotsService.applyQueuedStatusEvent(event, origin);
+            // Also patch pending store so isPending overlay shows new status immediately.
+            try {
+                const payload = event.payload;
+                const toStatus = payload.to_status || payload.status;
+                const orderId = payload.order_id || event.entity_id;
+                if (toStatus && orderId) {
+                    const store = usePendingOrdersStore.getState();
+                    const target = store.orders.find((o) => o.id === orderId || o.order_number === orderId);
+                    if (target)
+                        store.addOrder({ ...target, status: toStatus });
+                }
+            }
+            catch { }
+            const db = await openSyncDatabase();
+            await insertEvent(db, { event, origin });
+            invalidator?.();
+            return;
+        }
+        if (PAYMENT_QUEUED_TYPES.has(event.event_type) || event.event_type === "payment.completed") {
+            await orderSnapshotsService.applyPaymentEvent(event, origin);
+            patchPendingPaid(event);
             const db = await openSyncDatabase();
             await insertEvent(db, { event, origin });
             invalidator?.();

package/dist/sync/transport-rest.js

@@ -50,11 +50,12 @@ export class RestTransport {
             case "order:create": {
                 const posPayload = {
                     ...payload,
+                    id: command.command_id,
                     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);
+                return this.wrapResponse("order.created", response.data, entity_id ?? command.command_id, timestamp, command);
             }
             case "order:accept": {
                 const response = await sellerService.acceptOrder(entity_id);
@@ -89,8 +90,9 @@ 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);
+                const createPayload = { ...payload, id: payload.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);
@@ -101,8 +103,13 @@ 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 createPayload = { ...payload, id: payload.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 "payment:confirm_cash": {
+                const response = await sellerService.confirmCashPayment(entity_id);
+                return this.wrapResponse("payment.completed", response, entity_id, timestamp, command);
             }
             default:
                 throw new Error(`RestTransport: unsupported command type ${command_type}`);

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

@@ -10,6 +10,7 @@
 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";
@@ -24,16 +25,42 @@ 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 });
+            }
+            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 });
+            }
+            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 +69,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
@@ -90,15 +121,12 @@ 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");
             }
         });
         return () => {
+            if (timer)
+                clearTimeout(timer);
             unsubscribe();
             unregisterInvalidator();
             unregisterReferenceInvalidator();

package/package.json

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