@teincfood/core 0.9.19 → 0.9.20

package/dist/db/operations.d.ts

@@ -81,6 +81,7 @@ export declare function listOrders(db: SQLiteDatabase, businessId: string, filte
     order_type?: string;
     date_from?: string;
     date_to?: string;
+    is_paid?: string;
 }, page?: number, pageSize?: number): Promise<{
     data: import("../types/api/seller.api").SellerOrder[];
     total: number;

package/dist/db/operations.js

@@ -263,6 +263,12 @@ export async function listOrders(db, businessId, filters, page = 1, pageSize = 2
         where.push("order_type = ?");
         args.push(filters.order_type);
     }
+    if (filters?.is_paid === "paid") {
+        where.push("json_extract(payment, '$.is_paid') = 1");
+    }
+    else if (filters?.is_paid === "unpaid") {
+        where.push("(json_extract(payment, '$.is_paid') IS NULL OR json_extract(payment, '$.is_paid') = 0)");
+    }
     if (filters?.q) {
         where.push("(order_number LIKE ? OR customer_name LIKE ? OR customer_phone LIKE ?)");
         const q = `%${filters.q}%`;

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

@@ -17,6 +17,7 @@ export declare function listLocalOrders(businessId: string, filters?: {
     order_type?: string;
     date_from?: string;
     date_to?: string;
+    is_paid?: string;
 }, page?: number, pageSize?: number): Promise<{
     data: import("../../types/api/seller.api").SellerOrder[];
     total: number;

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

@@ -17,6 +17,10 @@ export declare function useDeliveryDetailQuery(deliveryId: string, enabled?: boo
 export interface DeliveryFilters {
     status?: string;
     search?: string;
+    order_type?: string;
+    is_paid?: string;
+    date_from?: string;
+    date_to?: string;
 }
 export declare function useBusinessDeliveriesQuery(enabled?: boolean, filters?: DeliveryFilters): {
     dataUpdatedAt: number;

package/dist/hooks/delivery.hooks.js

@@ -34,7 +34,14 @@ function useBusinessId() {
     return id ?? undefined;
 }
 async function fetchOfflineDeliveries(businessId, filters, page, pageSize) {
-    const { data } = await listLocalOrders(businessId, { status: undefined, q: filters?.search }, page, pageSize);
+    const { data } = await listLocalOrders(businessId, {
+        status: undefined,
+        q: filters?.search,
+        order_type: filters?.order_type,
+        is_paid: filters?.is_paid,
+        date_from: filters?.date_from,
+        date_to: filters?.date_to,
+    }, page, pageSize);
     const deliveryOrders = data.filter((o) => o.delivery_id);
     const statusSet = new Set((filters?.status ?? "").split(",").map((s) => s.trim()).filter(Boolean));
     const filtered = statusSet.size > 0
@@ -73,6 +80,14 @@ export function useBusinessDeliveriesQuery(enabled = true, filters) {
                 params.status = filters.status;
             if (filters?.search)
                 params.search = filters.search;
+            if (filters?.order_type)
+                params.order_type = filters.order_type;
+            if (filters?.is_paid)
+                params.payment_status = filters.is_paid;
+            if (filters?.date_from)
+                params.date_from = filters.date_from;
+            if (filters?.date_to)
+                params.date_to = filters.date_to;
             const res = (await deliveryService.fetchBusinessDeliveries(businessId, params));
             return res;
         },

package/dist/hooks/orders.hooks.d.ts

@@ -12,11 +12,16 @@ export declare const SELLER_KEYS: {
     order: (id: string, bid?: string) => readonly ["seller", "order", string, string | undefined];
 };
 export declare function usePOSOrdersQuery(filters?: Record<string, string>, enabled?: boolean): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error>;
-export declare function useSellerOrdersQuery(enabled?: boolean, filters?: {
+export interface SellerOrderFilters {
     status?: string;
     q?: string;
     search?: string;
-}): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error>;
+    order_type?: string;
+    is_paid?: string;
+    date_from?: string;
+    date_to?: string;
+}
+export declare function useSellerOrdersQuery(enabled?: boolean, filters?: SellerOrderFilters): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error>;
 export declare function useSellerOrderQuery(orderId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
     data: SellerOrder;
 }, Error>;

package/dist/hooks/orders.hooks.js

@@ -58,7 +58,14 @@ export function useSellerOrdersQuery(enabled = true, filters) {
             if (!bid)
                 return { data: [], pagination: { page: 1, page_size: 20, total_pages: 1, total_entries: 0 } };
             const q = filters?.q ?? filters?.search;
-            const { data, total } = await listLocalOrders(bid, { status: filters?.status, q }, pageParam, 20);
+            const { data, total } = await listLocalOrders(bid, {
+                status: filters?.status,
+                q,
+                order_type: filters?.order_type,
+                is_paid: filters?.is_paid,
+                date_from: filters?.date_from,
+                date_to: filters?.date_to,
+            }, pageParam, 20);
             const merged = await mergePendingIntoList(data, bid, pageParam);
             const totalPages = Math.max(1, Math.ceil(total / 20));
             return { data: merged, pagination: { page: pageParam, page_size: 20, total_pages: totalPages, total_entries: total + (merged.length - data.length) } };

package/dist/index.d.ts

@@ -21,7 +21,9 @@ export * from "./utils/attempt-stats";
 export { PHONE_COUNTRIES, getDialCodeFromCountry, getCountryOption, normalizePhoneForCountry, isLikelyE164 } from "./utils/phone";
 export type { PhoneCountryOption } from "./utils/phone";
 export * from "./utils/formatCurrency";
-export { formatDate, formatRelativeTime } from "./utils/formatDate";
+export { formatDate, formatDateTime, formatTime, formatDateCompact, formatRelativeTime } from "./utils/formatDate";
+export { resolveDateRange, DATE_PRESET_LABELS } from "./utils/date-range";
+export type { DatePreset, DateRange } from "./utils/date-range";
 export * from "./utils/validation";
 export * from "./validation/offline";
 export * from "./utils/copyToClipBoard";

package/dist/index.js

@@ -22,7 +22,8 @@ export * from "./utils/debug-log";
 export * from "./utils/attempt-stats";
 export { PHONE_COUNTRIES, getDialCodeFromCountry, getCountryOption, normalizePhoneForCountry, isLikelyE164 } from "./utils/phone";
 export * from "./utils/formatCurrency";
-export { formatDate, formatRelativeTime } from "./utils/formatDate";
+export { formatDate, formatDateTime, formatTime, formatDateCompact, formatRelativeTime } from "./utils/formatDate";
+export { resolveDateRange, DATE_PRESET_LABELS } from "./utils/date-range";
 export * from "./utils/validation";
 export * from "./validation/offline";
 export * from "./utils/copyToClipBoard";

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

@@ -410,24 +410,61 @@ export function createMemoryDriver() {
                     rows = rows.slice(0, limit);
                 return rows;
             }
-            // orders list with filters (simple business_id filter + pagination)
+            // orders list with filters (business_id + status/order_type/is_paid/q/date)
             if (s.includes("SELECT * FROM orders WHERE")) {
                 const business_id = args[0];
-                // args includes where-clause params plus LIMIT and OFFSET at end
-                // For test, just filter by business_id and apply basic status/q if present in sql string via args slicing?
-                // Simpler: return all orders for that business, sorted by inserted_at desc, handle LIMIT/OFFSET manually
                 let rows = tables.orders.filter((r) => r.business_id === business_id);
-                // handle status filter if sql contains status IN
+                // Consume filter args in the exact clause order produced by listOrders.
+                let i = 1;
                 if (s.includes("status IN")) {
-                    // find args that are status values (excluding business_id, limit, offset)
-                    // Our sql: SELECT * FROM orders WHERE business_id = ? AND status IN (?,?) ... LIMIT ? OFFSET ?
-                    // So statuses are args[1]..args[?]
-                    // Count statuses by parsing SQL placeholder count?
-                    // For test, just extract known statuses from args that look like status strings
-                    const possibleStatuses = ["pending", "awaiting_payment", "accepted", "preparing", "ready", "waiting_pickup", "on_the_way", "arrived", "delivered", "cancelled", "assigned", "picked_up", "en_route", "failed"];
-                    const statusArgs = args.filter((v) => possibleStatuses.includes(String(v)));
-                    if (statusArgs.length)
-                        rows = rows.filter((r) => statusArgs.includes(r.status));
+                    const n = (s.match(/status IN \([^)]*\)/)[0].match(/\?/g) || []).length;
+                    const statuses = args.slice(i, i + n);
+                    i += n;
+                    if (statuses.length)
+                        rows = rows.filter((r) => statuses.includes(r.status));
+                }
+                if (s.includes("is_pos = ?")) {
+                    const v = Number(args[i++]) === 1;
+                    rows = rows.filter((r) => !!r.is_pos === v);
+                }
+                if (s.includes("order_type = ?")) {
+                    const t = args[i++];
+                    rows = rows.filter((r) => r.order_type === t);
+                }
+                if (s.includes("json_extract(payment, '$.is_paid') = 1")) {
+                    rows = rows.filter((r) => {
+                        try {
+                            return JSON.parse(r.payment ?? "{}").is_paid === true;
+                        }
+                        catch {
+                            return false;
+                        }
+                    });
+                }
+                else if (s.includes("json_extract(payment, '$.is_paid') IS NULL")) {
+                    rows = rows.filter((r) => {
+                        try {
+                            return JSON.parse(r.payment ?? "{}").is_paid !== true;
+                        }
+                        catch {
+                            return true;
+                        }
+                    });
+                }
+                if (s.includes("order_number LIKE ?")) {
+                    const term = String(args[i]).replace(/%/g, "").toLowerCase();
+                    i += 3;
+                    rows = rows.filter((r) => String(r.order_number ?? "").toLowerCase().includes(term) ||
+                        String(r.customer_name ?? "").toLowerCase().includes(term) ||
+                        String(r.customer_phone ?? "").toLowerCase().includes(term));
+                }
+                if (s.includes("inserted_at >= ?")) {
+                    const from = String(args[i++]);
+                    rows = rows.filter((r) => String(r.inserted_at) >= from);
+                }
+                if (s.includes("inserted_at < ?")) {
+                    const to = String(args[i++]);
+                    rows = rows.filter((r) => String(r.inserted_at) < to);
                 }
                 rows = rows.sort((a, b) => (a.inserted_at < b.inserted_at ? 1 : -1));
                 const limit = args[args.length - 2];

package/dist/utils/date-range.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Date-range presets for order/delivery filters.
+ *
+ * Returns YYYY-MM-DD strings (local day boundaries) that both the backend
+ * (normalizes to UTC day bounds) and the local SQLite read-model
+ * (`inserted_at >= from` / `inserted_at < `${to}T23:59:59``) accept.
+ */
+export type DatePreset = "all" | "today" | "yesterday" | "last7" | "custom";
+export interface DateRange {
+    date_from?: string;
+    date_to?: string;
+}
+export declare function resolveDateRange(preset: DatePreset | string | undefined, customFrom?: string, customTo?: string): DateRange;
+export declare const DATE_PRESET_LABELS: Array<{
+    key: DatePreset;
+    label: string;
+}>;

package/dist/utils/date-range.js

@@ -0,0 +1,45 @@
+/**
+ * Date-range presets for order/delivery filters.
+ *
+ * Returns YYYY-MM-DD strings (local day boundaries) that both the backend
+ * (normalizes to UTC day bounds) and the local SQLite read-model
+ * (`inserted_at >= from` / `inserted_at < `${to}T23:59:59``) accept.
+ */
+function toISODate(d) {
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}`;
+}
+function addDays(base, days) {
+    const d = new Date(base);
+    d.setDate(d.getDate() + days);
+    return d;
+}
+export function resolveDateRange(preset, customFrom, customTo) {
+    const today = new Date();
+    switch (preset) {
+        case "today":
+            return { date_from: toISODate(today), date_to: toISODate(today) };
+        case "yesterday": {
+            const y = toISODate(addDays(today, -1));
+            return { date_from: y, date_to: y };
+        }
+        case "last7":
+            return { date_from: toISODate(addDays(today, -6)), date_to: toISODate(today) };
+        case "custom":
+            return {
+                ...(customFrom ? { date_from: customFrom } : {}),
+                ...(customTo ? { date_to: customTo } : {}),
+            };
+        default:
+            return {};
+    }
+}
+export const DATE_PRESET_LABELS = [
+    { key: "all", label: "All time" },
+    { key: "today", label: "Today" },
+    { key: "yesterday", label: "Yesterday" },
+    { key: "last7", label: "Last 7 days" },
+    { key: "custom", label: "Custom" },
+];

package/dist/utils/formatDate.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Format the time-of-day of an ISO date string (e.g. "2:30 PM").
+ */
+export declare function formatTime(isoString: string): string;
+/**
+ * Compact date (e.g. "26 Sep 2026") for list cards where the year may be
+ * implied but is still useful for older orders.
+ */
+export declare function formatDateCompact(isoString: string): string;
+/**
+ * Date + time for order/delivery cards: "26 Sep 2026, 2:30 PM".
+ */
+export declare function formatDateTime(isoString: string): string;
 /**
  * Format an ISO date string into a human-readable format.
  */

package/dist/utils/formatDate.js

@@ -1,3 +1,32 @@
+/**
+ * Format the time-of-day of an ISO date string (e.g. "2:30 PM").
+ */
+export function formatTime(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleTimeString('en-US', {
+        hour: 'numeric',
+        minute: '2-digit',
+        hour12: true,
+    });
+}
+/**
+ * Compact date (e.g. "26 Sep 2026") for list cards where the year may be
+ * implied but is still useful for older orders.
+ */
+export function formatDateCompact(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleDateString('en-US', {
+        day: '2-digit',
+        month: 'short',
+        year: 'numeric',
+    });
+}
+/**
+ * Date + time for order/delivery cards: "26 Sep 2026, 2:30 PM".
+ */
+export function formatDateTime(isoString) {
+    return `${formatDateCompact(isoString)}, ${formatTime(isoString)}`;
+}
 /**
  * Format an ISO date string into a human-readable format.
  */

package/package.json

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