@teincfood/core 0.7.8 → 0.8.0

package/dist/catalog/hooks.js

@@ -7,13 +7,13 @@ import { useMemo } from "react";
 import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useSyncExternalStore } from "react";
 import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
-import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
 import { menuService } from "../adapters/services";
 import { getReferenceData } from "../reference/operations";
 import { openSyncDatabase } from "../db/connection";
 import { referenceSyncService } from "../reference/service";
 import { emitReferenceChanged } from "../reference/events";
 import { runOfflineCapableMutation } from "../sync/offline-capable";
+import { useIsEffectivelyOnline } from "../hooks/use-infinite-list";
 export const CATALOG_KEYS = {
     all: ["menu"],
     items: (businessId) => [...CATALOG_KEYS.all, "items", businessId],
@@ -23,13 +23,9 @@ function useBusinessId() {
     const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
     return id ?? undefined;
 }
-function useIsOnline() {
-    const s = useSyncExternalStore(subscribeConnectivity, getConnectivityState, getConnectivityState);
-    return s.isOnline;
-}
 export function useMenuItemsQuery(filters, enabled = true) {
     const businessId = useBusinessId();
-    const isOnline = useIsOnline();
+    const isOnline = useIsEffectivelyOnline();
     // Cached reference query — synchronous from SQLite via query
     const cachedQuery = useQuery({
         queryKey: [...CATALOG_KEYS.items(businessId), "cached", filters],
@@ -97,7 +93,7 @@ export function useMenuItemsQuery(filters, enabled = true) {
 }
 export function useMenuCategoriesQuery() {
     const businessId = useBusinessId();
-    const isOnline = useIsOnline();
+    const isOnline = useIsEffectivelyOnline();
     const cachedQuery = useQuery({
         queryKey: [...CATALOG_KEYS.categories(businessId), "cached"],
         queryFn: async () => {
@@ -118,15 +114,28 @@ export function useMenuCategoriesQuery() {
         retry: false,
         networkMode: "offlineFirst",
     });
-    const data = (isOnline && networkQuery.data ? networkQuery.data : cachedQuery.data);
-    return { ...networkQuery, data, isPending: cachedQuery.isPending && !networkQuery.data };
+    const usingNetwork = isOnline && networkQuery.data;
+    const data = usingNetwork ? networkQuery.data : cachedQuery.data;
+    const hasCache = cachedQuery.data != null;
+    return {
+        ...networkQuery,
+        data,
+        isPending: cachedQuery.isPending && !networkQuery.data,
+        isError: hasCache ? false : networkQuery.isError,
+        error: hasCache ? null : networkQuery.error,
+    };
 }
 // Mutations — offline-capable
 export function useCreateMenuItemMutation() {
     const businessId = useBusinessId();
     const qc = useQueryClient();
     return useMutation({
-        mutationFn: (payload) => runOfflineCapableMutation({ run: () => menuService.createMenuItem(payload), commandType: "menu:create_item", businessId: businessId, payload }),
+        mutationFn: (payload) => {
+            // cacheRecord is local-cache only — never on the wire.
+            const { cacheRecord: _omit, ...wire } = payload;
+            void _omit;
+            return runOfflineCapableMutation({ run: () => menuService.createMenuItem(wire), commandType: "menu:create_item", businessId: businessId, entityId: payload.id, payload });
+        },
         onSuccess: () => {
             qc.invalidateQueries({ queryKey: CATALOG_KEYS.items(businessId) });
             if (businessId)
@@ -138,7 +147,11 @@ export function useUpdateMenuItemMutation() {
     const businessId = useBusinessId();
     const qc = useQueryClient();
     return useMutation({
-        mutationFn: ({ id, payload }) => runOfflineCapableMutation({ run: () => menuService.updateMenuItem(id, payload), commandType: "menu:update_item", businessId: businessId, entityId: id, payload }),
+        mutationFn: ({ id, payload }) => {
+            const { cacheRecord: _omit, ...wire } = payload;
+            void _omit;
+            return runOfflineCapableMutation({ run: () => menuService.updateMenuItem(id, wire), commandType: "menu:update_item", businessId: businessId, entityId: id, payload });
+        },
         onSuccess: () => {
             qc.invalidateQueries({ queryKey: CATALOG_KEYS.items(businessId) });
             if (businessId)
@@ -158,3 +171,61 @@ export function useDeleteMenuItemMutation() {
         },
     });
 }
+export function useToggleItemAvailabilityMutation() {
+    const businessId = useBusinessId();
+    const qc = useQueryClient();
+    return useMutation({
+        // Availability is an update_item with an availability patch — same engine
+        // route (cloud → LAN → queue), same cache convergence.
+        mutationFn: ({ id, available }) => runOfflineCapableMutation({ run: () => menuService.updateMenuItem(id, { available }), commandType: "menu:update_item", businessId: businessId, entityId: id, payload: { id, available } }),
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: CATALOG_KEYS.items(businessId) });
+            if (businessId)
+                emitReferenceChanged(businessId, ["menu:items"]);
+        },
+    });
+}
+export function useCreateMenuCategoryMutation() {
+    const businessId = useBusinessId();
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: (payload) => {
+            const { cacheRecord: _omit, ...wire } = payload;
+            void _omit;
+            return runOfflineCapableMutation({ run: () => menuService.createCategory(businessId, wire), commandType: "menu:create_category", businessId: businessId, entityId: payload.id, payload });
+        },
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: CATALOG_KEYS.categories(businessId) });
+            if (businessId)
+                emitReferenceChanged(businessId, ["menu:categories"]);
+        },
+    });
+}
+export function useUpdateMenuCategoryMutation() {
+    const businessId = useBusinessId();
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ id, payload }) => {
+            const { cacheRecord: _omit, ...wire } = payload;
+            void _omit;
+            return runOfflineCapableMutation({ run: () => menuService.updateCategory(id, wire), commandType: "menu:update_category", businessId: businessId, entityId: id, payload: { ...payload, id } });
+        },
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: CATALOG_KEYS.categories(businessId) });
+            if (businessId)
+                emitReferenceChanged(businessId, ["menu:categories"]);
+        },
+    });
+}
+export function useDeleteMenuCategoryMutation() {
+    const businessId = useBusinessId();
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: (id) => runOfflineCapableMutation({ run: () => menuService.deleteCategory(id), commandType: "menu:delete_category", businessId: businessId, entityId: id, payload: { id } }),
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: CATALOG_KEYS.categories(businessId) });
+            if (businessId)
+                emitReferenceChanged(businessId, ["menu:categories"]);
+        },
+    });
+}

