@teincfood/core 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# @teincfood/core
+
+TeincFood shared offline-first core — single source of truth for mobile (`TeincFoodBusiness`) and desktop (`TeincFoodDesktop`).
+
+## What lives here (v0.1.0 backbone)
+
+- `types/api/*` — snake_case API contracts matching backend
+- `utils/*` — currency, error, format, uuid, order-number (async), etc.
+- `sync/*` — engine, command-queue, transports, routing-policy, pending-orders
+- `db/*` — migrations + operations (driver-agnostic, takes a `SqliteDriver`)
+- `reference/*` — versioned reference-data cache
+- `repositories/*` — order/pos repositories
+- `adapters/*` — platform seams (KV, SQLite, HTTP, etc.)
+
+## Adapters
+
+Apps supply platform adapters via `createTeincCore({ storage, db, http, ... })`:
+
+- `KVStorage` — async `getItem/setItem/removeItem` (MMKV-wrapped on mobile, `plugin-store` on desktop)
+- `SqliteDriver` — `execAsync/runAsync/getFirstAsync/getAllAsync/withTransactionAsync`
+- `HttpClient` — axios instance with auth interceptors (token plumbing stays app-side)
+- `LanTransport` — `{ isAvailable(), execute(command) }`
+
+## Usage
+
+```ts
+import { createTeincCore } from "@teincfood/core";
+const core = createTeincCore({ storage, db, http });
+```
+
+Apps re-export types via `export * from "@teincfood/core"` barrels to avoid churn.
+
+## Publishing
+
+```bash
+yarn build
+npm publish --access public
+```
+
+## Roadmap
+
+- v0.2 services/stores/hooks
+- v0.3 LAN protocol + orchestrator + restart/diagnostics
+- v0.4 phoenix/events

package/dist/adapters/auth.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Auth store stub.
+ */
+export interface AuthUser {
+    id: string;
+    email?: string;
+}
+export declare function setAuthUser(u: AuthUser | null): void;
+export declare const useAuthStore: {
+    getState: () => {
+        user: AuthUser | null;
+    };
+};

package/dist/adapters/auth.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Auth store stub.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuthStore = void 0;
+exports.setAuthUser = setAuthUser;
+let user = null;
+function setAuthUser(u) {
+    user = u;
+}
+exports.useAuthStore = {
+    getState: () => ({ user }),
+};

package/dist/adapters/business.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Business store stub.
+ */
+export declare function setActiveBusiness(b: {
+    id: string;
+} | null): void;
+export declare const useBusinessStore: {
+    getState: () => {
+        activeBusiness: {
+            id: string;
+        } | null;
+    };
+};

package/dist/adapters/business.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Business store stub.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBusinessStore = void 0;
+exports.setActiveBusiness = setActiveBusiness;
+let activeBusiness = null;
+function setActiveBusiness(b) {
+    activeBusiness = b;
+}
+exports.useBusinessStore = {
+    getState: () => ({ activeBusiness }),
+};

package/dist/adapters/connectivity.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Connectivity adapter — replaces zustand connectivity store.
+ * Host apps inject real connectivity state; core defaults to offline-unknown.
+ */
+export type CloudReachable = "reachable" | "unreachable" | "unknown";
+export interface ConnectivityState {
+    isOnline: boolean;
+    isCloudReachable: CloudReachable;
+}
+export declare function getConnectivityState(): ConnectivityState;
+export declare function setConnectivityState(patch: Partial<ConnectivityState>): void;
+export declare function setCloudReachable(value: CloudReachable): void;
+export declare function setOnline(value: boolean): void;
+export declare function subscribeConnectivity(listener: (s: ConnectivityState) => void): () => void;
+export declare const connectivityStoreShim: {
+    getState: typeof getConnectivityState;
+};

