@teincfood/core 0.7.7 → 0.7.9

package/dist/realtime/events.service.js

@@ -0,0 +1,76 @@
+import { phoenixSocket } from "./phoenix-socket";
+class EventsService {
+    constructor() {
+        this.refCount = 0;
+        this.topic = null;
+        this.joined = false;
+        this.lastSequence = 0;
+        this.activeBusinessId = null;
+        this.listeners = new Map();
+        this.wildcardListeners = new Set();
+        this.frameHandlerUnsub = null;
+    }
+    connect(userId, businessId) {
+        this.refCount++;
+        const topic = `events:${userId}`;
+        if (businessId !== undefined)
+            this.activeBusinessId = businessId ?? null;
+        if (this.refCount === 1 && !this.frameHandlerUnsub) {
+            this.topic = topic;
+            this.frameHandlerUnsub = phoenixSocket.onFrame(topic, ([_joinRef, _ref, _topic, event, payload]) => {
+                const data = payload;
+                const payloadBid = data?.business_id;
+                if (this.activeBusinessId && payloadBid && payloadBid !== this.activeBusinessId)
+                    return;
+                const sequence = data?._sequence;
+                if (typeof sequence === "number" && sequence <= this.lastSequence)
+                    return;
+                if (typeof sequence === "number" && sequence > this.lastSequence)
+                    this.lastSequence = sequence;
+                else if (typeof data?._sequence === "number")
+                    this.lastSequence = data._sequence;
+                const typeListeners = this.listeners.get(event);
+                if (typeListeners)
+                    typeListeners.forEach((cb) => cb(data));
+                this.wildcardListeners.forEach((cb) => cb(data));
+            });
+            const joinPayload = {};
+            if (this.lastSequence > 0)
+                joinPayload.last_sequence = this.lastSequence;
+            if (this.activeBusinessId)
+                joinPayload.business_id = this.activeBusinessId;
+            phoenixSocket.connect().then(() => phoenixSocket.joinChannel(topic, joinPayload)).then(() => { this.joined = true; }).catch(() => { });
+        }
+        else if (businessId !== undefined) {
+            // business switched while already joined — update filter without rejoin (next events filtered). If backend requires business:{id} subscription, re-join could be forced — not needed as fallback business_authorized check still passes.
+            this.activeBusinessId = businessId ?? null;
+        }
+        let disconnected = false;
+        return () => {
+            if (disconnected)
+                return;
+            disconnected = true;
+            this.refCount = Math.max(0, this.refCount - 1);
+            if (this.refCount === 0) {
+                if (this.topic && this.joined)
+                    phoenixSocket.leaveChannel(this.topic);
+                this.frameHandlerUnsub?.();
+                this.frameHandlerUnsub = null;
+                this.joined = false;
+                this.topic = null;
+                // reset sequence on full disconnect so next user doesn't dedup? Keep until next connect with same user - if user changes, lastSequence should reset. Caller should ensure new userId -> new instance or reset.
+                // Keep for replay.
+            }
+        };
+    }
+    on(eventType, callback) {
+        if (!this.listeners.has(eventType))
+            this.listeners.set(eventType, new Set());
+        this.listeners.get(eventType).add(callback);
+        return () => { this.listeners.get(eventType)?.delete(callback); };
+    }
+    onAny(callback) { this.wildcardListeners.add(callback); return () => this.wildcardListeners.delete(callback); }
+    isConnected() { return this.joined && phoenixSocket.isConnected(); }
+    resetSequence() { this.lastSequence = 0; }
+}
+export const eventsService = new EventsService();

package/dist/realtime/order-events.service.d.ts

@@ -0,0 +1,6 @@
+export declare const orderEventsService: {
+    onOrderUpdates(callback: (event: Record<string, unknown> & {
+        type: string;
+        order_id?: string;
+    }) => void): () => void;
+};

package/dist/realtime/order-events.service.js

@@ -0,0 +1,17 @@
+import { eventsService } from "./events.service";
+const ORDER_EVENT_TYPES = [
+    "order.created",
+    "order.status_changed",
+    "delivery.assigned",
+    "delivery.status_changed",
+    "delivery.pickup_confirmed",
+    "payment.completed",
+    "payment.failed",
+    "reference_data.changed",
+];
+export const orderEventsService = {
+    onOrderUpdates(callback) {
+        const unsubs = ORDER_EVENT_TYPES.map((type) => eventsService.on(type, (data) => callback({ ...data, type })));
+        return () => unsubs.forEach((fn) => fn());
+    },
+};

