@teincfood/core 0.9.24 → 0.9.26

package/dist/catalog/hooks.js

@@ -73,9 +73,14 @@ export function useMenuItemsQuery(filters, enabled = true) {
         ? networkQuery.data.pages.flatMap((p) => p.data)
         : undefined;
     const data = isOnline && networkData !== undefined ? networkData : enabled ? filtered : undefined;
+    // A local snapshot (even an empty list) means the POS has something to
+    // render: never gate the whole screen on the in-flight network refresh.
+    const hasLocalSnapshot = cachedQuery.data != null;
+    const pending = cachedQuery.isPending || (!hasLocalSnapshot && networkQuery.isFetching);
     return {
         data,
-        isPending: cachedQuery.isPending && !networkData,
+        isPending: pending,
+        isLoading: pending,
         isFetching: networkQuery.isFetching,
         isError: cachedQuery.isError || networkQuery.isError,
         error: (cachedQuery.error ?? networkQuery.error),
@@ -117,10 +122,14 @@ export function useMenuCategoriesQuery() {
     const usingNetwork = isOnline && networkQuery.data;
     const data = usingNetwork ? networkQuery.data : cachedQuery.data;
     const hasCache = cachedQuery.data != null;
+    // Only report "loading" when there is nothing local to show; the network
+    // refresh must never hide an already-cached category list.
+    const pending = cachedQuery.isPending || (!hasCache && networkQuery.isFetching);
     return {
         ...networkQuery,
         data,
-        isPending: cachedQuery.isPending && !networkQuery.data,
+        isPending: pending,
+        isLoading: pending,
         isError: hasCache ? false : networkQuery.isError,
         error: hasCache ? null : networkQuery.error,
     };

package/dist/db/migrations.js

@@ -423,4 +423,29 @@ export const MIGRATIONS = [
         `);
         },
     },
+    {
+        version: 12,
+        up: async (db) => {
+            // Payment timestamp at the top level of the order.
+            //
+            // The server returns `paid_at` on the order and (for cash sales taken at
+            // the till) no payment transaction at all. Keeping the timestamp only
+            // inside the `payment` JSON blob meant every pull overwrote a locally
+            // paid cash order with the server's `{is_paid:false, paid_at:null}`,
+            // so the row read back as UNPAID. One column, backfilled from the blob,
+            // is the single local source of truth.
+            await db.execAsync(`
+          ALTER TABLE orders ADD COLUMN paid_at TEXT;
+        `);
+            try {
+                await db.execAsync(`
+            UPDATE orders
+               SET paid_at = json_extract(payment, '$.paid_at')
+             WHERE paid_at IS NULL
+               AND json_extract(payment, '$.paid_at') IS NOT NULL;
+          `);
+            }
+            catch { }
+        },
+    },
 ];

package/dist/db/operations.d.ts

@@ -66,10 +66,17 @@ export interface OrderRow {
     inserted_at: string;
     updated_at: string | null;
     hlc: string | null;
+    paid_at?: string | null;
     deleted_at: string | null;
     sync_failed_at?: string | null;
     sync_error?: string | null;
 }
+/** True when the order has any recorded payment. */
+export declare function isOrderPaid(order: {
+    is_paid?: boolean;
+    paid_at?: string | null;
+    payment?: unknown;
+} | null | undefined): boolean;
 export declare function insertOrder(db: SQLiteDatabase, order: import("../types/api/seller.api").SellerOrder & {
     hlc?: string;
 }): Promise<void>;

package/dist/db/operations.js

@@ -198,7 +198,47 @@ function rowToDomainEvent(row) {
         timestamp: row.timestamp,
     };
 }
+const EMPTY_PAYMENT = {
+    is_paid: false,
+    reference: null,
+    amount_minor: null,
+    currency: null,
+    paid_at: null,
+};
+/**
+ * Effective payment of a stored order.
+ *
+ * `payment` (server payment summary) is the primary shape, but the order's
+ * own `paid_at` column wins when the server did not report a payment. Cash
+ * sales taken at a POS terminal only carry `paid_at` — no payment
+ * transaction — so reading the blob alone made them look unpaid.
+ */
+function paymentStateOf(row) {
+    let parsed = {};
+    if (row.payment) {
+        try {
+            const value = JSON.parse(row.payment);
+            if (value && typeof value === "object")
+                parsed = value;
+        }
+        catch { }
+    }
+    const payment = { ...EMPTY_PAYMENT, ...parsed };
+    const paidAt = payment.paid_at ?? row.paid_at ?? null;
+    const isPaid = payment.is_paid === true || !!paidAt;
+    return { payment: { ...payment, paid_at: paidAt, is_paid: isPaid }, isPaid, paidAt };
+}
+/** True when the order has any recorded payment. */
+export function isOrderPaid(order) {
+    if (!order)
+        return false;
+    if (order.is_paid === true || order.paid_at)
+        return true;
+    const payment = order.payment;
+    return payment?.is_paid === true || !!payment?.paid_at;
+}
 function orderRowToSellerOrder(row) {
+    const { payment, isPaid, paidAt } = paymentStateOf(row);
     return {
         id: row.id,
         business_id: row.business_id,
@@ -212,7 +252,7 @@ function orderRowToSellerOrder(row) {
         total_minor: row.total_minor,
         tax_minor: row.tax_minor,
         tax_lines: row.tax_lines ? JSON.parse(row.tax_lines) : [],
-        payment: row.payment ? JSON.parse(row.payment) : { is_paid: false, reference: null, amount_minor: null, currency: null, paid_at: null },
+        payment,
         customer_name: row.customer_name,
         customer_phone: row.customer_phone,
         pos_payment_method: row.pos_payment_method,
@@ -222,15 +262,15 @@ function orderRowToSellerOrder(row) {
         delivery_lat: null,
         delivery_lng: null,
         user: row.user ? JSON.parse(row.user) : null,
-        currency: (row.payment ? JSON.parse(row.payment).currency : "GHS") ?? "GHS",
-        currency_code: (row.payment ? JSON.parse(row.payment).currency : "GHS") ?? "GHS",
+        currency: payment.currency ?? "GHS",
+        currency_code: payment.currency ?? "GHS",
         discount_minor: 0,
         promo_code: null,
         tip_minor: null,
         delivery_fee_minor: 0,
         delivery_status: null,
-        is_paid: row.payment ? JSON.parse(row.payment).is_paid ?? false : false,
-        paid_at: row.payment ? JSON.parse(row.payment).paid_at ?? null : null,
+        is_paid: isPaid,
+        paid_at: paidAt,
         inserted_at: row.inserted_at,
         updated_at: row.updated_at ?? row.inserted_at,
         sync_failed_at: row.sync_failed_at ?? null,
@@ -240,10 +280,13 @@ function orderRowToSellerOrder(row) {
 export async function insertOrder(db, order) {
     const hlc = order.hlc ?? 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, 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, 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), 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);
+    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);
     notifyDbChange(order.business_id, "orders");
 }
 export async function getOrderById(db, businessId, idOrNumber) {
@@ -253,7 +296,7 @@ export async function getOrderById(db, businessId, idOrNumber) {
 export async function getPendingOrderIntent(db, businessId, orderId) {
     const empty = { status: null, isPaid: false, hasPending: false };
     try {
-        const rows = await db.getAllAsync(`SELECT command_type FROM sync_jobs WHERE business_id = ? AND entity_id = ? AND status = 'pending' ORDER BY created_at ASC, rowid ASC;`, businessId, orderId);
+        const rows = await db.getAllAsync(`SELECT command_type, payload FROM sync_jobs WHERE business_id = ? AND entity_id = ? AND status = 'pending' ORDER BY created_at ASC, rowid ASC;`, businessId, orderId);
         if (!rows.length)
             return empty;
         let status = null;
@@ -266,6 +309,19 @@ export async function getPendingOrderIntent(db, businessId, orderId) {
             if (commandType === "payment:confirm_cash" || commandType === "order:confirm_cash") {
                 isPaid = true;
             }
+            // A cash sale is paid at the moment it is rung up — the queued create
+            // itself is the record of that intent. Without this, a pull landing
+            // before the create reaches the backend replaces the paid local row
+            // with the server's (older, unpaid) copy.
+            if (commandType === "order:create") {
+                try {
+                    const payload = row.payload ? JSON.parse(row.payload) : null;
+                    const method = payload?.pos_payment_method ?? "cash";
+                    if (method === "cash")
+                        isPaid = true;
+                }
+                catch { }
+            }
         }
         return { status, isPaid, hasPending: true };
     }
@@ -289,15 +345,35 @@ export async function upsertServerOrder(db, order, opts = {}) {
         return;
     const existing = await getOrderById(db, order.business_id, order.id);
     const status = opts.preserveStatus && existing ? existing.status : order.status;
-    const payment = opts.preservePayment && existing ? existing.payment : order.payment;
+    const serverPayment = (order.payment ?? {});
+    const serverPaidAt = order.paid_at ?? serverPayment.paid_at ?? null;
+    const serverIsPaid = order.is_paid === true || !!serverPaidAt || serverPayment.is_paid === true;
+    let payment;
+    if (existing &&
+        (opts.preservePayment || (!serverIsPaid && isOrderPaid(existing)))) {
+        // Keep the device's payment. A pull must never un-pay an order: the
+        // server copy of a cash sale rung up moments ago can lag behind, and it
+        // used to reset the row to UNPAID until the create finished syncing.
+        payment = { ...existing.payment };
+    }
+    else {
+        payment = {
+            ...serverPayment,
+            is_paid: serverIsPaid,
+            paid_at: serverPaidAt,
+            amount_minor: serverPayment.amount_minor ?? order.total_minor ?? null,
+            currency: serverPayment.currency ?? order.currency_code ?? null,
+        };
+    }
+    const paidAt = payment.paid_at ?? null;
     const hlc = order.hlc ??
         order.updated_at ??
         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, 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, 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), 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, 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);
     notifyDbChange(order.business_id, "orders");
 }
 export async function listOrders(db, businessId, filters, page = 1, pageSize = 20) {
@@ -318,11 +394,13 @@ export async function listOrders(db, businessId, filters, page = 1, pageSize = 2
         where.push("order_type = ?");
         args.push(filters.order_type);
     }
+    // Paid means "the order has a payment timestamp" (cash at the till) or the
+    // payment blob says so (gateway payment) — mirroring the backend filter.
     if (filters?.is_paid === "paid") {
-        where.push("json_extract(payment, '$.is_paid') = 1");
+        where.push("(json_extract(payment, '$.is_paid') = 1 OR paid_at IS NOT NULL)");
     }
     else if (filters?.is_paid === "unpaid") {
-        where.push("(json_extract(payment, '$.is_paid') IS NULL OR json_extract(payment, '$.is_paid') = 0)");
+        where.push("(COALESCE(json_extract(payment, '$.is_paid'), 0) = 0 AND paid_at IS NULL)");
     }
     if (filters?.q) {
         where.push("(order_number LIKE ? OR customer_name LIKE ? OR customer_phone LIKE ?)");
@@ -366,7 +444,7 @@ export async function updateOrderPayment(db, businessId, orderId, patch) {
     if (!row)
         return;
     const payment = { ...row.payment, is_paid: patch.is_paid, paid_at: patch.paid_at };
-    await db.runAsync(`UPDATE orders SET payment = ?, hlc = ? WHERE business_id = ? AND (id = ? OR order_number = ?);`, JSON.stringify(payment), new Date().toISOString(), businessId, orderId, orderId);
+    await db.runAsync(`UPDATE orders SET payment = ?, paid_at = COALESCE(?, paid_at), hlc = ? WHERE business_id = ? AND (id = ? OR order_number = ?);`, JSON.stringify(payment), patch.is_paid ? patch.paid_at : null, new Date().toISOString(), businessId, orderId, orderId);
     notifyDbChange(businessId, "orders");
 }
 /**

package/dist/domain/orders/order-flow.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Business-configurable fulfilment flow for terminal / business-app orders.
+ *
+ * Buyer-placed online orders always use the full pipeline
+ * (accept → preparing → ready → completed). Orders rung up on a POS terminal
+ * or in the business app follow the business setting:
+ *
+ *   "staged" (default) — same pipeline as online orders.
+ *   "direct"           — the sale is completed the moment it is taken, so the
+ *                        order is born `delivered` and no pipeline buttons are
+ *                        offered.
+ *
+ * The setting lives on the business (`businesses.pos_order_flow`) and is
+ * cached in the `business:profile` reference record, so it is readable while
+ * offline.
+ */
+import type { SQLiteDatabase } from "../../adapters/sqlite";
+export type OrderFlowMode = "staged" | "direct";
+export declare const DEFAULT_ORDER_FLOW_MODE: OrderFlowMode;
+/** Coerce any server/local value into a known mode. */
+export declare function normalizeOrderFlowMode(value: unknown): OrderFlowMode;
+export declare function isDirectOrderFlow(value: unknown): boolean;
+/**
+ * Read `pos_order_flow` out of a `business:profile` payload. Accepts both the
+ * reference-data envelope (`{ data: {...} }`) and a bare profile object.
+ */
+export declare function orderFlowModeFromProfile(payload: unknown): OrderFlowMode;
+/**
+ * Cached business flow mode (works fully offline). Falls back to "staged" when
+ * the profile has never been synced — the safe, full-pipeline default.
+ */
+export declare function getBusinessOrderFlowMode(businessId: string, db?: SQLiteDatabase): Promise<OrderFlowMode>;
+/**
+ * Status a POS/business-app order starts in.
+ *
+ * Cash sales in direct flow are complete on creation. Anything that still
+ * needs money (mobile money / card) must stay `awaiting_payment` first — the
+ * backend moves it to `accepted` (staged) or `delivered` (direct) once the
+ * payment lands.
+ */
+export declare function initialPosOrderStatus(paymentMethod: string | null | undefined, mode: OrderFlowMode): "accepted" | "awaiting_payment" | "delivered";

package/dist/domain/orders/order-flow.js

@@ -0,0 +1,66 @@
+/**
+ * Business-configurable fulfilment flow for terminal / business-app orders.
+ *
+ * Buyer-placed online orders always use the full pipeline
+ * (accept → preparing → ready → completed). Orders rung up on a POS terminal
+ * or in the business app follow the business setting:
+ *
+ *   "staged" (default) — same pipeline as online orders.
+ *   "direct"           — the sale is completed the moment it is taken, so the
+ *                        order is born `delivered` and no pipeline buttons are
+ *                        offered.
+ *
+ * The setting lives on the business (`businesses.pos_order_flow`) and is
+ * cached in the `business:profile` reference record, so it is readable while
+ * offline.
+ */
+import { openSyncDatabase } from "../../db/connection";
+import { getReferenceData } from "../../reference/operations";
+export const DEFAULT_ORDER_FLOW_MODE = "staged";
+/** Coerce any server/local value into a known mode. */
+export function normalizeOrderFlowMode(value) {
+    return value === "direct" ? "direct" : DEFAULT_ORDER_FLOW_MODE;
+}
+export function isDirectOrderFlow(value) {
+    return normalizeOrderFlowMode(value) === "direct";
+}
+/**
+ * Read `pos_order_flow` out of a `business:profile` payload. Accepts both the
+ * reference-data envelope (`{ data: {...} }`) and a bare profile object.
+ */
+export function orderFlowModeFromProfile(payload) {
+    if (!payload || typeof payload !== "object")
+        return DEFAULT_ORDER_FLOW_MODE;
+    const record = payload;
+    return normalizeOrderFlowMode(record.data?.pos_order_flow ?? record.pos_order_flow);
+}
+/**
+ * Cached business flow mode (works fully offline). Falls back to "staged" when
+ * the profile has never been synced — the safe, full-pipeline default.
+ */
+export async function getBusinessOrderFlowMode(businessId, db) {
+    if (!businessId)
+        return DEFAULT_ORDER_FLOW_MODE;
+    try {
+        const connection = db ?? (await openSyncDatabase());
+        const record = await getReferenceData(connection, businessId, "business:profile");
+        return orderFlowModeFromProfile(record?.payload);
+    }
+    catch {
+        return DEFAULT_ORDER_FLOW_MODE;
+    }
+}
+/**
+ * Status a POS/business-app order starts in.
+ *
+ * Cash sales in direct flow are complete on creation. Anything that still
+ * needs money (mobile money / card) must stay `awaiting_payment` first — the
+ * backend moves it to `accepted` (staged) or `delivered` (direct) once the
+ * payment lands.
+ */
+export function initialPosOrderStatus(paymentMethod, mode) {
+    const method = paymentMethod ?? "cash";
+    if (method !== "cash")
+        return "awaiting_payment";
+    return mode === "direct" ? "delivered" : "accepted";
+}

package/dist/domain/orders/service.d.ts

@@ -1,7 +1,8 @@
 /**
  * Local Orders Service — SQLite is real DB (like backend Orders).
  * Device-partitioned by UUID PK + DD-RRR-CCC per business.
- * is_pos orders are accepted at create; online payment requires online.
+ * POS orders start in the business's configured flow (staged → accepted,
+ * direct → delivered); online payment requires connectivity.
  */
 import type { SellerOrder } from "../../types/api/seller.api";
 import type { POSOrderCreateRequest } from "../../types/pos.types";

package/dist/domain/orders/service.js

@@ -1,7 +1,8 @@
 /**
  * Local Orders Service — SQLite is real DB (like backend Orders).
  * Device-partitioned by UUID PK + DD-RRR-CCC per business.
- * is_pos orders are accepted at create; online payment requires online.
+ * POS orders start in the business's configured flow (staged → accepted,
+ * direct → delivered); online payment requires connectivity.
  */
 import { openSyncDatabase } from "../../db/connection";
 import { insertOrder, getOrderById, listOrders, updateOrderStatus, updateOrderPayment, getEntitySnapshotsByType } from "../../db/operations";
@@ -15,6 +16,7 @@ import { canTransition } from "../../utils/order-transitions";
 import { TRANSITION_ERROR_CODES, TransitionError } from "../../sync/transition-errors";
 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 { canBusinessSync } from "../../sync/sync-guard";
@@ -78,6 +80,10 @@ export async function createLocalOrder(businessId, input) {
     // Offline validation mirror — backend Order.changeset rules, pre-commit.
     validateOrderCreateInput(input);
     const method = input.pos_payment_method ?? "cash";
+    // Business-configurable fulfilment flow (cached business profile, offline).
+    // "direct" completes walk-in sales the moment they are rung up; "staged"
+    // keeps accept → preparing → ready → completed.
+    const flowMode = await getBusinessOrderFlowMode(businessId);
     // Operating-hours gate (fail-closed, offline-first): matches backend
     // validate_business_open. Throws BUSINESS_CLOSED / HOURS_NOT_SYNCED before
     // anything is written, so a doomed order never enters SQLite/sync_jobs.
@@ -128,7 +134,7 @@ export async function createLocalOrder(businessId, input) {
         id,
         order_number: orderNumber,
         callout_number: callout,
-        status: isPos ? "accepted" : "pending",
+        status: isPos ? initialPosOrderStatus(method, flowMode) : "pending",
         order_type: input.order_type ?? "takeout",
         is_pos: isPos,
         customer_name: input.customer_name ?? null,
@@ -161,7 +167,7 @@ export async function createLocalOrder(businessId, input) {
     };
     const db = await openSyncDatabase();
     await insertOrder(db, order);
-    syncLogger.debug("DomainOrders", "createLocalOrder inserted", { businessId, id, orderNumber, isPos, connectivity: getConnectivityState(), hasToken: !!getAuthToken(), deviceNumber: dd });
+    syncLogger.debug("DomainOrders", "createLocalOrder inserted", { businessId, id, orderNumber, isPos, flowMode, status: order.status, connectivity: getConnectivityState(), hasToken: !!getAuthToken(), deviceNumber: dd });
     try {
         await db.runAsync(`INSERT OR IGNORE INTO sync_jobs (id, business_id, command_type, entity_id, payload, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, 'pending', ?, ?);`, id, businessId, "order:create", id, JSON.stringify({ ...input, order_number: orderNumber, id }), now, now);
         syncLogger.debug("DomainOrders", "sync_jobs enqueued", { businessId, id, command_type: "order:create" });

package/dist/hooks/delivery.hooks.d.ts

@@ -36,10 +36,10 @@ export declare function useBusinessDeliveriesQuery(enabled?: boolean, filters?:
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchStatus: import("@tanstack/query-core").FetchStatus;
-    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
     hasNextPage: boolean;
     hasPreviousPage: boolean;
     isFetchingNextPage: boolean;
@@ -70,10 +70,10 @@ export declare function useBusinessDeliveriesQuery(enabled?: boolean, filters?:
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchStatus: import("@tanstack/query-core").FetchStatus;
-    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
     hasNextPage: boolean;
     hasPreviousPage: boolean;
     isFetchingNextPage: boolean;
@@ -105,10 +105,10 @@ export declare function useBusinessDeliveriesQuery(enabled?: boolean, filters?:
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchStatus: import("@tanstack/query-core").FetchStatus;
-    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
     hasNextPage: boolean;
     hasPreviousPage: boolean;
     isFetchingNextPage: boolean;
@@ -138,10 +138,10 @@ export declare function useBusinessDeliveriesQuery(enabled?: boolean, filters?:
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchStatus: import("@tanstack/query-core").FetchStatus;
-    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
     hasNextPage: boolean;
     hasPreviousPage: boolean;
     isFetchingNextPage: boolean;
@@ -172,10 +172,10 @@ export declare function useBusinessDeliveriesQuery(enabled?: boolean, filters?:
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchStatus: import("@tanstack/query-core").FetchStatus;
-    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
     hasNextPage: boolean;
     hasPreviousPage: boolean;
     isFetchNextPageError: boolean;
@@ -206,10 +206,10 @@ export declare function useBusinessDeliveriesQuery(enabled?: boolean, filters?:
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchStatus: import("@tanstack/query-core").FetchStatus;
-    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
-    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<import("@tanstack/query-core").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<ListPage<BusinessDelivery>, unknown>, Error>>;
     hasNextPage: boolean;
     hasPreviousPage: boolean;
     isFetchingNextPage: boolean;