@teincfood/core 0.10.16 → 0.10.18

package/dist/adapters/services.d.ts

@@ -36,7 +36,7 @@ export declare const sellerService: {
     }>;
 };
 export declare const kioskService: {
-    assignKioskOrderToRider: (_orderId: string, _riderId: string) => Promise<unknown>;
+    assignKioskOrderToRider: (_orderId: string, _riderId: string, _idempotencyKey?: string) => Promise<unknown>;
 };
 export declare const menuService: {
     fetchBusinessMenuItems: (_businessId: string, _page: number) => Promise<unknown>;

package/dist/adapters/services.js

@@ -54,7 +54,7 @@ export const sellerService = {
 };
 // kiosk.service
 export const kioskService = {
-    assignKioskOrderToRider: async (_orderId, _riderId) => {
+    assignKioskOrderToRider: async (_orderId, _riderId, _idempotencyKey) => {
         notImpl("kioskService.assignKioskOrderToRider");
     },
 };

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

@@ -60,6 +60,18 @@ declare class LocalNodeServiceCore {
     private storeUnsub;
     private setupStoreSubscriptions;
     private teardownStoreSubscriptions;
+    /**
+     * Apply an event received over the LAN, regardless of whether it arrived on
+     * a client socket (`peer`) or was relayed through a node by another terminal
+     * (`relay`).
+     *
+     * Both paths must materialize order rows and invalidate the read model. The
+     * relay path previously only applied reference-data events, so an order
+     * created on a phone while it had internet (cloud route) was broadcast to
+     * the LAN but silently dropped by the peer node — the other terminal never
+     * saw it until a later reconciliation.
+     */
+    private applyLanEvent;
     private startAsNode;
     /**
      * (Re)publish this node's mDNS advertisement. Isolated from server bring-up

package/dist/local-node/service.js

@@ -422,6 +422,92 @@ class LocalNodeServiceCore {
         this.storeUnsub = null;
         this.subscribed = false;
     }
+    /**
+     * Apply an event received over the LAN, regardless of whether it arrived on
+     * a client socket (`peer`) or was relayed through a node by another terminal
+     * (`relay`).
+     *
+     * Both paths must materialize order rows and invalidate the read model. The
+     * relay path previously only applied reference-data events, so an order
+     * created on a phone while it had internet (cloud route) was broadcast to
+     * the LAN but silently dropped by the peer node — the other terminal never
+     * saw it until a later reconciliation.
+     */
+    applyLanEvent(event, source) {
+        syncLogger.event(event, "received", { origin: "lan", source });
+        const deps = this.getDeps();
+        const eventType = event.event_type;
+        // Materialize LAN order events into the canonical orders table so
+        // list queries (POS In Progress, KDS) converge without the backend.
+        // Previously only order:sync inserted rows: a cloud/local-shape
+        // order.created from a peer fell through to the pending-store apply
+        // fns (which never touch the orders table), so the event arrived,
+        // every layer reported success, and the row never materialized.
+        if (eventType === "order:sync" || eventType === "order.created" || eventType === "order.status_changed") {
+            void (async () => {
+                try {
+                    const p = event.payload;
+                    const bid = deps.getBusiness()?.id;
+                    const payloadBid = p.business_id;
+                    if (typeof payloadBid === "string" && bid && payloadBid !== bid) {
+                        syncLogger.warn("LocalNodeService", "Ignoring LAN order event for another business", {
+                            event_type: eventType,
+                            payloadBid,
+                            bid,
+                        });
+                        return;
+                    }
+                    if (p && typeof p.order_number === "string" && p.id) {
+                        // Full-order payload (order:sync publish or order.created /
+                        // status_changed echo): upsert the canonical row. HLC guard
+                        // inside insertOrder keeps this idempotent across mesh + phx
+                        // double delivery.
+                        const db = await openSyncDatabase();
+                        await insertOrder(db, p);
+                        syncLogger.info("LocalNodeService", "LAN order row materialized", {
+                            event_type: eventType,
+                            order_number: p.order_number,
+                            source,
+                        });
+                    }
+                    else {
+                        // Action-shaped payload (order:sync from a LAN command):
+                        // apply the transition to the local row.
+                        const action = p.action;
+                        const orderId = p.orderId ?? p.order_id;
+                        if (action && orderId && bid) {
+                            try {
+                                await transitionLocalOrder(bid, String(orderId), action);
+                                syncLogger.info("LocalNodeService", "LAN order transition applied", {
+                                    event_type: eventType,
+                                    action,
+                                    orderId: String(orderId),
+                                    source,
+                                });
+                            }
+                            catch { }
+                        }
+                        else {
+                            syncLogger.warn("LocalNodeService", "LAN order event has no materializable payload", {
+                                event_type: eventType,
+                                entity_id: event.entity_id,
+                            });
+                        }
+                    }
+                }
+                catch (e) {
+                    syncLogger.warn("LocalNodeService", "LAN order apply failed", { err: String(e), event_type: eventType });
+                }
+                // The row is in SQLite now — invalidate so lists/detail refetch.
+                // (LAN-applied writes bypass the engine pipeline, so no subscriber
+                // does this for us.)
+                notifyPendingOrdersChanged();
+            })();
+        }
+        applyPendingOrderEvent(event, "lan").catch((e) => syncLogger.error("LocalNodeService", "Failed to apply LAN event", { error: String(e), event_type: event.event_type }));
+        applyReferenceChangeEvent(event, "lan").catch((e) => syncLogger.error("LocalNodeService", "Failed to apply LAN reference", { error: String(e), event_type: event.event_type }));
+        applyOrderStateChangeEvent(event, "lan").catch((e) => syncLogger.error("LocalNodeService", "Failed to apply LAN order state", { error: String(e), event_type: event.event_type }));
+    }
     async startAsNode(port) {
         if (!this.businessId || !this.secret)
             throw new Error("LocalNodeService: business context missing");
@@ -435,7 +521,7 @@ class LocalNodeServiceCore {
                 return event ? [event] : [];
             },
             onRelayEvent: (event) => {
-                applyReferenceChangeEvent(event, "lan").catch((e) => syncLogger.error("LocalNodeService", "Failed to apply relayed reference", { error: String(e), event_type: event.event_type }));
+                this.applyLanEvent(event, "relay");
             },
             onClientConnected: (info) => {
                 localNodeStore.getState().addConnectedClient({ deviceId: info.deviceId, deviceName: info.deviceName, host: info.host, connectedAt: new Date().toISOString() });
@@ -609,76 +695,7 @@ class LocalNodeServiceCore {
             businessId: this.businessId,
             secret: this.secret,
             onEvent: (event) => {
-                syncLogger.event(event, "received", { origin: "lan" });
-                const eventType = event.event_type;
-                // Materialize LAN order events into the canonical orders table so
-                // list queries (POS In Progress, KDS) converge without the backend.
-                // Previously only order:sync inserted rows: a cloud/local-shape
-                // order.created from a peer fell through to the pending-store apply
-                // fns (which never touch the orders table), so the event arrived,
-                // every layer reported success, and the row never materialized.
-                if (eventType === "order:sync" || eventType === "order.created" || eventType === "order.status_changed") {
-                    void (async () => {
-                        try {
-                            const p = event.payload;
-                            const bid = deps.getBusiness()?.id;
-                            const payloadBid = p.business_id;
-                            if (typeof payloadBid === "string" && bid && payloadBid !== bid) {
-                                syncLogger.warn("LocalNodeService", "Ignoring LAN order event for another business", {
-                                    event_type: eventType,
-                                    payloadBid,
-                                    bid,
-                                });
-                                return;
-                            }
-                            if (p && typeof p.order_number === "string" && p.id) {
-                                // Full-order payload (order:sync publish or order.created /
-                                // status_changed echo): upsert the canonical row. HLC guard
-                                // inside insertOrder keeps this idempotent across mesh + phx
-                                // double delivery.
-                                const db = await openSyncDatabase();
-                                await insertOrder(db, p);
-                                syncLogger.info("LocalNodeService", "LAN order row materialized", {
-                                    event_type: eventType,
-                                    order_number: p.order_number,
-                                });
-                            }
-                            else {
-                                // Action-shaped payload (order:sync from a LAN command):
-                                // apply the transition to the local row.
-                                const action = p.action;
-                                const orderId = p.orderId ?? p.order_id;
-                                if (action && orderId && bid) {
-                                    try {
-                                        await transitionLocalOrder(bid, String(orderId), action);
-                                        syncLogger.info("LocalNodeService", "LAN order transition applied", {
-                                            event_type: eventType,
-                                            action,
-                                            orderId: String(orderId),
-                                        });
-                                    }
-                                    catch { }
-                                }
-                                else {
-                                    syncLogger.warn("LocalNodeService", "LAN order event has no materializable payload", {
-                                        event_type: eventType,
-                                        entity_id: event.entity_id,
-                                    });
-                                }
-                            }
-                        }
-                        catch (e) {
-                            syncLogger.warn("LocalNodeService", "LAN order apply failed", { err: String(e), event_type: eventType });
-                        }
-                        // The row is in SQLite now — invalidate so lists/detail refetch.
-                        // (LAN-applied writes bypass the engine pipeline, so no
-                        // subscriber does this for us.)
-                        notifyPendingOrdersChanged();
-                    })();
-                }
-                applyPendingOrderEvent(event, "lan").catch((e) => syncLogger.error("LocalNodeService", "Failed to apply LAN event", { error: String(e), event_type: event.event_type }));
-                applyReferenceChangeEvent(event, "lan").catch((e) => syncLogger.error("LocalNodeService", "Failed to apply LAN reference", { error: String(e), event_type: event.event_type }));
-                applyOrderStateChangeEvent(event, "lan").catch((e) => syncLogger.error("LocalNodeService", "Failed to apply LAN order state", { error: String(e), event_type: event.event_type }));
+                this.applyLanEvent(event, "peer");
             },
             onConnected: () => {
                 this.settleDial(node.deviceId);

package/dist/repositories/order.repository.js

@@ -141,8 +141,12 @@ export const orderRepository = {
             commandType: "delivery:assign",
             businessId: input.businessId,
             entityId: input.orderId,
-            payload: { rider_id: input.riderId },
+            payload: { rider_id: input.riderId, idempotency_key: "" },
         });
+        // One user action = one stable key. Replays of this command (timeout,
+        // reconnect, LAN relay) must converge on the same delivery instead of
+        // creating another one.
+        command.payload.idempotency_key = command.command_id;
         const events = await syncEngine.execute(command);
         const event = events[0];
         if (!event) {

package/dist/sync/sync-jobs.service.js

@@ -217,7 +217,12 @@ async function tryRest(businessId, payload, commandType) {
                 const riderId = (payload.rider_id ?? payload.riderId);
                 if (!riderId)
                     return { ok: false, status: 422, code: "MISSING_RIDER", message: "Assign rider job has no rider_id — re-assign from the app" };
-                await http.post(`/deliveries/assign`, { order_id: orderId, rider_id: riderId });
+                const idempotencyKey = (payload.idempotency_key ?? payload.idempotencyKey);
+                await http.post(`/deliveries/assign`, {
+                    order_id: orderId,
+                    rider_id: riderId,
+                    ...(idempotencyKey ? { idempotency_key: idempotencyKey } : {}),
+                });
                 return { ok: true };
             }
             // POST /deliveries/:deliveryId/confirm-handover — resolve the delivery

package/dist/sync/transport-rest.js

@@ -84,7 +84,8 @@ export class RestTransport {
                 return this.executeOrderTransition(command, "cancel", timestamp, () => sellerService.cancelOrder(entity_id));
             }
             case "delivery:assign": {
-                const response = await kioskService.assignKioskOrderToRider(entity_id, payload.rider_id);
+                const assignPayload = payload;
+                const response = await kioskService.assignKioskOrderToRider(entity_id, assignPayload.rider_id, assignPayload.idempotency_key ?? command.command_id);
                 return this.wrapResponse("delivery.assigned", response, entity_id, timestamp, command);
             }
             case "delivery:confirm_handover": {

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

@@ -96,15 +96,22 @@ export function useSyncReconciliation() {
             // The node relays engine events (e.g. order.created when a queued
             // command is replayed) to LAN clients so they reconcile their pending
             // orders and refresh caches.
+            //
+            // A terminal that is only a LAN client (its own listener failed to bind,
+            // or it is a phone in the background) also has to forward the events it
+            // produces locally. Otherwise a sale completed over the cloud while the
+            // phone has mobile data — the exact iOS Wi-Fi + LTE case — never reaches
+            // the node until a later full sync. Reference events were already
+            // forwarded here; order/payment/delivery events need the same path.
+            const relayable = event.event_type === REFERENCE_CHANGED_EVENT_TYPE ||
+                event.event_type.startsWith("order.") ||
+                event.event_type.startsWith("order:") ||
+                event.event_type.startsWith("payment.") ||
+                event.event_type.startsWith("delivery.");
             if (localNodeService.isLocalNode()) {
                 localNodeService.broadcastToClients(event);
             }
-            // Reference data changed on this device but we are a LAN client (not the
-            // node): forward the event to the node so it rebroadcasts it to every
-            // other terminal (the node also applies it locally via its onRelayEvent
-            // hook). The node does not echo it back to this device.
-            if (event.event_type === REFERENCE_CHANGED_EVENT_TYPE &&
-                !localNodeService.isLocalNode()) {
+            else if (relayable) {
                 localNodeService.getClient()?.publishEvent?.(event);
             }
             // Where the event came from: a Phoenix push is "cloud", a LAN relay is

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@teincfood/core",
-  "version": "0.10.16",
-  "description": "TeincFood shared offline-first core — types, sync engine, local DB, reference data, and repositories for mobile + desktop",
+  "version": "0.10.18",
+  "description": "TeincFood shared offline-first core \u2014 types, sync engine, local DB, reference data, and repositories for mobile + desktop",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",