package/dist/realtime/phoenix-socket.d.ts

@@ -0,0 +1,55 @@
+export type ConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting";
+export type PhoenixV2Frame = [string | null, string | null, string, string, Record<string, unknown>];
+export type PhoenixOutbound = {
+    topic: string;
+    event: string;
+    payload: Record<string, unknown>;
+    ref?: string | null;
+    joinRef?: string | null;
+};
+type FrameHandler = (frame: PhoenixV2Frame) => void;
+declare class PhoenixSocket {
+    socket: WebSocket | null;
+    private refCounter;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private heartbeatPend;
+    private heartbeatMissed;
+    private static readonly MAX_MISSED;
+    private intentionalClose;
+    private connectGen;
+    private connectPromise;
+    private connectionState;
+    private connectionListeners;
+    private pendingJoins;
+    private pendingPushes;
+    joinedChannels: Set<string>;
+    private pendingRejoin;
+    private topicJoinRefs;
+    private frameHandlers;
+    private getRef;
+    private buildSocketUrl;
+    private setState;
+    onConnectionStateChange(fn: (s: ConnectionState) => void): () => void;
+    getConnectionState(): ConnectionState;
+    connect(): Promise<void>;
+    disconnect(): void;
+    retryConnection(): void;
+    private scheduleReconnect;
+    private cancelReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private sendRaw;
+    push(topic: string, event: string, payload: Record<string, unknown>): void;
+    pushWithReply(topic: string, event: string, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+    private handleFrame;
+    onFrame(topic: string, handler: FrameHandler): () => void;
+    joinChannel(topic: string, payload?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    leaveChannel(topic: string): void;
+    private rejoinPending;
+    isConnected(): boolean;
+    hasJoined(topic: string): boolean;
+}
+export declare const phoenixSocket: PhoenixSocket;
+export {};

package/dist/realtime/phoenix-socket.js

@@ -0,0 +1,240 @@
+import { WS_BASE_URL } from "../utils/constants";
+import { getAuthToken } from "../adapters/auth";
+const RECONNECT_BASE = 1000;
+const RECONNECT_MAX = 10000;
+const HEARTBEAT_MS = 30000;
+class PhoenixSocket {
+    constructor() {
+        this.socket = null;
+        this.refCounter = 0;
+        this.reconnectAttempt = 0;
+        this.reconnectTimer = null;
+        this.heartbeatTimer = null;
+        this.heartbeatPend = false;
+        this.heartbeatMissed = 0;
+        this.intentionalClose = false;
+        this.connectGen = 0;
+        this.connectPromise = null;
+        this.connectionState = "disconnected";
+        this.connectionListeners = new Set();
+        this.pendingJoins = new Map();
+        this.pendingPushes = new Map();
+        this.joinedChannels = new Set();
+        this.pendingRejoin = new Set();
+        this.topicJoinRefs = new Map();
+        this.frameHandlers = new Map();
+    }
+    getRef() { return String(++this.refCounter); }
+    buildSocketUrl(token) {
+        const base = WS_BASE_URL.replace(/\/+$/, "");
+        const path = base.endsWith("/ws") ? "/websocket" : "/ws/websocket";
+        return `${base}${path}?token=${encodeURIComponent(token)}&vsn=2.0.0`;
+    }
+    setState(s) {
+        this.connectionState = s;
+        this.connectionListeners.forEach((fn) => fn(s));
+    }
+    onConnectionStateChange(fn) {
+        this.connectionListeners.add(fn);
+        return () => this.connectionListeners.delete(fn);
+    }
+    getConnectionState() { return this.connectionState; }
+    connect() {
+        if (this.socket?.readyState === WebSocket.OPEN)
+            return Promise.resolve();
+        if (this.connectPromise)
+            return this.connectPromise;
+        this.cancelReconnect();
+        this.intentionalClose = false;
+        this.setState("connecting");
+        this.connectPromise = new Promise((resolve, reject) => {
+            const token = getAuthToken();
+            if (!token) {
+                this.setState("disconnected");
+                this.connectPromise = null;
+                reject(new Error("Not authenticated"));
+                return;
+            }
+            const myGen = ++this.connectGen;
+            const url = this.buildSocketUrl(token);
+            this.socket = new WebSocket(url);
+            this.socket.onopen = () => {
+                if (myGen !== this.connectGen)
+                    return;
+                this.reconnectAttempt = 0;
+                this.setState("connected");
+                this.startHeartbeat();
+                this.rejoinPending().catch(() => { });
+                this.connectPromise = null;
+                resolve();
+            };
+            this.socket.onerror = () => { if (myGen !== this.connectGen)
+                return; if (this.connectionState === "connecting") {
+                this.setState("disconnected");
+                this.connectPromise = null;
+            } };
+            this.socket.onmessage = (ev) => { try {
+                const frame = JSON.parse(ev.data);
+                this.handleFrame(frame);
+            }
+            catch { } };
+            this.socket.onclose = () => {
+                if (myGen !== this.connectGen)
+                    return;
+                this.stopHeartbeat();
+                if (!this.intentionalClose) {
+                    this.joinedChannels.forEach((t) => this.pendingRejoin.add(t));
+                    this.joinedChannels.clear();
+                    this.scheduleReconnect();
+                }
+                else {
+                    this.joinedChannels.clear();
+                    this.pendingRejoin.clear();
+                    this.setState("disconnected");
+                }
+                this.connectPromise = null;
+            };
+        });
+        return this.connectPromise;
+    }
+    disconnect() {
+        this.intentionalClose = true;
+        this.cancelReconnect();
+        this.stopHeartbeat();
+        this.joinedChannels.clear();
+        this.pendingRejoin.clear();
+        this.pendingJoins.clear();
+        this.pendingPushes.clear();
+        this.topicJoinRefs.clear();
+        this.frameHandlers.clear();
+        if (this.socket) {
+            this.socket.close();
+            this.socket = null;
+        }
+        this.setState("disconnected");
+        this.connectPromise = null;
+    }
+    retryConnection() { this.cancelReconnect(); this.reconnectAttempt = 0; this.connect().catch(() => { }); }
+    scheduleReconnect() {
+        if (this.intentionalClose)
+            return;
+        this.setState("reconnecting");
+        const delay = Math.min(RECONNECT_BASE * Math.pow(2, this.reconnectAttempt), RECONNECT_MAX);
+        this.reconnectAttempt++;
+        this.reconnectTimer = setTimeout(() => this.connect().catch(() => { }), delay);
+    }
+    cancelReconnect() { if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+    } }
+    startHeartbeat() {
+        this.heartbeatPend = false;
+        this.heartbeatMissed = 0;
+        this.heartbeatTimer = setInterval(() => {
+            if (this.heartbeatPend) {
+                this.heartbeatMissed++;
+                if (this.heartbeatMissed >= PhoenixSocket.MAX_MISSED)
+                    this.socket?.close();
+                return;
+            }
+            this.heartbeatPend = true;
+            this.sendRaw({ topic: "phoenix", event: "heartbeat", payload: {} });
+        }, HEARTBEAT_MS);
+    }
+    stopHeartbeat() { if (this.heartbeatTimer) {
+        clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+    } this.heartbeatPend = false; this.heartbeatMissed = 0; }
+    sendRaw(msg) {
+        if (this.socket?.readyState === WebSocket.OPEN) {
+            const joinRef = msg.topic && msg.topic !== "phoenix" ? (msg.joinRef ?? this.topicJoinRefs.get(msg.topic) ?? null) : (msg.joinRef ?? null);
+            const frame = [joinRef, msg.ref ?? null, msg.topic, msg.event, msg.payload];
+            this.socket.send(JSON.stringify(frame));
+        }
+    }
+    push(topic, event, payload) { const ref = this.getRef(); this.sendRaw({ topic, event, payload, ref, joinRef: this.topicJoinRefs.get(topic) }); }
+    pushWithReply(topic, event, payload) {
+        const ref = this.getRef();
+        const msg = { topic, event, payload, ref, joinRef: this.topicJoinRefs.get(topic) };
+        return new Promise((resolve, reject) => {
+            this.pendingPushes.set(ref, { resolve, reject });
+            this.sendRaw(msg);
+            setTimeout(() => { if (this.pendingPushes.has(ref)) {
+                this.pendingPushes.delete(ref);
+                reject(new Error(`Request timed out: ${event} on ${topic}`));
+            } }, 5000);
+        });
+    }
+    handleFrame([joinRef, ref, topic, event, payload]) {
+        if (event === "phx_reply" && topic === "phoenix") {
+            this.heartbeatPend = false;
+            this.heartbeatMissed = 0;
+            return;
+        }
+        if (event === "phx_reply" && ref) {
+            const pending = this.pendingPushes.get(ref);
+            if (pending) {
+                const status = payload?.status;
+                const response = (payload?.response ?? {});
+                if (status === "ok")
+                    pending.resolve(response);
+                else
+                    pending.reject(new Error(String(response.reason ?? "Request failed")));
+                this.pendingPushes.delete(ref);
+                return;
+            }
+        }
+        if (event === "phx_reply" && payload?.status === "ok") {
+            const pending = this.pendingJoins.get(topic);
+            if (pending) {
+                const response = (payload?.response ?? {});
+                pending.resolve(response);
+                this.pendingJoins.delete(topic);
+                this.joinedChannels.add(topic);
+                if (joinRef)
+                    this.topicJoinRefs.set(topic, joinRef);
+            }
+            return;
+        }
+        if (event === "phx_reply" && payload?.status === "error") {
+            const pending = this.pendingJoins.get(topic);
+            if (pending) {
+                const response = (payload?.response ?? {});
+                pending.reject(new Error(String(response.reason ?? "Join failed")));
+                this.pendingJoins.delete(topic);
+            }
+            return;
+        }
+        const handlers = this.frameHandlers.get(topic);
+        if (handlers)
+            handlers.forEach((cb) => cb([joinRef, ref, topic, event, payload]));
+    }
+    onFrame(topic, handler) {
+        if (!this.frameHandlers.has(topic))
+            this.frameHandlers.set(topic, new Set());
+        this.frameHandlers.get(topic).add(handler);
+        return () => { this.frameHandlers.get(topic)?.delete(handler); };
+    }
+    async joinChannel(topic, payload = {}) {
+        if (this.joinedChannels.has(topic))
+            return Promise.resolve({});
+        if (this.pendingJoins.has(topic))
+            return new Promise((resolve, reject) => { this.pendingJoins.set(topic, { resolve, reject }); });
+        const ref = this.getRef();
+        const msg = { topic, event: "phx_join", payload, ref };
+        return new Promise((resolve, reject) => {
+            this.pendingJoins.set(topic, { resolve, reject });
+            this.sendRaw(msg);
+            setTimeout(() => { if (this.pendingJoins.has(topic)) {
+                this.pendingJoins.delete(topic);
+                reject(new Error(`Failed to join channel ${topic} - timeout`));
+            } }, 5000);
+        });
+    }
+    leaveChannel(topic) { this.joinedChannels.delete(topic); this.pendingRejoin.delete(topic); this.topicJoinRefs.delete(topic); }
+    async rejoinPending() { const topics = Array.from(this.pendingRejoin); this.pendingRejoin.clear(); await Promise.allSettled(topics.map((t) => this.joinChannel(t))); }
+    isConnected() { return this.socket?.readyState === WebSocket.OPEN; }
+    hasJoined(topic) { return this.joinedChannels.has(topic); }
+}
+PhoenixSocket.MAX_MISSED = 3;
+export const phoenixSocket = new PhoenixSocket();

package/dist/realtime/useEventsConnection.d.ts

@@ -0,0 +1 @@
+export declare function useEventsConnection(): void;

package/dist/realtime/useEventsConnection.js

@@ -0,0 +1,41 @@
+import { useEffect } from "react";
+import { eventsService } from "./events.service";
+import { useSyncExternalStore } from "react";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { getAuthToken } from "../adapters/auth";
+function useBusinessId() {
+    return useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+}
+function useIsAuthenticated() {
+    // poll auth token presence; host should setAuthProvider — if no provider, assume authenticated when token exists
+    return !!getAuthToken();
+}
+export function useEventsConnection() {
+    const activeBusinessId = useBusinessId();
+    // derive userId from auth token? Host must provide via setAuthProvider that encodes user, but we need userId for topic.
+    // For now, read from global if host set it via setAuthUserId adapter. Fallback: token payload decode.
+    // Minimal: require host to call eventsService.connect with userId directly via wrapper — this hook is convenience that reads business only.
+    // To keep zero-config, we attempt to read from window localStorage token decode — fallback no-op.
+    const userId = deriveUserId();
+    useEffect(() => {
+        if (!userId)
+            return;
+        const disconnect = eventsService.connect(userId, activeBusinessId);
+        return () => disconnect();
+    }, [userId, activeBusinessId]);
+}
+function deriveUserId() {
+    try {
+        const token = getAuthToken();
+        if (!token)
+            return null;
+        const parts = token.split(".");
+        if (parts.length < 2)
+            return null;
+        const payload = JSON.parse(atob(parts[1]));
+        return payload.sub || payload.user_id || payload.id || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/reference/capabilities.js

@@ -93,6 +93,7 @@ export const CAPABILITY_BY_COMMAND = {
     "menu:update_item": "menu_manage",
     "menu:delete_item": "menu_manage",
     "menu:create_category": "menu_manage",
+    "payment:confirm_cash": "orders_accept",
 };
 export async function hasCapabilitySync(businessId, commandType) {
     const required = CAPABILITY_BY_COMMAND[commandType];

package/dist/repositories/order.repository.d.ts

@@ -41,4 +41,5 @@ export declare const orderRepository: {
     assignRider(input: AssignRiderInput & {
         businessId: string;
     }): Promise<unknown>;
+    confirmCashPayment(input: OrderActionInput): Promise<SellerOrder>;
 };

package/dist/repositories/order.repository.js

@@ -126,4 +126,13 @@ export const orderRepository = {
         }
         return event.payload;
     },
+    async confirmCashPayment(input) {
+        const command = buildCommand({
+            commandType: "payment:confirm_cash",
+            businessId: input.businessId,
+            entityId: input.orderId,
+            payload: {},
+        });
+        return executeCommand(command);
+    },
 };

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

@@ -25,6 +25,10 @@ const QUEUED_STATUS_BY_COMMAND = {
     "delivery:assign": "assigned",
     "delivery:confirm_handover": "delivered",
 };
+const PAYMENT_QUEUED_PAYLOAD = {
+    is_paid: true,
+    to_is_paid: true,
+};
 export function getQueuedStatus(commandType) {
     return QUEUED_STATUS_BY_COMMAND[commandType] ?? null;
 }
@@ -42,6 +46,24 @@ function buildOptimisticEvent(command) {
             timestamp: new Date().toISOString(),
         };
     }
+    if (command.command_type === "payment:confirm_cash") {
+        return {
+            event_id: generateEventId(),
+            event_type: "payment.completed_queued",
+            event_version: "1.0",
+            entity_id: command.entity_id ?? command.command_id,
+            user_id: command.user_id,
+            device_id: command.device_id,
+            payload: {
+                ...payload,
+                command_id: command.command_id,
+                is_paid: true,
+                paid_at: new Date().toISOString(),
+                order_id: command.entity_id,
+            },
+            timestamp: new Date().toISOString(),
+        };
+    }
     const queuedStatus = getQueuedStatus(command.command_type);
     return {
         event_id: generateEventId(),
@@ -58,11 +80,13 @@ function buildOptimisticEvent(command) {
             to_status: queuedStatus,
             order_id: command.entity_id,
             delivery_id: command.entity_id,
+            ...(queuedStatus ? {} : {}),
         },
         timestamp: new Date().toISOString(),
     };
 }
 function buildOptimisticOrder(command, payload) {
+    const snapshots = payload.item_snapshots ?? null;
     const items = payload.items ?? [];
     const totalMinor = payload.total_minor ?? 0;
     const subtotalMinor = payload.subtotal_minor ?? totalMinor;
@@ -109,14 +133,22 @@ function buildOptimisticOrder(command, payload) {
         delivery_lat: null,
         delivery_lng: null,
         user: null,
-        items: items.map((item, index) => ({
+        items: (snapshots ? snapshots.map((s, index) => ({
+            id: `tmp-${command.command_id}-${index}`,
+            menu_item: { id: s.menu_item_id, name: s.name },
+            quantity: s.quantity,
+            unit_price: s.unit_price_minor,
+            subtotal: s.unit_price_minor * s.quantity,
+            variant_name: s.variant_name,
+            addons: (s.addons ?? []).map((a) => ({ name: a.name, price_minor: a.price_minor })),
+        })) : items.map((item, index) => ({
             id: `tmp-${command.command_id}-${index}`,
             menu_item: { id: item.menu_item_id, name: "" },
             quantity: item.quantity,
             unit_price: 0,
             subtotal: 0,
             addons: [],
-        })),
+        }))),
         inserted_at: now,
     };
 }

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

@@ -97,6 +97,36 @@ 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 lists = 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.