package/dist/adapters/connectivity.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Connectivity adapter — replaces zustand connectivity store.
+ * Host apps inject real connectivity state; core defaults to offline-unknown.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectivityStoreShim = void 0;
+exports.getConnectivityState = getConnectivityState;
+exports.setConnectivityState = setConnectivityState;
+exports.setCloudReachable = setCloudReachable;
+exports.setOnline = setOnline;
+exports.subscribeConnectivity = subscribeConnectivity;
+let state = {
+    isOnline: true,
+    isCloudReachable: "unknown",
+};
+const listeners = new Set();
+function getConnectivityState() {
+    return { ...state };
+}
+function setConnectivityState(patch) {
+    state = { ...state, ...patch };
+    listeners.forEach((l) => l({ ...state }));
+}
+function setCloudReachable(value) {
+    setConnectivityState({ isCloudReachable: value });
+}
+function setOnline(value) {
+    setConnectivityState({ isOnline: value });
+}
+function subscribeConnectivity(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+// Compatibility shim for code that previously used useConnectivityStore.getState()
+exports.connectivityStoreShim = {
+    getState: getConnectivityState,
+};

package/dist/adapters/devices.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Devices service stub.
+ */
+export declare function setAppInstanceId(id: string): void;
+export declare function getAppInstanceId(): string;

package/dist/adapters/devices.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Devices service stub.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAppInstanceId = setAppInstanceId;
+exports.getAppInstanceId = getAppInstanceId;
+let appInstanceId = "core-device-id";
+function setAppInstanceId(id) {
+    appInstanceId = id;
+}
+function getAppInstanceId() {
+    return appInstanceId;
+}

package/dist/adapters/http.d.ts

@@ -0,0 +1,30 @@
+/**
+ * HTTP adapter — provides ApiError and a minimal api client interface.
+ * Host apps inject a real HTTP client (axios/fetch) via setHttpClient().
+ */
+export declare class ApiError extends Error {
+    status: number;
+    code?: string;
+    data?: unknown;
+    constructor(message: string, status: number, code?: string, data?: unknown);
+}
+export interface HttpClient {
+    get<T>(url: string, config?: unknown): Promise<{
+        data: T;
+    }>;
+    post<T>(url: string, body?: unknown, config?: unknown): Promise<{
+        data: T;
+    }>;
+    put<T>(url: string, body?: unknown, config?: unknown): Promise<{
+        data: T;
+    }>;
+    patch<T>(url: string, body?: unknown, config?: unknown): Promise<{
+        data: T;
+    }>;
+    delete<T>(url: string, config?: unknown): Promise<{
+        data: T;
+    }>;
+}
+export declare function setHttpClient(c: HttpClient): void;
+export declare function getHttpClient(): HttpClient;
+export declare const api: HttpClient;

package/dist/adapters/http.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * HTTP adapter — provides ApiError and a minimal api client interface.
+ * Host apps inject a real HTTP client (axios/fetch) via setHttpClient().
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.api = exports.ApiError = void 0;
+exports.setHttpClient = setHttpClient;
+exports.getHttpClient = getHttpClient;
+class ApiError extends Error {
+    constructor(message, status, code, data) {
+        super(message);
+        this.name = "ApiError";
+        this.status = status;
+        this.code = code;
+        this.data = data;
+    }
+}
+exports.ApiError = ApiError;
+let client = null;
+function setHttpClient(c) {
+    client = c;
+}
+function getHttpClient() {
+    if (!client) {
+        throw new Error("HTTP client not injected. Call setHttpClient(client) before making API calls.");
+    }
+    return client;
+}
+// Default export compatible with `import { api } from "@/services/api"`
+exports.api = {
+    get: (...args) => getHttpClient().get(...args),
+    post: (...args) => getHttpClient().post(...args),
+    put: (...args) => getHttpClient().put(...args),
+    patch: (...args) => getHttpClient().patch(...args),
+    delete: (...args) => getHttpClient().delete(...args),
+};

package/dist/adapters/image-cache.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Image cache stub — no-op in core library.
+ * Host apps with file-system access inject real impl.
+ */
+export declare function cacheImageBatch(_urls: (string | null | undefined)[], _opts?: {
+    skipIfCached?: boolean;
+}): Promise<string[]>;
+export declare function pruneImageCache(_urls: (string | null | undefined)[]): Promise<void>;

package/dist/adapters/image-cache.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Image cache stub — no-op in core library.
+ * Host apps with file-system access inject real impl.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheImageBatch = cacheImageBatch;
+exports.pruneImageCache = pruneImageCache;
+async function cacheImageBatch(_urls, _opts) {
+    return [];
+}
+async function pruneImageCache(_urls) { }

package/dist/adapters/kv-types.d.ts

@@ -0,0 +1,5 @@
+export interface StateStorage {
+    getItem: (name: string) => string | null | Promise<string | null>;
+    setItem: (name: string, value: string) => void | Promise<void>;
+    removeItem: (name: string) => void | Promise<void>;
+}

package/dist/adapters/kv-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/adapters/kv.d.ts

@@ -0,0 +1,20 @@
+/**
+ * KV storage adapter — async get/set/remove with in-memory fallback for tests.
+ * Host apps can inject a persistent backend via setKVDriver().
+ */
+export interface KVDriver {
+    getItem(key: string): Promise<string | null> | string | null;
+    setItem(key: string, value: string): Promise<void> | void;
+    removeItem(key: string): Promise<void> | void;
+}
+export declare function setKVDriver(d: KVDriver): void;
+export declare function getKVDriver(): KVDriver;
+export declare function kvGetItem(key: string): Promise<string | null>;
+export declare function kvSetItem(key: string, value: string): Promise<void>;
+export declare function kvRemoveItem(key: string): Promise<void>;
+export declare function getItem<T>(key: string): Promise<T | null>;
+export declare function setItem<T>(key: string, value: T): Promise<void>;
+export declare function removeItem(key: string): Promise<void>;
+export declare function getItemSync<T>(key: string): T | null;
+export declare function setItemSync<T>(key: string, value: T): void;
+export declare function removeItemSync(key: string): void;

package/dist/adapters/kv.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * KV storage adapter — async get/set/remove with in-memory fallback for tests.
+ * Host apps can inject a persistent backend via setKVDriver().
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setKVDriver = setKVDriver;
+exports.getKVDriver = getKVDriver;
+exports.kvGetItem = kvGetItem;
+exports.kvSetItem = kvSetItem;
+exports.kvRemoveItem = kvRemoveItem;
+exports.getItem = getItem;
+exports.setItem = setItem;
+exports.removeItem = removeItem;
+exports.getItemSync = getItemSync;
+exports.setItemSync = setItemSync;
+exports.removeItemSync = removeItemSync;
+const memory = new Map();
+let driver = null;
+function setKVDriver(d) {
+    driver = d;
+}
+function getKVDriver() {
+    if (driver)
+        return driver;
+    return {
+        getItem: (key) => memory.get(key) ?? null,
+        setItem: (key, value) => {
+            memory.set(key, value);
+        },
+        removeItem: (key) => {
+            memory.delete(key);
+        },
+    };
+}
+async function kvGetItem(key) {
+    const v = await getKVDriver().getItem(key);
+    return v ?? null;
+}
+async function kvSetItem(key, value) {
+    await getKVDriver().setItem(key, value);
+}
+async function kvRemoveItem(key) {
+    await getKVDriver().removeItem(key);
+}
+// Typed JSON helpers (mirrors old storage.ts sync API but async)
+async function getItem(key) {
+    const raw = await kvGetItem(key);
+    if (raw == null)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function setItem(key, value) {
+    await kvSetItem(key, JSON.stringify(value));
+}
+async function removeItem(key) {
+    await kvRemoveItem(key);
+}
+// Synchronous fallbacks for legacy callers that used MMKV sync API
+function getItemSync(key) {
+    const raw = memory.get(key);
+    if (raw == null)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function setItemSync(key, value) {
+    memory.set(key, JSON.stringify(value));
+}
+function removeItemSync(key) {
+    memory.delete(key);
+}

package/dist/adapters/local-node.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Local Node stubs — minimal interfaces so core compiles without RN.
+ * Host apps with LAN support replace these via setters.
+ */
+import type { Command, DomainEvent } from "../sync/types";
+export interface LocalNodeClient {
+    execute(command: Command): Promise<DomainEvent[]>;
+    publishEvent?(event: DomainEvent): void | Promise<void>;
+}
+export interface ElectedNode {
+    deviceId: string;
+}
+export declare function setLocalNodeState(s: {
+    isLocalNodeEnabled?: boolean;
+    isConnectedToNode?: boolean;
+    isLocalNode?: boolean;
+    electedNode?: ElectedNode | null;
+    client?: LocalNodeClient | null;
+}): void;
+export declare const localNodeService: {
+    isLocalNode: () => boolean;
+    isConnectedToNode: () => boolean;
+    getElectedNode: () => ElectedNode | null;
+    getClient: () => LocalNodeClient | null;
+    broadcastToClients: (_event: DomainEvent) => void;
+    handleNodeCommand: (_command: Command) => Promise<DomainEvent | null>;
+};
+export declare const useLocalNodeStore: {
+    getState: () => {
+        isLocalNodeEnabled: boolean;
+        isConnectedToNode: boolean;
+        electedNode: ElectedNode | null;
+    };
+};

package/dist/adapters/local-node.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Local Node stubs — minimal interfaces so core compiles without RN.
+ * Host apps with LAN support replace these via setters.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLocalNodeStore = exports.localNodeService = void 0;
+exports.setLocalNodeState = setLocalNodeState;
+let isLocalEnabled = false;
+let isConnected = false;
+let isLocalNodeFlag = false;
+let electedNode = null;
+let client = null;
+function setLocalNodeState(s) {
+    if (s.isLocalNodeEnabled !== undefined)
+        isLocalEnabled = s.isLocalNodeEnabled;
+    if (s.isConnectedToNode !== undefined)
+        isConnected = s.isConnectedToNode;
+    if (s.isLocalNode !== undefined)
+        isLocalNodeFlag = s.isLocalNode;
+    if (s.electedNode !== undefined)
+        electedNode = s.electedNode;
+    if (s.client !== undefined)
+        client = s.client;
+}
+exports.localNodeService = {
+    isLocalNode: () => isLocalNodeFlag,
+    isConnectedToNode: () => isConnected,
+    getElectedNode: () => electedNode,
+    getClient: () => client,
+    broadcastToClients: (_event) => { },
+    handleNodeCommand: async (_command) => null,
+};
+exports.useLocalNodeStore = {
+    getState: () => ({
+        isLocalNodeEnabled: isLocalEnabled,
+        isConnectedToNode: isConnected,
+        electedNode,
+    }),
+};

package/dist/adapters/pending-orders.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Pending orders store stub.
+ */
+import type { SellerOrder } from "../types/api/seller.api";
+export declare const usePendingOrdersStore: {
+    getState: () => {
+        hydrated: boolean;
+        orders: SellerOrder[];
+        addOrder: (order: SellerOrder) => void;
+        removeByOrderNumber: (orderNumber: string) => void;
+        setHydrated: (v: boolean) => void;
+    };
+    setState: (patch: Partial<{
+        orders: SellerOrder[];
+        hydrated: boolean;
+    }>) => void;
+};

package/dist/adapters/pending-orders.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Pending orders store stub.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePendingOrdersStore = void 0;
+let orders = [];
+let hydrated = false;
+exports.usePendingOrdersStore = {
+    getState: () => ({
+        hydrated,
+        orders,
+        addOrder: (order) => {
+            if (!orders.find((o) => o.order_number === order.order_number)) {
+                orders.push(order);
+            }
+        },
+        removeByOrderNumber: (orderNumber) => {
+            orders = orders.filter((o) => o.order_number !== orderNumber);
+        },
+        setHydrated: (v) => {
+            hydrated = v;
+        },
+    }),
+    setState: (patch) => {
+        if (patch.orders !== undefined)
+            orders = patch.orders;
+        if (patch.hydrated !== undefined)
+            hydrated = patch.hydrated;
+    },
+};

package/dist/adapters/query-keys.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Query key stubs for reconciliation bridge.
+ * Real host apps expose these; core only needs shape for invalidateQueries.
+ */
+export declare const POS_KEYS: {
+    all: readonly ["pos"];
+    orders: (businessId: string) => readonly ["pos", "orders", string];
+};
+export declare const SELLER_KEYS: {
+    all: readonly ["seller"];
+};
+export declare const MENU_KEYS: {
+    all: readonly ["menu"];
+};
+export declare const REFERENCE_KEYS: {
+    all: readonly ["reference"];
+};

package/dist/adapters/query-keys.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Query key stubs for reconciliation bridge.
+ * Real host apps expose these; core only needs shape for invalidateQueries.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REFERENCE_KEYS = exports.MENU_KEYS = exports.SELLER_KEYS = exports.POS_KEYS = void 0;
+exports.POS_KEYS = {
+    all: ["pos"],
+    orders: (businessId) => ["pos", "orders", businessId],
+};
+exports.SELLER_KEYS = {
+    all: ["seller"],
+};
+exports.MENU_KEYS = {
+    all: ["menu"],
+};
+exports.REFERENCE_KEYS = {
+    all: ["reference"],
+};

package/dist/adapters/services.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Service stubs for pos/seller/kiosk/menu/business/roles.
+ * Host apps can replace via setServiceImpls; core defaults to no-op that throws helpful error.
+ */
+export declare const posService: {
+    createPOSOrder: (_businessId: string, _payload: unknown) => Promise<{
+        data: unknown;
+    }>;
+    fetchPOSOrderPreview: (_businessId: string, _payload: unknown) => Promise<unknown>;
+    fetchBusinessOrders: (_businessId: string, _params?: unknown) => Promise<unknown>;
+};
+export declare const sellerService: {
+    acceptOrder: (_orderId: string) => Promise<{
+        data: unknown;
+    }>;
+    rejectOrder: (_orderId: string) => Promise<{
+        data: unknown;
+    }>;
+    startPreparingOrder: (_orderId: string) => Promise<{
+        data: unknown;
+    }>;
+    markOrderReady: (_orderId: string) => Promise<{
+        data: unknown;
+    }>;
+    completeOrderPickup: (_orderId: string) => Promise<{
+        data: unknown;
+    }>;
+    cancelOrder: (_orderId: string) => Promise<{
+        data: unknown;
+    }>;
+    confirmHandover: (_deliveryId: string) => Promise<unknown>;
+};
+export declare const kioskService: {
+    assignKioskOrderToRider: (_orderId: string, _riderId: string) => Promise<unknown>;
+};
+export declare const menuService: {
+    fetchBusinessMenuItems: (_businessId: string, _page: number) => Promise<unknown>;
+    fetchBusinessCategories: (_businessId: string) => Promise<unknown>;
+};
+export declare const businessService: {
+    fetchBusinessMembers: (_businessId: string) => Promise<unknown>;
+    fetchBusinessTaxRules: (_businessId: string) => Promise<unknown>;
+    fetchBusinessById: (_businessId: string) => Promise<unknown>;
+    fetchOperatingHours: (_businessId: string) => Promise<unknown>;
+};
+export declare const rolesService: {
+    fetchBusinessRoles: () => Promise<unknown>;
+};
+export declare function getRegionConfig(_countryCode?: string): {
+    currencyCode: string;
+};
+export declare function formatCurrencyByRegion(amountMinor: number, _config: unknown): string;
+export declare const useLocationStore: {
+    getState(): {
+        currentLocation: {
+            countryCode?: string;
+        } | null;
+    };
+    (selector: (s: {
+        currentLocation: unknown;
+    }) => unknown): unknown;
+};