@teincfood/core 0.7.8 → 0.8.0

package/dist/hooks/members.hooks.js

@@ -0,0 +1,302 @@
+/**
+ * Members / invitations / roles / tax hooks — single source for both apps.
+ * Reads serve the SQLite reference cache instantly; network refreshes
+ * silently when online. Invites and management mutations require online.
+ */
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useSyncExternalStore } from "react";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { businessService, rolesService, fleetService } from "../adapters/services";
+import { assertOnlineFor } from "../sync/online-gates";
+import { validateInviteInput } from "../validation/offline";
+import { notifySuccess, notifyError } from "../adapters/notify";
+import { extractApiErrorMessage } from "../utils/error";
+import { emitReferenceChanged } from "../reference/events";
+import { useReferenceData } from "../reference/hooks";
+import { useIsEffectivelyOnline } from "./use-infinite-list";
+function useBusinessId() {
+    const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+    return id ?? undefined;
+}
+const OFFLINE_FIRST = { retry: false, networkMode: "offlineFirst" };
+// ─── Keys ───
+export const MEMBER_KEYS = {
+    all: ["business-members"],
+    list: (businessId) => [...MEMBER_KEYS.all, businessId],
+    invitations: (businessId) => [...MEMBER_KEYS.all, businessId, "invitations"],
+};
+export const INVITATION_KEYS = {
+    all: ["invitations"],
+    list: () => [...INVITATION_KEYS.all, "list"],
+};
+export const ROLES_KEYS = {
+    all: ["business-roles"],
+    forBusiness: (businessId) => [...ROLES_KEYS.all, businessId],
+};
+export const TAX_KEYS = {
+    all: ["tax-rules"],
+    list: (businessId) => [...TAX_KEYS.all, "list", businessId],
+};
+// ─── Members ───
+export function useBusinessMembersQuery() {
+    const businessId = useBusinessId();
+    const cached = useReferenceData("members");
+    const online = useIsEffectivelyOnline();
+    const q = useQuery({
+        queryKey: MEMBER_KEYS.list(businessId ?? ""),
+        queryFn: () => businessService.fetchBusinessMembers(businessId),
+        enabled: Boolean(businessId) && online,
+        staleTime: 30 * 1000,
+        ...OFFLINE_FIRST,
+        placeholderData: cached.data?.payload,
+    });
+    // Offline: SQLite cache directly so screens stay populated when down.
+    return { ...q, data: q.data ?? cached.data?.payload };
+}
+export function useInviteMemberMutation() {
+    const queryClient = useQueryClient();
+    const businessId = useBusinessId();
+    return useMutation({
+        mutationFn: (data) => {
+            assertOnlineFor("member:invite");
+            validateInviteInput({ email: data.email });
+            return businessService.inviteBusinessMember(businessId, data);
+        },
+        onSuccess: () => {
+            notifySuccess("Invitation sent!");
+            queryClient.invalidateQueries({ queryKey: MEMBER_KEYS.list(businessId ?? "") });
+            if (businessId)
+                emitReferenceChanged(businessId, ["members"]);
+        },
+        onError: (error) => {
+            notifyError(extractApiErrorMessage(error));
+        },
+    });
+}
+export function useRemoveMemberMutation() {
+    const queryClient = useQueryClient();
+    const businessId = useBusinessId();
+    return useMutation({
+        mutationFn: (userId) => {
+            assertOnlineFor("member:manage");
+            return businessService.removeBusinessMember(businessId, userId);
+        },
+        onSuccess: () => {
+            notifySuccess("Member removed");
+            queryClient.invalidateQueries({ queryKey: MEMBER_KEYS.list(businessId ?? "") });
+            if (businessId)
+                emitReferenceChanged(businessId, ["members"]);
+        },
+        onError: (error) => {
+            notifyError(extractApiErrorMessage(error));
+        },
+    });
+}
+export function useBusinessMemberInvitationsQuery() {
+    const businessId = useBusinessId();
+    // No invitations SQLite mirror — never fire while unreachable.
+    const online = useIsEffectivelyOnline();
+    return useQuery({
+        queryKey: MEMBER_KEYS.invitations(businessId ?? ""),
+        queryFn: () => businessService.fetchBusinessMemberInvitations(businessId),
+        enabled: Boolean(businessId) && online,
+        ...OFFLINE_FIRST,
+    });
+}
+export function useRevokeMemberInvitationMutation() {
+    const queryClient = useQueryClient();
+    const businessId = useBusinessId();
+    return useMutation({
+        mutationFn: (invitationId) => {
+            assertOnlineFor("member:manage");
+            return businessService.revokeBusinessMemberInvitation(businessId, invitationId);
+        },
+        onSuccess: () => {
+            notifySuccess("Invitation revoked");
+            queryClient.invalidateQueries({ queryKey: MEMBER_KEYS.invitations(businessId ?? "") });
+            if (businessId)
+                emitReferenceChanged(businessId, ["members"]);
+        },
+        onError: (error) => {
+            notifyError(extractApiErrorMessage(error));
+        },
+    });
+}
+export function useDeleteMemberInvitationMutation() {
+    const queryClient = useQueryClient();
+    const businessId = useBusinessId();
+    return useMutation({
+        mutationFn: (invitationId) => {
+            assertOnlineFor("member:manage");
+            return businessService.deleteBusinessMemberInvitation(businessId, invitationId);
+        },
+        onSuccess: () => {
+            notifySuccess("Invitation deleted");
+            queryClient.invalidateQueries({ queryKey: MEMBER_KEYS.invitations(businessId ?? "") });
+            if (businessId)
+                emitReferenceChanged(businessId, ["members"]);
+        },
+        onError: (error) => {
+            notifyError(extractApiErrorMessage(error));
+        },
+    });
+}
+// ─── User invitations ───
+export function useUserInvitationsQuery() {
+    // No invitations SQLite mirror — never fire while unreachable.
+    const online = useIsEffectivelyOnline();
+    return useQuery({
+        queryKey: INVITATION_KEYS.list(),
+        queryFn: () => businessService.fetchUserInvitations(),
+        enabled: online,
+        staleTime: 15000,
+        ...OFFLINE_FIRST,
+    });
+}
+export function useLeaveBusinessMutation() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (invitationId) => {
+            assertOnlineFor("member:manage");
+            return businessService.leaveBusiness(invitationId);
+        },
+        onSuccess: () => {
+            notifySuccess("Left the business");
+            queryClient.invalidateQueries({ queryKey: INVITATION_KEYS.list() });
+        },
+        onError: (error) => {
+            notifyError(extractApiErrorMessage(error));
+        },
+    });
+}
+export function useAcceptFleetInvitationMutation() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (data) => {
+            assertOnlineFor("member:manage");
+            return fleetService.acceptFleetInvitation(data);
+        },
+        onSuccess: () => {
+            notifySuccess("You have joined the business!");
+            queryClient.invalidateQueries({ queryKey: INVITATION_KEYS.list() });
+        },
+        onError: (error) => {
+            notifyError(extractApiErrorMessage(error));
+        },
+    });
+}
+export function useAcceptBusinessInvitationMutation() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (data) => {
+            assertOnlineFor("member:manage");
+            return businessService.acceptBusinessInvitation(data);
+        },
+        onSuccess: () => {
+            notifySuccess("Invitation accepted!");
+            queryClient.invalidateQueries({ queryKey: INVITATION_KEYS.list() });
+        },
+        onError: (error) => {
+            notifyError(extractApiErrorMessage(error));
+        },
+    });
+}
+// ─── Roles ───
+export function useBusinessRolesQuery(enabled = true) {
+    const businessId = useBusinessId();
+    const cached = useReferenceData("roles");
+    const online = useIsEffectivelyOnline();
+    const q = useQuery({
+        queryKey: ROLES_KEYS.forBusiness(businessId),
+        queryFn: () => rolesService.fetchBusinessRoles(),
+        staleTime: Infinity,
+        enabled: enabled && !!businessId && online,
+        ...OFFLINE_FIRST,
+        placeholderData: cached.data?.payload,
+    });
+    return { ...q, data: q.data ?? cached.data?.payload };
+}
+// ─── Tax rules ───
+export function useBusinessTaxRulesQuery(enabled = true) {
+    const businessId = useBusinessId();
+    const cached = useReferenceData("tax-rules");
+    const online = useIsEffectivelyOnline();
+    const q = useQuery({
+        queryKey: TAX_KEYS.list(businessId),
+        queryFn: () => businessService.fetchBusinessTaxRules(businessId),
+        enabled: enabled && Boolean(businessId) && online,
+        staleTime: 30 * 1000,
+        ...OFFLINE_FIRST,
+        placeholderData: cached.data?.payload,
+    });
+    return { ...q, data: q.data ?? cached.data?.payload };
+}
+export function useCreateTaxRuleMutation() {
+    const queryClient = useQueryClient();
+    const businessId = useBusinessId();
+    return useMutation({
+        mutationFn: (data) => {
+            assertOnlineFor("settings:manage");
+            return businessService.createBusinessTaxRule(businessId, data);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: TAX_KEYS.list(businessId) });
+            notifySuccess("Tax rule created");
+            if (businessId)
+                emitReferenceChanged(businessId, ["tax-rules"]);
+        },
+        onError: (err) => {
+            try {
+                console.debug("[TaxHook] Create failed", err);
+            }
+            catch { }
+            notifyError(extractApiErrorMessage(err));
+        },
+    });
+}
+export function useUpdateTaxRuleMutation() {
+    const queryClient = useQueryClient();
+    const businessId = useBusinessId();
+    return useMutation({
+        mutationFn: ({ id, data }) => {
+            assertOnlineFor("settings:manage");
+            return businessService.updateTaxRule(id, data);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: TAX_KEYS.list(businessId) });
+            notifySuccess("Tax rule updated");
+            if (businessId)
+                emitReferenceChanged(businessId, ["tax-rules"]);
+        },
+        onError: (err) => {
+            try {
+                console.debug("[TaxHook] Update failed", err);
+            }
+            catch { }
+            notifyError(extractApiErrorMessage(err));
+        },
+    });
+}
+export function useDeleteTaxRuleMutation() {
+    const queryClient = useQueryClient();
+    const businessId = useBusinessId();
+    return useMutation({
+        mutationFn: (id) => {
+            assertOnlineFor("settings:manage");
+            return businessService.deleteTaxRule(id);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: TAX_KEYS.list(businessId) });
+            notifySuccess("Tax rule removed");
+            if (businessId)
+                emitReferenceChanged(businessId, ["tax-rules"]);
+        },
+        onError: (err) => {
+            try {
+                console.debug("[TaxHook] Delete failed", err);
+            }
+            catch { }
+            notifyError(extractApiErrorMessage(err));
+        },
+    });
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Offline order hydration — single source for both apps.
+ *
+ * On startup / business change, seeds the TanStack Query cache from the
+ * durable SQLite order read-model so seller, POS, kitchen and display
+ * screens render current + recent orders immediately, even before any
+ * network fetch completes (and fully offline after a restart).
+ */
+export declare function useOfflineOrderHydration(): void;