package/dist/db/migrations.js

@@ -134,4 +134,278 @@ export const MIGRATIONS = [
             catch { }
         },
     },
+    {
+        version: 5,
+        up: async (db) => {
+            // Real orders table — primary DB like backend Orders, device-partitioned by UUID + DD-RRR-CCC
+            await db.execAsync(`
+          CREATE TABLE IF NOT EXISTS orders (
+            id TEXT PRIMARY KEY,
+            business_id TEXT NOT NULL,
+            order_number TEXT NOT NULL,
+            callout_number INTEGER,
+            status TEXT NOT NULL,
+            order_type TEXT,
+            is_pos INTEGER NOT NULL DEFAULT 0,
+            items TEXT NOT NULL,
+            subtotal_minor INTEGER NOT NULL DEFAULT 0,
+            total_minor INTEGER NOT NULL DEFAULT 0,
+            tax_minor INTEGER NOT NULL DEFAULT 0,
+            tax_lines TEXT,
+            payment TEXT,
+            customer_name TEXT,
+            customer_phone TEXT,
+            pos_payment_method TEXT,
+            delivery_id TEXT,
+            business TEXT,
+            user TEXT,
+            inserted_at TEXT NOT NULL,
+            hlc TEXT,
+            deleted_at TEXT
+          );
+          CREATE UNIQUE INDEX IF NOT EXISTS idx_orders_order_number_business ON orders(business_id, order_number);
+          CREATE INDEX IF NOT EXISTS idx_orders_business_status ON orders(business_id, status);
+          CREATE INDEX IF NOT EXISTS idx_orders_business_ispos ON orders(business_id, is_pos);
+          CREATE INDEX IF NOT EXISTS idx_orders_inserted ON orders(business_id, inserted_at DESC);
+          CREATE INDEX IF NOT EXISTS idx_orders_hlc ON orders(hlc);
+        `);
+            // Backfill from existing entity_snapshots type='order' if any (best-effort, ignore failures on fresh DB)
+            try {
+                await db.execAsync(`
+          INSERT OR IGNORE INTO orders (id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, hlc)
+          SELECT
+            json_extract(payload, '$.id') as id,
+            json_extract(payload, '$.business_id') as business_id,
+            json_extract(payload, '$.order_number') as order_number,
+            json_extract(payload, '$.callout_number') as callout_number,
+            json_extract(payload, '$.status') as status,
+            json_extract(payload, '$.order_type') as order_type,
+            CASE WHEN json_extract(payload, '$.is_pos') THEN 1 ELSE 0 END as is_pos,
+            json_extract(payload, '$.items') as items,
+            json_extract(payload, '$.subtotal_minor') as subtotal_minor,
+            json_extract(payload, '$.total_minor') as total_minor,
+            json_extract(payload, '$.tax_minor') as tax_minor,
+            json_extract(payload, '$.tax_lines') as tax_lines,
+            json_extract(payload, '$.payment') as payment,
+            json_extract(payload, '$.customer_name') as customer_name,
+            json_extract(payload, '$.customer_phone') as customer_phone,
+            json_extract(payload, '$.pos_payment_method') as pos_payment_method,
+            json_extract(payload, '$.delivery_id') as delivery_id,
+            json_extract(payload, '$.business') as business,
+            json_extract(payload, '$.user') as user,
+            json_extract(payload, '$.inserted_at') as inserted_at,
+            json_extract(payload, '$.hlc') as hlc
+          FROM entity_snapshots WHERE entity_type='order' AND json_extract(payload, '$.id') IS NOT NULL;
+        `);
+            }
+            catch { }
+            // Sync outbox for background backend sync — secondary, not UI-blocking
+            await db.execAsync(`
+          CREATE TABLE IF NOT EXISTS sync_jobs (
+            id TEXT PRIMARY KEY,
+            business_id TEXT NOT NULL,
+            command_type TEXT NOT NULL,
+            entity_id TEXT,
+            payload TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'pending',
+            attempts INTEGER NOT NULL DEFAULT 0,
+            last_error TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+          );
+          CREATE INDEX IF NOT EXISTS idx_sync_jobs_business ON sync_jobs(business_id, status);
+        `);
+        },
+    },
+    {
+        version: 6,
+        up: async (db) => {
+            // v5 backfilled only entity_type='order' which never exists — real data is
+            // entity_type='seller_orders' with {data: SellerOrder[]}. Backfill those via json_each.
+            // idempotent INSERT OR IGNORE; also handles legacy 'order' type with COALESCE timestamps.
+            try {
+                await db.execAsync(`
+          INSERT OR IGNORE INTO orders (id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, hlc)
+          SELECT
+            json_extract(value, '$.id') as id,
+            COALESCE(json_extract(value, '$.business_id'), json_extract(value, '$.business.id'), '') as business_id,
+            json_extract(value, '$.order_number') as order_number,
+            json_extract(value, '$.callout_number') as callout_number,
+            json_extract(value, '$.status') as status,
+            json_extract(value, '$.order_type') as order_type,
+            CASE WHEN json_extract(value, '$.is_pos') THEN 1 ELSE 0 END as is_pos,
+            COALESCE(json_extract(value, '$.items'), '[]') as items,
+            COALESCE(json_extract(value, '$.subtotal_minor'), 0) as subtotal_minor,
+            COALESCE(json_extract(value, '$.total_minor'), 0) as total_minor,
+            COALESCE(json_extract(value, '$.tax_minor'), 0) as tax_minor,
+            json_extract(value, '$.tax_lines') as tax_lines,
+            json_extract(value, '$.payment') as payment,
+            json_extract(value, '$.customer_name') as customer_name,
+            json_extract(value, '$.customer_phone') as customer_phone,
+            json_extract(value, '$.pos_payment_method') as pos_payment_method,
+            json_extract(value, '$.delivery_id') as delivery_id,
+            json_extract(value, '$.business') as business,
+            json_extract(value, '$.user') as user,
+            COALESCE(json_extract(value, '$.inserted_at'), json_extract(value, '$.created_at'), last_event_timestamp, datetime('now')) as inserted_at,
+            COALESCE(json_extract(value, '$.hlc'), last_event_timestamp, datetime('now')) as hlc
+          FROM entity_snapshots, json_each(json_extract(payload, '$.data'))
+          WHERE entity_type='seller_orders' AND json_extract(value, '$.id') IS NOT NULL AND json_extract(value, '$.order_number') IS NOT NULL;
+        `);
+            }
+            catch { }
+            try {
+                await db.execAsync(`
+          INSERT OR IGNORE INTO orders (id, business_id, order_number, callout_number, status, order_type, is_pos, items, subtotal_minor, total_minor, tax_minor, tax_lines, payment, customer_name, customer_phone, pos_payment_method, delivery_id, business, user, inserted_at, hlc)
+          SELECT
+            json_extract(payload, '$.id') as id,
+            COALESCE(json_extract(payload, '$.business_id'), '') as business_id,
+            json_extract(payload, '$.order_number') as order_number,
+            json_extract(payload, '$.callout_number') as callout_number,
+            json_extract(payload, '$.status') as status,
+            json_extract(payload, '$.order_type') as order_type,
+            CASE WHEN json_extract(payload, '$.is_pos') THEN 1 ELSE 0 END as is_pos,
+            COALESCE(json_extract(payload, '$.items'), '[]') as items,
+            COALESCE(json_extract(payload, '$.subtotal_minor'), 0) as subtotal_minor,
+            COALESCE(json_extract(payload, '$.total_minor'), 0) as total_minor,
+            COALESCE(json_extract(payload, '$.tax_minor'), 0) as tax_minor,
+            json_extract(payload, '$.tax_lines') as tax_lines,
+            json_extract(payload, '$.payment') as payment,
+            json_extract(payload, '$.customer_name') as customer_name,
+            json_extract(payload, '$.customer_phone') as customer_phone,
+            json_extract(payload, '$.pos_payment_method') as pos_payment_method,
+            json_extract(payload, '$.delivery_id') as delivery_id,
+            json_extract(payload, '$.business') as business,
+            json_extract(payload, '$.user') as user,
+            COALESCE(json_extract(payload, '$.inserted_at'), last_event_timestamp, datetime('now')) as inserted_at,
+            COALESCE(json_extract(payload, '$.hlc'), last_event_timestamp, datetime('now')) as hlc
+          FROM entity_snapshots WHERE entity_type='order' AND json_extract(payload, '$.id') IS NOT NULL;
+        `);
+            }
+            catch { }
+        },
+    },
+    {
+        version: 7,
+        up: async (db) => {
+            // Fix [object Object] order_number bug from 0.7.13 domain/service toString() on object
+            try {
+                await db.execAsync(`DELETE FROM orders WHERE order_number = '[object Object]';`);
+            }
+            catch { }
+            try {
+                await db.execAsync(`DELETE FROM sync_jobs WHERE payload LIKE '%[object Object]%';`);
+            }
+            catch { }
+            try {
+                await db.execAsync(`DELETE FROM entity_snapshots WHERE payload LIKE '%[object Object]%';`);
+            }
+            catch { }
+        },
+    },
+    {
+        version: 8,
+        up: async (db) => {
+            // Full drop legacy — new DB, no fallback (confirmed). Keep only orders, sync_jobs, reference_data, migrations.
+            // Drops commands, events, entity_snapshots (replaced by orders primary).
+            try {
+                await db.execAsync(`DROP TABLE IF EXISTS commands;`);
+            }
+            catch { }
+            try {
+                await db.execAsync(`DROP TABLE IF EXISTS events;`);
+            }
+            catch { }
+            // entity_snapshots kept for reference_data fallback? No — new DB no old stuff, drop all snapshots
+            try {
+                await db.execAsync(`DROP TABLE IF EXISTS entity_snapshots;`);
+            }
+            catch { }
+            // Recreate minimal empty entity_snapshots if later code expects it (reference fallback disabled for orders)
+            try {
+                await db.execAsync(`
+          CREATE TABLE IF NOT EXISTS entity_snapshots (
+            entity_type TEXT NOT NULL,
+            entity_id TEXT NOT NULL,
+            business_id TEXT,
+            last_event_id TEXT NOT NULL,
+            last_event_timestamp TEXT NOT NULL,
+            payload TEXT NOT NULL,
+            PRIMARY KEY (entity_type, entity_id)
+          );
+          CREATE INDEX IF NOT EXISTS idx_snapshots_entity_id ON entity_snapshots(entity_id);
+          CREATE INDEX IF NOT EXISTS idx_snapshots_business ON entity_snapshots(business_id, entity_type);
+        `);
+            }
+            catch { }
+            // Clean any stale TFL remnants that survived
+            try {
+                await db.execAsync(`DELETE FROM sync_jobs WHERE payload LIKE '%TFL-%';`);
+            }
+            catch { }
+        },
+    },
+    {
+        version: 9,
+        up: async (db) => {
+            // v8 dropped commands/events as "legacy" while the engine outbox
+            // (commandQueueService.enqueue) and the event journal (insertEvent,
+            // hydrate, replay) still depend on them. On any DB that ran v8, every
+            // queue/journal write throws "no such table", breaking offline queue
+            // on all transports. Recreate exactly (IF NOT EXISTS: healthy DBs no-op).
+            await db.execAsync(`
+          CREATE TABLE IF NOT EXISTS commands (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            command_id TEXT NOT NULL UNIQUE,
+            command_type TEXT NOT NULL,
+            command_version TEXT NOT NULL,
+            business_id TEXT NOT NULL,
+            entity_id TEXT,
+            user_id TEXT NOT NULL,
+            device_id TEXT NOT NULL,
+            payload TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'pending',
+            error TEXT,
+            retry_count INTEGER NOT NULL DEFAULT 0,
+            last_attempted_at TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+          );
+
+          CREATE INDEX IF NOT EXISTS idx_commands_status ON commands(status);
+          CREATE INDEX IF NOT EXISTS idx_commands_business ON commands(business_id);
+          CREATE INDEX IF NOT EXISTS idx_commands_entity ON commands(entity_id);
+          CREATE INDEX IF NOT EXISTS idx_commands_created_at ON commands(created_at);
+        `);
+            await db.execAsync(`
+          CREATE TABLE IF NOT EXISTS events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            event_id TEXT NOT NULL UNIQUE,
+            event_type TEXT NOT NULL,
+            event_version TEXT NOT NULL,
+            entity_id TEXT NOT NULL,
+            user_id TEXT NOT NULL,
+            device_id TEXT NOT NULL,
+            payload TEXT NOT NULL,
+            origin TEXT NOT NULL,
+            synced_to_cloud INTEGER NOT NULL DEFAULT 0,
+            timestamp TEXT NOT NULL,
+            persisted_at TEXT NOT NULL
+          );
+
+          CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
+          CREATE INDEX IF NOT EXISTS idx_events_entity ON events(entity_id);
+          CREATE INDEX IF NOT EXISTS idx_events_synced ON events(synced_to_cloud);
+          CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+          CREATE INDEX IF NOT EXISTS idx_events_origin ON events(origin);
+        `);
+        },
+    },
+    {
+        version: 10,
+        up: async (db) => {
+            await db.execAsync(`
+          ALTER TABLE orders ADD COLUMN updated_at TEXT;
+        `);
+        },
+    },
 ];

