@teincfood/core 0.10.12 → 0.10.14

package/dist/adapters/services.d.ts

@@ -87,8 +87,14 @@ export declare const dashboardService: {
     fetchSellerDashboard: (_businessId: string) => Promise<unknown>;
 };
 export declare const analyticsService: {
-    fetchSellerAnalytics: (_businessId: string, _period?: string) => Promise<unknown>;
-    fetchRevenueSummary: (_businessId: string, _period?: string) => Promise<unknown>;
+    fetchSellerAnalytics: (_businessId: string, _period?: string, _range?: {
+        date_from?: string;
+        date_to?: string;
+    }) => Promise<unknown>;
+    fetchRevenueSummary: (_businessId: string, _period?: string, _range?: {
+        date_from?: string;
+        date_to?: string;
+    }) => Promise<unknown>;
 };
 export declare const placesService: {
     searchPlaces: (_query: string, _lat?: number, _lng?: number) => Promise<PlaceSuggestion[]>;

package/dist/adapters/services.js

@@ -172,10 +172,10 @@ export const dashboardService = {
 };
 // analytics.service — seller analytics + revenue (hosts inject axios impls)
 export const analyticsService = {
-    fetchSellerAnalytics: async (_businessId, _period) => {
+    fetchSellerAnalytics: async (_businessId, _period, _range) => {
         notImpl("analyticsService.fetchSellerAnalytics");
     },
-    fetchRevenueSummary: async (_businessId, _period) => {
+    fetchRevenueSummary: async (_businessId, _period, _range) => {
         notImpl("analyticsService.fetchRevenueSummary");
     },
 };

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

@@ -3,13 +3,19 @@
  * Offline-first: local SQLite aggregates serve instantly; the network
  * refreshes silently when online.
  */
+export type AnalyticsPeriod = "today" | "this_week" | "this_month" | "this_year" | "custom";
+/** Inclusive UTC day bounds used by the custom range filter. */
+export interface AnalyticsRange {
+    date_from?: string;
+    date_to?: string;
+}
 export declare const SELLER_ANALYTICS_KEYS: {
     all: readonly ["seller-analytics"];
-    analytics: (businessId?: string, period?: string) => readonly ["seller-analytics", string | undefined, string | undefined];
+    analytics: (businessId?: string, period?: AnalyticsPeriod, range?: AnalyticsRange) => readonly ["seller-analytics", string | undefined, AnalyticsPeriod | undefined, string | null, string | null];
 };
 export declare const REVENUE_KEYS: {
     all: readonly ["revenue-summary"];
-    summary: (businessId?: string, period?: string) => readonly ["revenue-summary", string | undefined, string | undefined];
+    summary: (businessId?: string, period?: AnalyticsPeriod, range?: AnalyticsRange) => readonly ["revenue-summary", string | undefined, AnalyticsPeriod | undefined, string | null, string | null];
 };
 interface LocalOrderRow {
     status: string;
@@ -31,8 +37,21 @@ interface LocalOrderRow {
 interface AggregateOptions {
     forRevenueSummary: boolean;
 }
-export declare function aggregateLocal(orders: LocalOrderRow[], period: "today" | "this_week" | "this_month", opts: AggregateOptions): {
-    period: "this_month" | "this_week" | "today";
+/**
+ * Filter local rows to the same period boundaries as the backend
+ * (`period_bounds/2`):
+ *   - today      = current UTC day
+ *   - this_week  = Monday 00:00 UTC → now (backend uses ISO weekday)
+ *   - this_month = 1st of the current UTC month → now
+ *   - this_year  = 1 January of the current UTC year → now
+ *   - custom     = inclusive `date_from` → `date_to` (YYYY-MM-DD)
+ *
+ * Exported so the period boundaries can be regression-tested with a fixed
+ * clock instead of depending on the day the suite runs.
+ */
+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;
     total_revenue_minor: number;
     total_orders: number;
     average_order_value_minor: number;
@@ -61,7 +80,7 @@ export declare function aggregateLocal(orders: LocalOrderRow[], period: "today"
     by_payment_method?: undefined;
     by_order_type?: undefined;
     by_day?: undefined;
-    period: "this_month" | "this_week" | "today";
+    period: AnalyticsPeriod;
     total_revenue_minor: number;
     total_orders: number;
     average_order_value_minor: number;
@@ -82,16 +101,6 @@ export declare function aggregateLocal(orders: LocalOrderRow[], period: "today"
     }[];
     offline: boolean;
 };
-export declare function useSellerAnalyticsQuery(period?: "today" | "this_week" | "this_month", enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
-    data?: {
-        period?: string;
-        revenue_by_day?: unknown[];
-    };
-}, Error>;
-export declare function useRevenueSummaryQuery(period?: "today" | "this_week" | "this_month", enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
-    data?: {
-        period?: string;
-        by_day?: unknown[];
-    };
-}, Error>;
+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>;
 export {};

package/dist/hooks/analytics.hooks.js

@@ -11,11 +11,23 @@ import { listLocalOrders } from "../domain/orders/service";
 import { useIsEffectivelyOnline } from "./use-infinite-list";
 export const SELLER_ANALYTICS_KEYS = {
     all: ["seller-analytics"],
-    analytics: (businessId, period) => [...SELLER_ANALYTICS_KEYS.all, businessId, period],
+    analytics: (businessId, period, range) => [
+        ...SELLER_ANALYTICS_KEYS.all,
+        businessId,
+        period,
+        range?.date_from ?? null,
+        range?.date_to ?? null,
+    ],
 };
 export const REVENUE_KEYS = {
     all: ["revenue-summary"],
-    summary: (businessId, period) => [...REVENUE_KEYS.all, businessId, period],
+    summary: (businessId, period, range) => [
+        ...REVENUE_KEYS.all,
+        businessId,
+        period,
+        range?.date_from ?? null,
+        range?.date_to ?? null,
+    ],
 };
 function useBusinessId() {
     const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
@@ -23,35 +35,54 @@ function useBusinessId() {
 }
 const OFFLINE_FIRST = { retry: false, networkMode: "offlineFirst" };
 /**
- * Backend-shaped aggregates computed from local SQLite rows (offline).
- * Field names mirror orders.ex get_seller_analytics / get_revenue_summary
- * exactly so screens render identically online and offline.
+ * Filter local rows to the same period boundaries as the backend
+ * (`period_bounds/2`):
+ *   - today      = current UTC day
+ *   - this_week  = Monday 00:00 UTC → now (backend uses ISO weekday)
+ *   - this_month = 1st of the current UTC month → now
+ *   - this_year  = 1 January of the current UTC year → now
+ *   - custom     = inclusive `date_from` → `date_to` (YYYY-MM-DD)
+ *
+ * Exported so the period boundaries can be regression-tested with a fixed
+ * clock instead of depending on the day the suite runs.
  */
-function filterByPeriod(orders, period) {
-    const now = new Date();
+export function filterByPeriod(orders, period, now = new Date(), range) {
     const todayStr = now.toISOString().slice(0, 10);
     if (period === "today") {
         return orders.filter((o) => (o.inserted_at ?? "").slice(0, 10) === todayStr);
     }
-    if (period === "this_week") {
-        const startOfWeek = new Date(now);
-        startOfWeek.setDate(now.getDate() - now.getDay()); // Sunday
-        const startStr = startOfWeek.toISOString().slice(0, 10);
+    if (period === "custom") {
+        const from = range?.date_from;
+        const to = range?.date_to;
+        if (!from || !to)
+            return [];
         return orders.filter((o) => {
             const d = (o.inserted_at ?? "").slice(0, 10);
-            return d >= startStr && d <= todayStr;
+            return d >= from && d <= to;
         });
     }
-    // this_month
-    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
-    const startStr = startOfMonth.toISOString().slice(0, 10);
+    let startStr;
+    if (period === "this_week") {
+        // `getUTCDay()` is 0 for Sunday; shift so Monday is the first day.
+        const todayUtc = new Date(`${todayStr}T00:00:00.000Z`);
+        const daysSinceMonday = (todayUtc.getUTCDay() + 6) % 7;
+        const startOfWeek = new Date(todayUtc);
+        startOfWeek.setUTCDate(todayUtc.getUTCDate() - daysSinceMonday);
+        startStr = startOfWeek.toISOString().slice(0, 10);
+    }
+    else if (period === "this_year") {
+        startStr = `${todayStr.slice(0, 4)}-01-01`;
+    }
+    else {
+        startStr = `${todayStr.slice(0, 7)}-01`;
+    }
     return orders.filter((o) => {
         const d = (o.inserted_at ?? "").slice(0, 10);
         return d >= startStr && d <= todayStr;
     });
 }
-export function aggregateLocal(orders, period, opts) {
-    const filtered = filterByPeriod(orders, period);
+export function aggregateLocal(orders, period, opts, range) {
+    const filtered = filterByPeriod(orders, period, new Date(), range);
     // Backend parity (orders.ex get_business_analytics / get_revenue_summary):
     // revenue-eligible = all EXCEPT cancelled. Cancelled orders must never
     // inflate revenue, counts, breakdowns, or top items — online and offline.
@@ -59,7 +90,9 @@ export function aggregateLocal(orders, period, opts) {
     const total_revenue_minor = revenueOrders.reduce((s, o) => s + (o.total_minor ?? 0), 0);
     const total_orders = revenueOrders.length;
     // Backend uses div (truncation) — mirror, don't round.
-    const average_order_value_minor = total_orders ? Math.floor(total_revenue_minor / total_orders) : 0;
+    const average_order_value_minor = total_orders
+        ? Math.floor(total_revenue_minor / total_orders)
+        : 0;
     const byMethod = new Map();
     const byType = new Map();
     const byDay = new Map();
@@ -89,7 +122,9 @@ export function aggregateLocal(orders, period, opts) {
             itemRev.set(name, (itemRev.get(name) ?? 0) + rev);
         }
     }
-    const pct = (v) => (total_revenue_minor > 0 ? Math.round((v / total_revenue_minor) * 1000) / 10 : 0);
+    const pct = (v) => total_revenue_minor > 0
+        ? Math.round((v / total_revenue_minor) * 1000) / 10
+        : 0;
     // Backend orders_by_status counts over ALL period orders (not revenue-only).
     const orders_by_status = {
         delivered: filtered.filter((o) => o.status === "delivered").length,
@@ -103,7 +138,11 @@ export function aggregateLocal(orders, period, opts) {
             total_orders,
             average_order_value_minor,
             by_payment_method: [...byMethod.entries()]
-                .map(([method, v]) => ({ method, ...v, percentage: pct(v.revenue_minor) }))
+                .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 }))
@@ -121,7 +160,11 @@ export function aggregateLocal(orders, period, opts) {
         average_order_value_minor,
         total_refunds_minor: 0,
         top_items: [...itemQty.entries()]
-            .map(([name, quantity]) => ({ name, quantity, revenue_minor: itemRev.get(name) ?? 0 }))
+            .map(([name, quantity]) => ({
+            name,
+            quantity,
+            revenue_minor: itemRev.get(name) ?? 0,
+        }))
             .sort((a, b) => b.revenue_minor - a.revenue_minor)
             .slice(0, 10),
         orders_by_status,
@@ -133,90 +176,78 @@ export function aggregateLocal(orders, period, opts) {
 }
 async function localOrders(businessId) {
     const { data } = await listLocalOrders(businessId, {}, 1, 500);
-    return (data ?? []);
+    return data ?? [];
+}
+function hasCustomRange(period, range) {
+    return (period !== "custom" || Boolean(range?.date_from && range?.date_to));
 }
-export function useSellerAnalyticsQuery(period = "today", enabled = true) {
+export function useSellerAnalyticsQuery(period = "today", enabled = true, range) {
     const businessId = useBusinessId();
     const online = useIsEffectivelyOnline();
+    const customReady = hasCustomRange(period, range);
     return useQuery({
-        queryKey: SELLER_ANALYTICS_KEYS.analytics(businessId ?? "", period),
+        queryKey: SELLER_ANALYTICS_KEYS.analytics(businessId ?? "", period, range),
         queryFn: async () => {
             if (!online) {
                 try {
-                    return { data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: false }) };
+                    return {
+                        data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: false }, range),
+                    };
                 }
                 catch {
-                    return { data: aggregateLocal([], period, { forRevenueSummary: false }) };
+                    return {
+                        data: aggregateLocal([], period, { forRevenueSummary: false }, range),
+                    };
                 }
             }
             try {
-                const backendRes = await analyticsService.fetchSellerAnalytics(businessId, period);
-                // Safety net: if backend doesn't filter by period (returns all days regardless), filter locally
-                const backendData = backendRes.data;
-                const byDay = backendData?.revenue_by_day;
-                const shouldFilterLocally = !byDay?.length ||
-                    (period === "today" && byDay.length > 1) ||
-                    (period === "this_week" && byDay.some(d => {
-                        const day = new Date(d.date ?? "");
-                        const now = new Date();
-                        const startOfWeek = new Date(now);
-                        startOfWeek.setDate(now.getDate() - now.getDay());
-                        return day < startOfWeek || day > now;
-                    }));
-                if (shouldFilterLocally) {
-                    const localOrdersData = await localOrders(businessId);
-                    return { data: aggregateLocal(localOrdersData, period, { forRevenueSummary: false }) };
-                }
-                return backendRes;
+                // 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 }) };
+                return {
+                    data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: false }, range),
+                };
             }
         },
-        enabled: enabled && Boolean(businessId),
+        enabled: enabled && Boolean(businessId) && customReady,
         staleTime: 30000,
         ...OFFLINE_FIRST,
     });
 }
-export function useRevenueSummaryQuery(period = "today", enabled = true) {
+export function useRevenueSummaryQuery(period = "today", enabled = true, range) {
     const businessId = useBusinessId();
     const online = useIsEffectivelyOnline();
+    const customReady = hasCustomRange(period, range);
     return useQuery({
-        queryKey: REVENUE_KEYS.summary(businessId ?? "", period),
+        queryKey: REVENUE_KEYS.summary(businessId ?? "", period, range),
         queryFn: async () => {
             if (!online) {
                 try {
-                    return { data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: true }) };
+                    return {
+                        data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: true }, range),
+                    };
                 }
                 catch {
-                    return { data: aggregateLocal([], period, { forRevenueSummary: true }) };
+                    return {
+                        data: aggregateLocal([], period, { forRevenueSummary: true }, range),
+                    };
                 }
             }
             try {
-                const backendRes = await analyticsService.fetchRevenueSummary(businessId, period);
-                // Safety net: if backend doesn't filter by period (returns all days regardless), filter locally
-                const backendData = backendRes.data;
-                const byDay = backendData?.by_day;
-                const shouldFilterLocally = !byDay?.length ||
-                    (period === "today" && byDay.length > 1) ||
-                    (period === "this_week" && byDay.some(d => {
-                        const day = new Date(d.date ?? "");
-                        const now = new Date();
-                        const startOfWeek = new Date(now);
-                        startOfWeek.setDate(now.getDate() - now.getDay());
-                        return day < startOfWeek || day > now;
-                    }));
-                if (shouldFilterLocally) {
-                    const localOrdersData = await localOrders(businessId);
-                    return { data: aggregateLocal(localOrdersData, period, { forRevenueSummary: true }) };
-                }
-                return backendRes;
+                // 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 }) };
+                return {
+                    data: aggregateLocal(await localOrders(businessId), period, { forRevenueSummary: true }, range),
+                };
             }
         },
-        enabled: enabled && Boolean(businessId),
+        enabled: enabled && Boolean(businessId) && customReady,
         staleTime: 30000,
         ...OFFLINE_FIRST,
     });

package/package.json

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