package/dist/hooks/offline-orders.hooks.js

@@ -0,0 +1,51 @@
+/**
+ * Offline order hydration — single source for both apps.
+ *
+ * On startup / business change, seeds the TanStack Query cache from the
+ * durable SQLite order read-model so seller, POS, kitchen and display
+ * screens render current + recent orders immediately, even before any
+ * network fetch completes (and fully offline after a restart).
+ */
+import { useEffect } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useSyncExternalStore } from "react";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { orderSnapshotsService } from "../sync/order-snapshots.service";
+import { SELLER_KEYS, POS_KEYS } from "./orders.hooks";
+export function useOfflineOrderHydration() {
+    const queryClient = useQueryClient();
+    const businessId = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
+    useEffect(() => {
+        if (!businessId)
+            return;
+        const bid = businessId;
+        let cancelled = false;
+        async function hydrate() {
+            const orders = await orderSnapshotsService.getSellerList(bid, bid);
+            if (cancelled || !orders || orders.length === 0)
+                return;
+            const pages = {
+                pages: [
+                    {
+                        data: orders,
+                        pagination: {
+                            page: 1,
+                            total_pages: 1,
+                            page_size: orders.length,
+                            total_entries: orders.length,
+                        },
+                    },
+                ],
+                pageParams: [1],
+            };
+            // Seed the same key shape the seller and POS screens use with no filters.
+            queryClient.setQueryData([...SELLER_KEYS.orders(bid)], pages);
+            queryClient.setQueryData([...POS_KEYS.orders(bid), undefined], pages);
+        }
+        hydrate().catch(() => { });
+        orderSnapshotsService.pruneOld().catch(() => { });
+        return () => {
+            cancelled = true;
+        };
+    }, [businessId, queryClient]);
+}

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