package/dist/db/operations.d.ts

@@ -39,10 +39,61 @@ export interface UpsertEntitySnapshotInput<T = unknown> {
     payload: T;
 }
 export declare function upsertEntitySnapshot<T>(db: SQLiteDatabase, input: UpsertEntitySnapshotInput<T>): Promise<void>;
-export declare function getEntitySnapshot<T>(db: SQLiteDatabase, entityType: string, entityId: string): Promise<EntitySnapshot<T> | null>;
-export declare function getEntitySnapshotsByType<T>(db: SQLiteDatabase, entityType: string): Promise<EntitySnapshot<T>[]>;
+export declare function getEntitySnapshot<T>(db: SQLiteDatabase, entityType: string, entityId: string, businessId?: string | null): Promise<EntitySnapshot<T> | null>;
+export declare function getEntitySnapshotsByType<T>(db: SQLiteDatabase, entityType: string, businessId?: string | null): Promise<EntitySnapshot<T>[]>;
 export declare function deleteEntitySnapshot(db: SQLiteDatabase, entityType: string, entityId: string): Promise<void>;
 export declare function pruneEntitySnapshots(db: SQLiteDatabase, entityType: string, cutoffIso: string): Promise<void>;
+export interface OrderRow {
+    id: string;
+    business_id: string;
+    order_number: string;
+    callout_number: number | null;
+    status: string;
+    order_type: string | null;
+    is_pos: number;
+    items: string;
+    subtotal_minor: number;
+    total_minor: number;
+    tax_minor: number;
+    tax_lines: string | null;
+    payment: string | null;
+    customer_name: string | null;
+    customer_phone: string | null;
+    pos_payment_method: string | null;
+    delivery_id: string | null;
+    business: string | null;
+    user: string | null;
+    inserted_at: string;
+    updated_at: string | null;
+    hlc: string | null;
+    deleted_at: string | null;
+}
+export declare function insertOrder(db: SQLiteDatabase, order: import("../types/api/seller.api").SellerOrder & {
+    hlc?: string;
+}): Promise<void>;
+export declare function getOrderById(db: SQLiteDatabase, businessId: string, idOrNumber: string): Promise<import("../types/api/seller.api").SellerOrder | null>;
+export declare function listOrders(db: SQLiteDatabase, businessId: string, filters?: {
+    status?: string;
+    q?: string;
+    is_pos?: string;
+    order_type?: string;
+    date_from?: string;
+    date_to?: string;
+}, page?: number, pageSize?: number): Promise<{
+    data: import("../types/api/seller.api").SellerOrder[];
+    total: number;
+}>;
+export declare function updateOrderStatus(db: SQLiteDatabase, businessId: string, orderId: string, toStatus: string, hlc?: string): Promise<void>;
+export declare function updateOrderPayment(db: SQLiteDatabase, businessId: string, orderId: string, patch: {
+    is_paid: boolean;
+    paid_at: string | null;
+}): Promise<void>;
 export declare function clearAllSyncData(db: SQLiteDatabase): Promise<void>;
+export declare function wipeForNewInstall(db: SQLiteDatabase): Promise<void>;
 export declare function clearReferenceData(db: SQLiteDatabase): Promise<void>;
+export declare function subscribeDbChanges(listener: (info: {
+    businessId?: string;
+    table: string;
+}) => void): () => void;
+export declare function notifyDbChange(businessId: string | undefined, table: string): void;
 export declare function clearCompletedCommandsAndOrphans(db: SQLiteDatabase): Promise<void>;