@teincfood/core 0.10.14 → 0.10.16

package/dist/adapters/auth.d.ts

@@ -4,6 +4,9 @@
 export interface AuthUser {
     id: string;
     email?: string;
+    full_name?: string | null;
+    phone?: string | null;
+    avatar_url?: string | null;
 }
 export declare function setAuthUser(u: AuthUser | null): void;
 export declare const useAuthStore: {

package/dist/db/migrations.js

@@ -448,4 +448,29 @@ export const MIGRATIONS = [
             catch { }
         },
     },
+    {
+        version: 13,
+        up: async (db) => {
+            // Online orders need their prepaid/pay-on-delivery mode locally so the
+            // analytics payment breakdown mirrors the backend. POS orders keep
+            // `pos_payment_method` as the authoritative method.
+            await db.execAsync(`
+          ALTER TABLE orders ADD COLUMN payment_mode TEXT;
+        `);
+            // Best-effort backfill: POS rows are prepaid at the order level; online
+            // rows without a value are assumed prepaid until the next pull.
+            try {
+                await db.execAsync(`
+            UPDATE orders
+               SET payment_mode = CASE
+                 WHEN is_pos = 1 THEN 'prepaid'
+                 WHEN pos_payment_method IS NULL THEN 'prepaid'
+                 ELSE pos_payment_method
+               END
+             WHERE payment_mode IS NULL;
+          `);
+            }
+            catch { }
+        },
+    },
 ];

package/dist/db/operations.d.ts