@@ -1,54 +1,27 @@
-/**
- * Order lifecycle hooks — offline-first, device-owned outbox.
- *
- * Device owns its partition: when offline it serves the durable
- * entity_snapshots + pending overlay immediately; the SyncEngine replays
- * queued commands when back online. No hook ever blocks on a cloud timeout
- * when offline.
- *
- * Host apps just re-export from "@teincfood/core" — no app-local duplication.
- */
-import type { POSOrderCreateRequest, POSOrderPreviewResponse } from "../types/pos.types";
-import type { POSCartItem, POSOrderType } from "../types/pos.types";
+import type { POSOrderCreateRequest, POSOrderPreviewResponse, POSCartItem, POSOrderType } from "../types/pos.types";
 import type { SellerOrder } from "../types/api/seller.api";
 export declare const POS_KEYS: {
-    readonly all: readonly ["pos"];
-    readonly orders: (businessId?: string) => readonly ["pos", "orders", string | undefined];
-    readonly preview: (businessId?: string) => readonly ["pos", "preview", string | undefined];
+    all: readonly ["pos"];
+    orders: (bid?: string) => readonly ["pos", "orders", string | undefined];
+    preview: (bid?: string) => readonly ["pos", "preview", string | undefined];
 };
 export declare const SELLER_KEYS: {
-    readonly all: readonly ["seller"];
-    readonly orders: (businessId?: string, filters?: Record<string, unknown>) => readonly unknown[];
-    readonly deliveries: (businessId?: string, filters?: Record<string, unknown>) => readonly unknown[];
-    readonly order: (id: string, businessId?: string) => readonly ["seller", "order", string, string | undefined];
-};
-export declare function usePOSOrdersQuery(filters?: {
-    status?: string;
-    order_type?: string;
-    is_pos?: string;
-    date_from?: string;
-    date_to?: string;
-    q?: string;
-    search?: string;
-}, enabled?: boolean): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error> & {
-    data: SellerOrder[] | undefined;
+    all: readonly ["seller"];
+    orders: (bid?: string, f?: Record<string, unknown>) => readonly unknown[];
+    deliveries: (bid?: string, f?: Record<string, unknown>) => readonly unknown[];
+    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?: {
     status?: string;
     q?: string;
     search?: string;
-    date_from?: string;
-    date_to?: string;
-}): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error> & {
-    data: SellerOrder[] | undefined;
-};
-export declare function usePendingOrders(businessId?: string): SellerOrder[];
-export declare function useCreatePOSOrderMutation(): import("@tanstack/react-query").UseMutationResult<unknown, Error, POSOrderCreateRequest, unknown>;
-export declare function usePOSOrderPreviewQuery(items: POSCartItem[], orderType: POSOrderType, customerName: string): import("@tanstack/react-query").UseQueryResult<POSOrderPreviewResponse, Error>;
+}): import("@tanstack/react-query").UseInfiniteQueryResult<SellerOrder[], Error>;
 export declare function useSellerOrderQuery(orderId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
     data: SellerOrder;
 }, Error>;
