@teincfood/core 0.7.8 → 0.8.0

package/dist/sync/order-number.js

@@ -16,23 +16,37 @@ function cryptoRandom100to999() {
     }
     return 100 + Math.floor(Math.random() * 900);
 }
-function getNextCallout() {
-    const stored = getItem(CALLOUT_SEQ_KEY);
+function calloutKeyForBusiness(businessId) {
+    return businessId ? `${CALLOUT_SEQ_KEY}:${businessId}` : CALLOUT_SEQ_KEY;
+}
+function getNextCallout(businessId) {
+    const key = calloutKeyForBusiness(businessId);
+    const stored = getItem(key);
     let next = (stored ?? 0) + 1;
     if (next > 999)
         next = 1;
-    setItem(CALLOUT_SEQ_KEY, next);
+    setItem(key, next);
+    // migrate legacy global once: keep global in sync for backward compat
+    if (businessId) {
+        const legacy = getItem(CALLOUT_SEQ_KEY) ?? 0;
+        if (legacy < next)
+            setItem(CALLOUT_SEQ_KEY, next);
+    }
     return next;
 }
-export function peekCallout() {
-    const stored = getItem(CALLOUT_SEQ_KEY);
-    return stored ?? 0;
+export function peekCallout(businessId) {
+    const key = calloutKeyForBusiness(businessId);
+    const v = getItem(key);
+    if (v != null)
+        return v;
+    const legacy = getItem(CALLOUT_SEQ_KEY);
+    return legacy ?? 0;
 }
-export function generateOrderNumber(deviceNumber) {
+export function generateOrderNumber(deviceNumber, businessId) {
     if (!/^(0[1-9]|[1-9][0-9])$/.test(deviceNumber)) {
         throw new Error(`Invalid deviceNumber ${deviceNumber} — must be 01-99`);
     }
-    const callout = getNextCallout();
+    const callout = getNextCallout(businessId);
     let random = cryptoRandom100to999();
     // On wrap to 001, ensure new random (already new per order, but keep hook)
     if (callout === 1) {
@@ -53,11 +67,11 @@ export function generateOrderNumberForBusiness(businessId) {
     if (!v || !/^(0[1-9]|[1-9][0-9])$/.test(v)) {
         throw new Error(`No device lease for business ${businessId} — call ensureLease(businessId) first (online-only until leased)`);
     }
-    return generateOrderNumber(v).orderNumber;
+    return generateOrderNumber(v, businessId).orderNumber;
 }
-export function generateLocalCalloutNumber() {
-    // kept for SellerOrder.callout_number compatibility — returns CCC
-    const next = peekCallout() + 1;
+export function generateLocalCalloutNumber(businessId) {
+    // kept for SellerOrder.callout_number compatibility — returns next CCC
+    const next = peekCallout(businessId) + 1;
     return next > 999 ? 1 : next;
 }
 // New canonical check — unified for DD-RRR-CCC
@@ -74,6 +88,12 @@ export function parseOrderNumber(orderNumber) {
     return { deviceNumber: m[1], random: m[2], callout: m[3] };
 }
 // Test helpers
-export function resetCalloutForTests() {
+export function resetCalloutForTests(businessId) {
+    if (businessId) {
+        setItem(calloutKeyForBusiness(businessId), 0);
+        return;
+    }
     setItem(CALLOUT_SEQ_KEY, 0);
+    // also clear per-business keys that tests may have touched
+    // caller should pass businessId if they used business-scoped sequences
 }

package/dist/sync/order-snapshots.service.d.ts

@@ -29,6 +29,7 @@ declare class OrderSnapshotsService {
      */
     applyQueuedStatusEvent(event: DomainEvent, origin?: "local" | "lan" | "cloud"): Promise<void>;
     private applyOrderStatusToReadModelInternal;
+    applyPaymentEvent(event: DomainEvent, origin?: "local" | "lan" | "cloud"): Promise<void>;
     /**
      * Patch the latest status of a known order inside every list snapshot for the
      * business, so offline devices see live status changes without a refetch.

package/dist/sync/order-snapshots.service.js

@@ -74,7 +74,19 @@ class OrderSnapshotsService {
     }
     async applyOrderStatusToReadModelInternal(db, orderId, toStatus, event) {
         try {
-            const lists = await getEntitySnapshotsByType(db, "seller_orders");
+            const payload = event.payload;
+            const businessId = payload?.business_id ?? payload?.businessId ?? null;
+            // Dual-write: keep canonical orders table in sync so POS/KDS reads converge instantly.
+            if (businessId) {
+                try {
+                    const { updateOrderStatus } = await import("../db/operations");
+                    await updateOrderStatus(db, businessId, orderId, toStatus, event.timestamp);
+                }
+                catch { }
+            }
+            const lists = businessId
+                ? await getEntitySnapshotsByType(db, "seller_orders", businessId)
+                : await getEntitySnapshotsByType(db, "seller_orders");
             for (const list of lists) {
                 const data = list.payload.data ?? [];
                 const idx = data.findIndex((o) => o.id === orderId);
@@ -97,6 +109,39 @@ class OrderSnapshotsService {
             });
         }
     }
+    async applyPaymentEvent(event, origin = "local") {
+        const payload = event.payload;
+        const orderId = payload?.order_id ?? event.entity_id;
+        if (!orderId)
+            return;
+        const paidAt = payload?.paid_at || new Date().toISOString();
+        try {
+            const db = await openSyncDatabase();
+            await insertEvent(db, { event, origin });
+            const businessId = payload?.business_id ?? payload?.businessId ?? null;
+            const lists = businessId
+                ? await getEntitySnapshotsByType(db, "seller_orders", businessId)
+                : await getEntitySnapshotsByType(db, "seller_orders");
+            for (const list of lists) {
+                const data = list.payload.data ?? [];
+                const idx = data.findIndex((o) => o.id === orderId || o.order_number === payload?.order_number);
+                if (idx === -1)
+                    continue;
+                const updated = data.map((o, i) => i === idx ? { ...o, is_paid: true, paid_at: paidAt, payment: { ...o.payment, is_paid: true, paid_at: paidAt } } : o);
+                await upsertEntitySnapshot(db, {
+                    entityType: "seller_orders",
+                    entityId: list.entity_id,
+                    businessId: list.business_id,
+                    lastEventId: event.event_id,
+                    lastEventTimestamp: event.timestamp,
+                    payload: { ...list.payload, data: updated },
+                });
+            }
+        }
+        catch (error) {
+            syncLogger.error("OrderSnapshots", "Failed to apply payment", { error: String(error) });
+        }
+    }
     /**
      * Patch the latest status of a known order inside every list snapshot for the
      * business, so offline devices see live status changes without a refetch.
@@ -143,7 +188,7 @@ class OrderSnapshotsService {
     async getSellerList(businessId, scope) {
         try {
             const db = await openSyncDatabase();
-            const snap = await getEntitySnapshot(db, "seller_orders", scope);
+            const snap = await getEntitySnapshot(db, "seller_orders", scope, businessId);
             if (!snap || snap.business_id !== businessId)
                 return null;
             return snap.payload.data ?? null;

package/dist/sync/pending-orders.service.d.ts

@@ -15,11 +15,29 @@
  * order's `order_number`.
  */
 import type { DomainEvent } from "./types";
+import type { SellerOrder } from "../types/api/seller.api";
 /**
  * Register a callback used to invalidate TanStack Query caches when a pending
  * order is reconciled. Returns an unregister function.
  */
 export declare function registerPendingOrdersInvalidator(fn: () => void): () => void;
+/**
+ * Fire the registered query invalidator (lists refetch from SQLite).
+ * Used after LAN-applied writes (order:sync) that bypass the engine event
+ * pipeline, so peers' UIs converge without waiting for a cloud echo.
+ */
+export declare function notifyPendingOrdersChanged(): void;
+/**
+ * Merge optimistic (queued, unconfirmed) state into a page of listed orders.
+ * Called by list queryFns (page 1 only) so offline work is visible:
+ *  1. Pending creations (order.create_queued, local or LAN) missing from the
+ *     SQLite page are prepended — deduped by id/order_number.
+ *  2. Queued transitions only patch the snapshot read model, never the
+ *     orders table — overlay snapshot statuses onto base rows so the list
+ *     reflects the queued status immediately (converges on replay).
+ * Reactivity comes from the invalidator: every apply path above refetches.
+ */
+export declare function mergePendingIntoList(base: SellerOrder[], businessId: string, page: number): Promise<SellerOrder[]>;
 /**
  * Load persisted unsynced order:create_queued events into the store.
  * Idempotent; safe to call after app restart while still offline.

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

@@ -15,7 +15,7 @@
  * order's `order_number`.
  */
 import { openSyncDatabase } from "../db/connection";
-import { insertEvent, getUnsyncedEvents, markEventsSynced, } from "../db/operations";
+import { insertEvent, getUnsyncedEvents, markEventsSynced, getEntitySnapshotsByType, } from "../db/operations";
 import { usePendingOrdersStore } from "../adapters/pending-orders";
 import { orderSnapshotsService } from "./order-snapshots.service";
 import { syncLogger } from "../utils/sync-logger";
@@ -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
@@ -48,6 +49,72 @@ export function registerPendingOrdersInvalidator(fn) {
             invalidator = null;
     };
 }
+/**
+ * Fire the registered query invalidator (lists refetch from SQLite).
+ * Used after LAN-applied writes (order:sync) that bypass the engine event
+ * pipeline, so peers' UIs converge without waiting for a cloud echo.
+ */
+export function notifyPendingOrdersChanged() {
+    try {
+        invalidator?.();
+    }
+    catch { }
+}
+/**
+ * Merge optimistic (queued, unconfirmed) state into a page of listed orders.
+ * Called by list queryFns (page 1 only) so offline work is visible:
+ *  1. Pending creations (order.create_queued, local or LAN) missing from the
+ *     SQLite page are prepended — deduped by id/order_number.
+ *  2. Queued transitions only patch the snapshot read model, never the
+ *     orders table — overlay snapshot statuses onto base rows so the list
+ *     reflects the queued status immediately (converges on replay).
+ * Reactivity comes from the invalidator: every apply path above refetches.
+ */
+export async function mergePendingIntoList(base, businessId, page) {
+    if (page !== 1)
+        return base;
+    let merged = base;
+    try {
+        const pending = usePendingOrdersStore.getState().orders;
+        if (pending.length) {
+            const seen = new Set(merged.map((o) => String(o.id ?? o.order_number)));
+            const fresh = pending.filter((p) => !seen.has(String(p.id ?? p.order_number)));
+            if (fresh.length)
+                merged = [...fresh, ...merged];
+        }
+    }
+    catch { }
+    try {
+        const db = await openSyncDatabase();
+        const snaps = await getEntitySnapshotsByType(db, "seller_orders", businessId);
+        if (!snaps.length)
+            return merged;
+        const statusById = new Map();
+        for (const s of snaps) {
+            const arr = s.payload?.data ?? [];
+            for (const o of arr) {
+                if (o?.id && o.status)
+                    statusById.set(String(o.id), String(o.status));
+            }
+        }
+        if (!statusById.size)
+            return merged;
+        let patched = false;
+        merged = merged.map((o) => {
+            const want = statusById.get(String(o.id));
+            if (want && want !== o.status) {
+                patched = true;
+                return { ...o, status: want };
+            }
+            return o;
+        });
+        if (patched) {
+            syncLogger.debug("PendingOrders", "overlaid queued statuses onto list", { businessId, count: merged.length });
+        }
+    }
+    catch { }
+    return merged;
+}
 /**
  * Load persisted unsynced order:create_queued events into the store.
  * Idempotent; safe to call after app restart while still offline.
@@ -99,8 +166,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 +182,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 +208,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 +268,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/reconciliation/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Global realtime reconciliation — RECONCILE_DEBOUNCE_MS 400 Set coalesce (§24).
+ * Canonical in src/sync/use-sync-reconciliation.
+ */
+export * from "../use-sync-reconciliation";

package/dist/sync/reconciliation/index.js

@@ -0,0 +1,5 @@
+/**
+ * Global realtime reconciliation — RECONCILE_DEBOUNCE_MS 400 Set coalesce (§24).
+ * Canonical in src/sync/use-sync-reconciliation.
+ */
+export * from "../use-sync-reconciliation";

package/dist/sync/snapshots/entity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Entity snapshots — local read model (§9 SQLite Model).
+ * Canonical in src/db/operations + src/sync/order-snapshots.service.
+ */
+export { upsertEntitySnapshot, getEntitySnapshot, getEntitySnapshotsByType, pruneEntitySnapshots } from "../../db/operations";
+export { orderSnapshotsService } from "../order-snapshots.service";

package/dist/sync/snapshots/entity.js

@@ -0,0 +1,6 @@
+/**
+ * Entity snapshots — local read model (§9 SQLite Model).
+ * Canonical in src/db/operations + src/sync/order-snapshots.service.
+ */
+export { upsertEntitySnapshot, getEntitySnapshot, getEntitySnapshotsByType, pruneEntitySnapshots } from "../../db/operations";
+export { orderSnapshotsService } from "../order-snapshots.service";

package/dist/sync/sync-jobs.service.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Sync Jobs FIFO — near real-time drain after local commit.
+ * Tries PHX business:{id} push first, then REST, queues on fail.
+ * Core-only, single in_flight per business, coalesced via isOnline gate.
+ */
+export declare function drainOne(businessId: string, entityId: string): Promise<void>;
+export declare function pullRemoteOrders(businessId: string): Promise<void>;
+export declare function drainPending(businessId: string): Promise<void>;
+export declare function setupSyncJobsDrain(): void;
+export declare function getSyncJobsPendingCount(businessId: string): Promise<number>;
+export declare function debugDumpSyncJobs(businessId: string): Promise<Array<{
+    id: string;
+    command_type: string;
+    status: string;
+    created_at: string;
+    attempts: number;
+    last_error: string | null;
+}>>;