@@ -60,6 +60,7 @@ export interface OrderRow {
     customer_name: string | null;
     customer_phone: string | null;
     pos_payment_method: string | null;
+    payment_mode: string | null;
     delivery_id: string | null;
     business: string | null;
     user: string | null;

package/dist/db/operations.js

@@ -256,6 +256,7 @@ function orderRowToSellerOrder(row) {
         customer_name: row.customer_name,
         customer_phone: row.customer_phone,
         pos_payment_method: row.pos_payment_method,
+        payment_mode: row.payment_mode ?? "prepaid",
         delivery_id: row.delivery_id,
         business: row.business ? JSON.parse(row.business) : null,
         delivery_address: null,
@@ -283,10 +284,10 @@ export async function insertOrder(db, order) {
     const paidAt = order.paid_at ??
         order.payment?.paid_at ??
         (isOrderPaid(order) ? updatedAt : null);
-    await db.runAsync(`INSERT INTO orders (id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, paid_at, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, updated_at, hlc)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-     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
-     WHERE excluded.hlc >= orders.hlc OR orders.hlc IS NULL;`, order.id, order.business_id, order.order_number, order.callout_number, order.status, order.order_type, order.is_pos ? 1 : 0, JSON.stringify(order.items), order.subtotal_minor, order.total_minor, order.tax_minor, JSON.stringify(order.tax_lines), JSON.stringify(order.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);
+    await db.runAsync(`INSERT INTO orders (id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, paid_at, customer_name, customer_phone, pos_payment_method, payment_mode, delivery_id, business, user, inserted_at, updated_at, hlc)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     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, payment_mode=excluded.payment_mode, 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
+     WHERE excluded.hlc >= orders.hlc OR orders.hlc IS NULL;`, order.id, order.business_id, order.order_number, order.callout_number, order.status, order.order_type, order.is_pos ? 1 : 0, JSON.stringify(order.items), order.subtotal_minor, order.total_minor, order.tax_minor, JSON.stringify(order.tax_lines), JSON.stringify(order.payment), paidAt, order.customer_name, order.customer_phone, order.pos_payment_method, order.payment_mode ?? null, 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");
 }
 export async function getOrderById(db, businessId, idOrNumber) {
@@ -371,9 +372,9 @@ export async function upsertServerOrder(db, order, opts = {}) {
         order.inserted_at ??
         new Date().toISOString();
     const updatedAt = order.updated_at ?? order.inserted_at;
-    await db.runAsync(`INSERT INTO orders (id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, paid_at, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, updated_at, hlc)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-     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);
+    await db.runAsync(`INSERT INTO orders (id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, paid_at, customer_name, customer_phone, pos_payment_method, payment_mode, delivery_id, business, user, inserted_at, updated_at, hlc)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     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, payment_mode=excluded.payment_mode, 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.payment_mode ?? (order.is_pos ? "prepaid" : "prepaid"), 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");
 }
 /**

package/dist/domain/orders/service.js

@@ -18,7 +18,7 @@ import { validateOrderCreateInput } from "../../validation/offline";
 import { buildItemSnapshots, snapshotsToOrderLines } from "./snapshots";
 import { getBusinessOrderFlowMode, initialPosOrderStatus } from "./order-flow";
 import { drainOne, pullRemoteOrders } from "../../sync/sync-jobs.service";
-import { getAuthToken } from "../../adapters/auth";
+import { getAuthToken, useAuthStore } from "../../adapters/auth";
 import { canBusinessSync } from "../../sync/sync-guard";
 import { syncLogger } from "../../utils/sync-logger";
 import { getItem } from "../../adapters/kv";
@@ -130,6 +130,16 @@ export async function createLocalOrder(businessId, input) {
     const taxMinor = input.tax_minor ?? 0;
     const taxLines = input.tax_lines ?? [];
     const currencyCode = input.currency_code ?? "GHS";
+    const authUser = useAuthStore.getState().user;
+    const teller = authUser
+        ? {
+            id: authUser.id,
+            full_name: authUser.full_name ?? authUser.email ?? "Staff",
+            email: authUser.email ?? "",
+            phone: authUser.phone ?? "",
+            avatar_url: authUser.avatar_url ?? null,
+        }
+        : null;
     const order = {
         id,
         order_number: orderNumber,
@@ -161,7 +171,8 @@ export async function createLocalOrder(businessId, input) {
         delivery_lng: null,
         delivery_id: null,
         delivery_status: null,
-        user: null,
+        user: teller,
+        teller,
         items: items,
         inserted_at: insertedAt,
     };

package/dist/hooks/analytics.hooks.d.ts

@@ -21,10 +21,16 @@ interface LocalOrderRow {
     status: string;
     total_minor: number;
     subtotal_minor?: number;
+    currency?: string;
     inserted_at: string;
+    is_pos?: boolean;
     payment_mode?: string;
     pos_payment_method?: string;
     order_type?: string;
+    user?: {
+        id?: string;
+        full_name?: string | null;
+    } | null;
     items?: Array<{
         quantity?: number;
         subtotal?: number;
@@ -52,6 +58,7 @@ interface AggregateOptions {
 export declare function filterByPeriod(orders: LocalOrderRow[], period: AnalyticsPeriod, now?: Date, range?: AnalyticsRange): LocalOrderRow[];
 export declare function aggregateLocal(orders: LocalOrderRow[], period: AnalyticsPeriod, opts: AggregateOptions, range?: AnalyticsRange): {
     period: AnalyticsPeriod;
+    currency: string;
     total_revenue_minor: number;
     total_orders: number;
     average_order_value_minor: number;
@@ -71,16 +78,33 @@ export declare function aggregateLocal(orders: LocalOrderRow[], period: Analytic
         count: number;
         date: string;
     }[];
+    by_channel: {
+        revenue_minor: number;
+        count: number;
+        channel: string;
+        percentage: number;
+    }[];
+    by_teller: {
+        user_id: string;
+        name: string;
+        revenue_minor: number;
+        count: number;
+        average_order_value_minor: number;
+    }[];
+    by_hour: {
+        hour: number;
+        revenue_minor: number;
+        count: number;
+    }[];
     offline: boolean;
     total_refunds_minor?: undefined;
     top_items?: undefined;
     orders_by_status?: undefined;
     revenue_by_day?: undefined;
 } | {
-    by_payment_method?: undefined;
-    by_order_type?: undefined;
     by_day?: undefined;
     period: AnalyticsPeriod;
+    currency: string;
     total_revenue_minor: number;
     total_orders: number;
     average_order_value_minor: number;
@@ -99,8 +123,45 @@ export declare function aggregateLocal(orders: LocalOrderRow[], period: Analytic
         date: string;
         revenue_minor: number;
     }[];
+    by_channel: {
+        revenue_minor: number;
+        count: number;
+        channel: string;
+        percentage: number;
+    }[];
+    by_payment_method: {
+        revenue_minor: number;
+        count: number;
+        method: string;
+        percentage: number;
+    }[];
+    by_order_type: {
+        revenue_minor: number;
+        count: number;
+        type: string;
+    }[];
+    by_teller: {
+        user_id: string;
+        name: string;
+        revenue_minor: number;
+        count: number;
+        average_order_value_minor: number;
+    }[];
+    by_hour: {
+        hour: number;
+        revenue_minor: number;
+        count: number;
+    }[];
     offline: boolean;
 };
-export declare function useSellerAnalyticsQuery(period?: AnalyticsPeriod, enabled?: boolean, range?: AnalyticsRange): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
-export declare function useRevenueSummaryQuery(period?: AnalyticsPeriod, enabled?: boolean, range?: AnalyticsRange): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+interface AnalyticsPayload {
+    total_orders?: number;
+    [key: string]: unknown;
+}
+interface AnalyticsResponse {
+    data?: AnalyticsPayload;
+    [key: string]: unknown;
+}
+export declare function useSellerAnalyticsQuery(period?: AnalyticsPeriod, enabled?: boolean, range?: AnalyticsRange): import("@tanstack/react-query").UseQueryResult<AnalyticsResponse, Error>;
+export declare function useRevenueSummaryQuery(period?: AnalyticsPeriod, enabled?: boolean, range?: AnalyticsRange): import("@tanstack/react-query").UseQueryResult<AnalyticsResponse, Error>;
 export {};

package/dist/hooks/analytics.hooks.js

@@ -3,11 +3,13 @@
  * Offline-first: local SQLite aggregates serve instantly; the network
  * refreshes silently when online.
  */
-import { useQuery } from "@tanstack/react-query";
-import { useSyncExternalStore } from "react";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useEffect, useSyncExternalStore } from "react";
 import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
 import { analyticsService } from "../adapters/services";
 import { listLocalOrders } from "../domain/orders/service";
+import { pullRemoteOrders } from "../sync/sync-jobs.service";
+import { syncLogger } from "../utils/sync-logger";
 import { useIsEffectivelyOnline } from "./use-infinite-list";
 export const SELLER_ANALYTICS_KEYS = {
     all: ["seller-analytics"],
@@ -96,10 +98,25 @@ export function aggregateLocal(orders, period, opts, range) {
     const byMethod = new Map();
     const byType = new Map();
     const byDay = new Map();
+    const byChannel = new Map();
+    const byTeller = new Map();
+    const byHour = new Map();
     const itemQty = new Map();
     const itemRev = new Map();
     for (const o of revenueOrders) {
-        const method = o.pos_payment_method ?? o.payment_mode ?? "cash";
+        // `is_pos` is the only online/local discriminator — same as backend.
+        const channel = o.is_pos ? "local" : "online";
+        const ch = byChannel.get(channel) ?? { revenue_minor: 0, count: 0 };
+        ch.revenue_minor += o.total_minor ?? 0;
+        ch.count += 1;
+        byChannel.set(channel, ch);
+        // POS uses the tendered method; online orders cannot truthfully be
+        // labelled card/MoMo from order data, so prepaid stays "online_prepaid".
+        const method = o.is_pos
+            ? (o.pos_payment_method ?? "cash")
+            : o.payment_mode === "pay_on_delivery"
+                ? "pay_on_delivery"
+                : "online_prepaid";
         const m = byMethod.get(method) ?? { revenue_minor: 0, count: 0 };
         m.revenue_minor += o.total_minor ?? 0;
         m.count += 1;
@@ -114,6 +131,25 @@ export function aggregateLocal(orders, period, opts, range) {
         d.revenue_minor += o.total_minor ?? 0;
         d.count += 1;
         byDay.set(day, d);
+        if (o.is_pos) {
+            const key = o.user?.id ?? "unassigned";
+            const teller = byTeller.get(key) ?? {
+                name: o.user?.full_name ?? "Unassigned",
+                revenue_minor: 0,
+                count: 0,
+            };
+            teller.revenue_minor += o.total_minor ?? 0;
+            teller.count += 1;
+            byTeller.set(key, teller);
+        }
+        const hourDate = new Date(o.inserted_at ?? "");
+        if (!Number.isNaN(hourDate.getTime())) {
+            const hour = String(hourDate.getUTCHours());
+            const h = byHour.get(hour) ?? { revenue_minor: 0, count: 0 };
+            h.revenue_minor += o.total_minor ?? 0;
+            h.count += 1;
+            byHour.set(hour, h);
+        }
         for (const it of o.items ?? []) {
             const name = it.menu_item?.name ?? "Unknown";
             const qty = it.quantity ?? 0;
@@ -131,30 +167,63 @@ export function aggregateLocal(orders, period, opts, range) {
         cancelled: filtered.filter((o) => o.status === "cancelled").length,
         pending: filtered.filter((o) => o.status === "pending").length,
     };
+    const by_channel = [...byChannel.entries()]
+        .map(([channel, v]) => ({
+        channel,
+        ...v,
+        percentage: pct(v.revenue_minor),
+    }))
+        .sort((a, b) => b.revenue_minor - a.revenue_minor);
+    const by_payment_method = [...byMethod.entries()]
+        .map(([method, v]) => ({
+        method,
+        ...v,
+        percentage: pct(v.revenue_minor),
+    }))
+        .sort((a, b) => b.revenue_minor - a.revenue_minor);
+    const by_order_type = [...byType.entries()]
+        .map(([type, v]) => ({ type, ...v }))
+        .sort((a, b) => b.revenue_minor - a.revenue_minor || a.type.localeCompare(b.type));
+    const by_teller = [...byTeller.entries()]
+        .map(([user_id, v]) => ({
+        user_id,
+        name: v.name,
+        revenue_minor: v.revenue_minor,
+        count: v.count,
+        average_order_value_minor: v.count
+            ? Math.floor(v.revenue_minor / v.count)
+            : 0,
+    }))
+        .sort((a, b) => b.revenue_minor - a.revenue_minor);
+    const by_hour = [...byHour.entries()]
+        .map(([hour, v]) => ({
+        hour: Number(hour),
+        revenue_minor: v.revenue_minor,
+        count: v.count,
+    }))
+        .sort((a, b) => a.hour - b.hour);
+    const currency = revenueOrders[0]?.currency ?? "GHS";
     if (opts.forRevenueSummary) {
         return {
             period,
+            currency,
             total_revenue_minor,
             total_orders,
             average_order_value_minor,
-            by_payment_method: [...byMethod.entries()]
-                .map(([method, v]) => ({
-                method,
-                ...v,
-                percentage: pct(v.revenue_minor),
-            }))
-                .sort((a, b) => b.revenue_minor - a.revenue_minor),
-            by_order_type: [...byType.entries()]
-                .map(([type, v]) => ({ type, ...v }))
-                .sort((a, b) => b.revenue_minor - a.revenue_minor),
+            by_payment_method,
+            by_order_type,
             by_day: [...byDay.entries()]
                 .map(([date, v]) => ({ date, ...v }))
                 .sort((a, b) => a.date.localeCompare(b.date)),
+            by_channel,
+            by_teller,
+            by_hour,
             offline: true,
         };
     }
     return {
         period,
+        currency,
         total_revenue_minor,
         total_orders,
         average_order_value_minor,
@@ -171,48 +240,130 @@ export function aggregateLocal(orders, period, opts, range) {
         revenue_by_day: [...byDay.entries()]
             .map(([date, v]) => ({ date, revenue_minor: v.revenue_minor }))
             .sort((a, b) => a.date.localeCompare(b.date)),
+        by_channel,
+        by_payment_method,
+        by_order_type,
+        by_teller,
+        by_hour,
         offline: true,
     };
 }
 async function localOrders(businessId) {
-    const { data } = await listLocalOrders(businessId, {}, 1, 500);
-    return data ?? [];
+    const pageSize = 500;
+    const first = await listLocalOrders(businessId, {}, 1, pageSize);
+    const rows = [...(first.data ?? [])];
+    const total = first.total ?? rows.length;
+    for (let page = 2; rows.length < total; page += 1) {
+        const next = await listLocalOrders(businessId, {}, page, pageSize);
+        const batch = next.data ?? [];
+        if (batch.length === 0)
+            break;
+        rows.push(...batch);
+    }
+    return rows;
 }
 function hasCustomRange(period, range) {
     return (period !== "custom" || Boolean(range?.date_from && range?.date_to));
 }
+const ORDER_PULL_COOLDOWN_MS = 15000;
+const lastOrderPullAt = new Map();
+/**
+ * Refresh the local order read model in the background. Analytics renders
+ * from SQLite immediately; this pull is what makes a freshly opened screen
+ * converge with the server without blocking the first paint.
+ */
+async function syncOrdersForAnalytics(businessId, queryClient) {
+    const now = Date.now();
+    const last = lastOrderPullAt.get(businessId) ?? 0;
+    if (now - last < ORDER_PULL_COOLDOWN_MS)
+        return;
+    lastOrderPullAt.set(businessId, now);
+    try {
+        await pullRemoteOrders(businessId);
+        await Promise.all([
+            queryClient.invalidateQueries({ queryKey: SELLER_ANALYTICS_KEYS.all }),
+            queryClient.invalidateQueries({ queryKey: REVENUE_KEYS.all }),
+        ]);
+    }
+    catch (error) {
+        syncLogger.debug("Analytics", "background order sync failed", {
+            businessId,
+            err: String(error),
+        });
+    }
+}
+/**
+ * Keep local data when it knows about more orders than the server snapshot
+ * (e.g. an offline order still in the outbox). Otherwise the server snapshot
+ * wins because it may include older history the device has never pulled.
+ */
+function preferRemote(current, remote) {
+    const localOrders = current?.data?.total_orders ?? 0;
+    const remoteOrders = remote.data?.total_orders ?? 0;
+    return remoteOrders >= localOrders ? remote : (current ?? remote);
+}
+async function buildLocalAnalytics(businessId, period, range) {
+    try {
+        return {
+            data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: false }, range),
+        };
+    }
+    catch {
+        return {
+            data: aggregateLocal([], period, { forRevenueSummary: false }, range),
+        };
+    }
+}
+async function buildLocalRevenue(businessId, period, range) {
+    try {
+        return {
+            data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: true }, range),
+        };
+    }
+    catch {
+        return {
+            data: aggregateLocal([], period, { forRevenueSummary: true }, range),
+        };
+    }
+}
 export function useSellerAnalyticsQuery(period = "today", enabled = true, range) {
     const businessId = useBusinessId();
     const online = useIsEffectivelyOnline();
+    const queryClient = useQueryClient();
     const customReady = hasCustomRange(period, range);
+    const queryKey = SELLER_ANALYTICS_KEYS.analytics(businessId ?? "", period, range);
+    const active = enabled && Boolean(businessId) && customReady;
+    // Local-first: read SQLite on every query run. The network is a background
+    // refresh only, so opening the screen never waits on the server.
+    useEffect(() => {
+        if (!active || !online || !businessId)
+            return;
+        void syncOrdersForAnalytics(businessId, queryClient);
+    }, [active, online, businessId, queryClient]);
     return useQuery({
-        queryKey: SELLER_ANALYTICS_KEYS.analytics(businessId ?? "", period, range),
+        queryKey,
         queryFn: async () => {
-            if (!online) {
-                try {
-                    return {
-                        data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: false }, range),
-                    };
-                }
-                catch {
-                    return {
-                        data: aggregateLocal([], period, { forRevenueSummary: false }, range),
-                    };
-                }
-            }
-            try {
-                // The backend applies the period filter itself. An empty
-                // `revenue_by_day` is a valid result (e.g. no orders today) and must
-                // not be replaced with local rows — doing that hid real backend data.
-                return await analyticsService.fetchSellerAnalytics(businessId, period, range);
-            }
-            catch {
-                return {
-                    data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: false }, range),
-                };
+            const local = await buildLocalAnalytics(businessId, period, range);
+            if (online && businessId) {
+                // Do not await. Once the server snapshot arrives, merge it into the
+                // cache only when it is at least as complete as the local model.
+                void analyticsService
+                    .fetchSellerAnalytics(businessId, period, range)
+                    .then((remote) => {
+                    const remoteResponse = remote;
+                    const current = queryClient.getQueryData(queryKey);
+                    queryClient.setQueryData(queryKey, preferRemote(current, remoteResponse));
+                })
+                    .catch((error) => {
+                    syncLogger.debug("Analytics", "background analytics refresh failed", {
+                        businessId,
+                        err: String(error),
+                    });
+                });
             }
+            return local;
         },
-        enabled: enabled && Boolean(businessId) && customReady,
+        enabled: active,
         staleTime: 30000,
         ...OFFLINE_FIRST,
     });
@@ -220,34 +371,34 @@ export function useSellerAnalyticsQuery(period = "today", enabled = true, range)
 export function useRevenueSummaryQuery(period = "today", enabled = true, range) {
     const businessId = useBusinessId();
     const online = useIsEffectivelyOnline();
+    const queryClient = useQueryClient();
     const customReady = hasCustomRange(period, range);
+    const queryKey = REVENUE_KEYS.summary(businessId ?? "", period, range);
+    const active = enabled && Boolean(businessId) && customReady;
+    useEffect(() => {
+        if (!active || !online || !businessId)
+            return;
+        void syncOrdersForAnalytics(businessId, queryClient);
+    }, [active, online, businessId, queryClient]);
     return useQuery({
-        queryKey: REVENUE_KEYS.summary(businessId ?? "", period, range),
+        queryKey,
         queryFn: async () => {
-            if (!online) {
-                try {
-                    return {
-                        data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: true }, range),
-                    };
-                }
-                catch {
-                    return {
-                        data: aggregateLocal([], period, { forRevenueSummary: true }, range),
-                    };
-                }
-            }
-            try {
-                // Same contract as analytics: trust the backend period filter and
-                // only fall back to SQLite when the request itself fails.
-                return await analyticsService.fetchRevenueSummary(businessId, period, range);
-            }
-            catch {
-                return {
-                    data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: true }, range),
-                };
+            const local = await buildLocalRevenue(businessId, period, range);
+            if (online && businessId) {
+                void analyticsService
+                    .fetchRevenueSummary(businessId, period, range)
+                    .then((remote) => {
+                    const remoteResponse = remote;
+                    const current = queryClient.getQueryData(queryKey);
+                    queryClient.setQueryData(queryKey, preferRemote(current, remoteResponse));
+                })
+                    .catch((error) => {
+                    syncLogger.debug("Analytics", "background revenue refresh failed", { businessId, err: String(error) });
+                });
             }
+            return local;
         },
-        enabled: enabled && Boolean(businessId) && customReady,
+        enabled: active,
         staleTime: 30000,
         ...OFFLINE_FIRST,
     });

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

@@ -21,6 +21,7 @@ import { buildItemSnapshots, snapshotsToOrderLines } from "../domain/orders/snap
 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 { useAuthStore } from "../adapters/auth";
 import { canBusinessSync } from "./sync-guard";
 import { backoffDelayMs } from "./backoff";
 import { reportSyncFailure } from "../adapters/sync-failure";
@@ -121,6 +122,16 @@ function buildOptimisticOrder(command, payload, flowMode) {
     const now = new Date().toISOString();
     const method = payload.pos_payment_method ?? "cash";
     const isCash = method === "cash";
+    const authUser = useAuthStore.getState().user;
+    const teller = authUser
+        ? {
+            id: authUser.id,
+            full_name: authUser.full_name ?? authUser.email ?? "Staff",
+            email: authUser.email ?? "",
+            phone: authUser.phone ?? "",
+            avatar_url: authUser.avatar_url ?? null,
+        }
+        : null;
     const orderNumber = payload.order_number ?? generateOrderNumberForBusiness(command.business_id);
     return {
         id: command.entity_id ?? command.command_id,
@@ -162,7 +173,8 @@ function buildOptimisticOrder(command, payload, flowMode) {
         delivery_address: null,
         delivery_lat: null,
         delivery_lng: null,
-        user: null,
+        user: teller,
+        teller,
         items: snapshotsToOrderLines(snapshots, command.command_id),
         inserted_at: now,
     };

package/dist/test-helpers/memory-driver.js

@@ -189,7 +189,7 @@ export function createMemoryDriver() {
             }
             // orders insert (primary DB)
             if (s.includes("INSERT INTO orders")) {
-                const [id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, paid_at, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, updated_at, hlc] = args;
+                const [id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, paid_at, customer_name, customer_phone, pos_payment_method, payment_mode, delivery_id, business, user, inserted_at, updated_at, hlc] = args;
                 const existing = tables.orders.find((r) => r.id === id);
                 // LWW check via hlc (if existing and incoming older, skip) — only for
                 // the local/LAN write path. The server write path (`upsertServerOrder`)
@@ -198,10 +198,10 @@ export function createMemoryDriver() {
                 if (existing) {
                     if (lwwGuarded && hlc && existing.hlc && hlc < existing.hlc)
                         return { lastInsertRowId: 0, changes: 0 };
-                    Object.assign(existing, { business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, paid_at: paid_at ?? existing.paid_at ?? null, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, updated_at, hlc });
+                    Object.assign(existing, { business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, paid_at: paid_at ?? existing.paid_at ?? null, customer_name, customer_phone, pos_payment_method, payment_mode, delivery_id, business, user, inserted_at, updated_at, hlc });
                     return { lastInsertRowId: 0, changes: 1 };
                 }
-                tables.orders.push({ id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, paid_at: paid_at ?? null, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, updated_at, hlc, deleted_at: null });
+                tables.orders.push({ id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, paid_at: paid_at ?? null, customer_name, customer_phone, pos_payment_method, payment_mode, delivery_id, business, user, inserted_at, updated_at, hlc, deleted_at: null });
                 return { lastInsertRowId: 1, changes: 1 };
             }
             // sync_jobs insert

package/package.json

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