-export declare function isQueuedTransition(result: unknown): boolean;
+export declare function useCreatePOSOrderMutation(): import("@tanstack/react-query").UseMutationResult<SellerOrder, Error, POSOrderCreateRequest, unknown>;
+export declare function usePOSOrderPreviewQuery(items: POSCartItem[], orderType: POSOrderType, customerName: string): import("@tanstack/react-query").UseQueryResult<POSOrderPreviewResponse, Error>;
 export declare const useAcceptOrderMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
 export declare const useRejectOrderMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
 export declare const useStartPreparingOrderMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
@@ -63,7 +36,14 @@ export declare function useAssignRiderMutation(): import("@tanstack/react-query"
     orderId: string;
     riderId: string;
 }, unknown>;
+export declare function useConfirmCashPaymentMutation(): import("@tanstack/react-query").UseMutationResult<SellerOrder, Error, string, unknown>;
 export declare function useUpdateOrderStatusMutation(): {
     mutate: (orderId: string, status: string) => Promise<unknown>;
     isPending: boolean;
 };
+export declare function isQueuedTransition(result: unknown): boolean;
+/**
+ * Reactive view of locally queued (unconfirmed) order creations.
+ * Hydrates persisted optimistic events once (survives restart offline).
+ */
+export declare function usePendingOrders(): SellerOrder[];