@teincfood/core 0.1.0

package/dist/reference/service.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * Reference Data Synchronization Service.
+ *
+ * Responsible for downloading, versioning, and caching reference data
+ * (menus, categories, modifiers, taxes, printers, etc.) locally.
+ *
+ * This service is separate from the Sync Engine, which handles transactional
+ * commands and events.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.referenceSyncService = void 0;
+const connection_1 = require("../db/connection");
+const sync_logger_1 = require("../utils/sync-logger");
+const uuid_1 = require("../utils/uuid");
+const services_1 = require("../adapters/services");
+const image_cache_1 = require("../adapters/image-cache");
+const operations_1 = require("./operations");
+const api_1 = require("./api");
+const DEFAULT_SYNC_KEYS = [
+    "menu:items",
+    "menu:categories",
+    "roles",
+    "members",
+    "tax-rules",
+    "business:profile",
+    "operating-hours",
+    "subscription:entitlements",
+];
+class ReferenceSyncService {
+    constructor() {
+        this.isSyncing = false;
+    }
+    async sync(options) {
+        if (this.isSyncing) {
+            return {
+                synced: [],
+                skipped: [],
+                failed: [],
+                errors: {},
+            };
+        }
+        this.isSyncing = true;
+        sync_logger_1.syncLogger.info("ReferenceSync", "Starting reference data sync", {
+            businessId: options.businessId,
+            keys: options.keys,
+        });
+        const result = {
+            synced: [],
+            skipped: [],
+            failed: [],
+            errors: {},
+        };
+        try {
+            const db = await (0, connection_1.openSyncDatabase)();
+            const keys = options.keys ?? DEFAULT_SYNC_KEYS;
+            // Attempt version-aware sync. If the backend does not support versioning
+            // endpoints, fall back to legacy full-fetch per key.
+            let versions = null;
+            try {
+                versions = await (0, api_1.fetchReferenceVersions)(options.businessId);
+            }
+            catch (error) {
+                sync_logger_1.syncLogger.warn("ReferenceSync", "Version endpoint unavailable, using fallback", {
+                    error: String(error),
+                });
+            }
+            for (const key of keys) {
+                try {
+                    const synced = await this.syncKey(db, key, options, versions);
+                    if (synced) {
+                        result.synced.push(key);
+                    }
+                    else {
+                        result.skipped.push(key);
+                    }
+                }
+                catch (error) {
+                    result.failed.push(key);
+                    result.errors[key] = String(error);
+                    sync_logger_1.syncLogger.error("ReferenceSync", `Failed to sync ${key}`, {
+                        error: String(error),
+                    });
+                }
+            }
+            // After a sync pass, download the images referenced by the freshly
+            // cached payloads (menu items, business logo/cover) so the device can
+            // display them while offline, then reclaim space from orphaned files.
+            if (result.synced.length > 0) {
+                await this.cacheReferenceImages(db, options.businessId, result.synced);
+            }
+        }
+        finally {
+            this.isSyncing = false;
+        }
+        sync_logger_1.syncLogger.info("ReferenceSync", "Reference data sync complete", {
+            synced: result.synced,
+            skipped: result.skipped,
+            failed: result.failed,
+        });
+        return result;
+    }
+    async syncKey(db, key, options, versions) {
+        const { businessId } = options;
+        const localVersion = await (0, operations_1.getReferenceVersion)(db, businessId, key);
+        // A key the backend does not version (e.g. during a gradual rollout) is
+        // fetched with a full fetch + local hash so it is still cached offline.
+        const serverVersion = versions?.find((v) => v.key === key)?.version;
+        if (!options.force && localVersion && !options.incremental) {
+            // In non-incremental mode without force, we still re-sync if version
+            // info says there is a newer version on the server.
+            if (serverVersion && serverVersion === localVersion) {
+                sync_logger_1.syncLogger.debug("ReferenceSync", `Up to date: ${key}`, {
+                    version: localVersion,
+                });
+                return false;
+            }
+        }
+        let payload;
+        let version;
+        if (versions && serverVersion) {
+            if (localVersion && serverVersion !== localVersion) {
+                try {
+                    const changeSet = await (0, api_1.fetchReferenceChanges)(businessId, key, localVersion);
+                    payload = changeSet.changes;
+                    version = changeSet.to_version;
+                }
+                catch {
+                    // Fall back to full fetch if changes endpoint fails.
+                    const data = await (0, api_1.fetchReferenceData)(businessId, [key]);
+                    payload = data[key];
+                    version = serverVersion;
+                }
+            }
+            else {
+                const data = await (0, api_1.fetchReferenceData)(businessId, [key]);
+                payload = data[key];
+                version = serverVersion;
+            }
+        }
+        else {
+            // Backend does not support versioning for this key (or at all):
+            // full fetch + local hash so the data is still cached offline.
+            const fallback = await this.fetchFallback(key, businessId);
+            payload = fallback.payload;
+            version = fallback.version;
+        }
+        await (0, operations_1.setReferenceData)(db, businessId, {
+            key,
+            // Defensive: never write a NULL version. If the backend ever omits the
+            // version, generate one so the row is still usable; the next version
+            // comparison will simply see a mismatch and re-sync.
+            version: version ?? (0, uuid_1.generateUUID)(),
+            payload,
+            downloadedAt: new Date().toISOString(),
+        });
+        return true;
+    }
+    async fetchFallback(key, businessId) {
+        switch (key) {
+            case "menu:items": {
+                const response = await services_1.menuService.fetchBusinessMenuItems(businessId, 1);
+                return {
+                    payload: response,
+                    version: this.hashPayload(response),
+                };
+            }
+            case "menu:categories": {
+                const response = await services_1.menuService.fetchBusinessCategories(businessId);
+                return {
+                    payload: response,
+                    version: this.hashPayload(response),
+                };
+            }
+            case "roles": {
+                const response = await services_1.rolesService.fetchBusinessRoles();
+                return {
+                    payload: response,
+                    version: this.hashPayload(response),
+                };
+            }
+            case "members": {
+                const response = await services_1.businessService.fetchBusinessMembers(businessId);
+                return {
+                    payload: response,
+                    version: this.hashPayload(response),
+                };
+            }
+            case "tax-rules": {
+                const response = await services_1.businessService.fetchBusinessTaxRules(businessId);
+                return {
+                    payload: response,
+                    version: this.hashPayload(response),
+                };
+            }
+            case "business:profile": {
+                const response = await services_1.businessService.fetchBusinessById(businessId);
+                return {
+                    payload: response,
+                    version: this.hashPayload(response),
+                };
+            }
+            case "operating-hours": {
+                const response = await services_1.businessService.fetchOperatingHours(businessId);
+                return {
+                    payload: response,
+                    version: this.hashPayload(response),
+                };
+            }
+            default:
+                throw new Error(`No fallback fetch available for ${key}`);
+        }
+    }
+    /**
+     * Download every image referenced by the given cached reference keys into
+     * durable local storage, then prune orphaned files. Covers menu item photos
+     * and the business logo/cover. Idempotent — already-cached images are
+     * skipped. Errors never propagate: a failed download must not fail the sync.
+     */
+    async cacheReferenceImages(db, businessId, keys) {
+        try {
+            const urls = [];
+            if (keys.includes("menu:items")) {
+                const cached = await (0, operations_1.getReferenceData)(db, businessId, "menu:items");
+                const items = cached?.payload?.data ?? [];
+                urls.push(...items.map((item) => item.image_url));
+            }
+            if (keys.includes("business:profile")) {
+                const cached = await (0, operations_1.getReferenceData)(db, businessId, "business:profile");
+                const business = cached?.payload?.data;
+                if (business) {
+                    urls.push(business.logo_url, business.cover_image_url);
+                }
+            }
+            if (urls.length === 0)
+                return;
+            const cachedImages = await (0, image_cache_1.cacheImageBatch)(urls, {
+                skipIfCached: true,
+            });
+            sync_logger_1.syncLogger.debug("ReferenceSync", "Reference images cached", {
+                businessId,
+                keys,
+                count: cachedImages.length,
+            });
+            await (0, image_cache_1.pruneImageCache)(urls);
+        }
+        catch (error) {
+            sync_logger_1.syncLogger.warn("ReferenceSync", "Failed to cache reference images", {
+                error: String(error),
+            });
+        }
+    }
+    hashPayload(payload) {
+        // Simple deterministic hash for fallback versioning.
+        // Replace with a proper hash (e.g. SHA-256) when backend versioning is ready.
+        const json = JSON.stringify(payload);
+        let hash = 0;
+        for (let i = 0; i < json.length; i++) {
+            const char = json.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash |= 0;
+        }
+        return `local-${Math.abs(hash).toString(16)}`;
+    }
+    async getCached(businessId, key) {
+        const db = await (0, connection_1.openSyncDatabase)();
+        return (0, operations_1.getReferenceData)(db, businessId, key);
+    }
+}
+exports.referenceSyncService = new ReferenceSyncService();

package/dist/reference/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Types for reference data synchronization.
+ *
+ * Reference data is data that changes infrequently and is required for
+ * day-to-day operation: menus, categories, products, modifiers, taxes,
+ * printers, kitchen stations, etc.
+ *
+ * It is synchronized separately from transactional data through the
+ * ReferenceSyncService.
+ */
+export type ReferenceDataKey = "menu:items" | "menu:categories" | "roles" | "members" | "tax-rules" | "business:profile" | "operating-hours" | "subscription:entitlements";
+export interface ReferenceDataRecord<T = unknown> {
+    key: ReferenceDataKey;
+    version: string;
+    payload: T;
+    downloadedAt: string;
+}
+export interface ReferenceVersionInfo {
+    key: ReferenceDataKey;
+    version: string;
+    updated_at: string;
+}
+export interface ReferenceSyncOptions {
+    businessId: string;
+    keys?: ReferenceDataKey[];
+    /** If true, ignore local cache and fetch fresh data. */
+    force?: boolean;
+    /** If true, only sync keys that are missing or stale. */
+    incremental?: boolean;
+}
+export interface ReferenceSyncResult {
+    synced: ReferenceDataKey[];
+    skipped: ReferenceDataKey[];
+    failed: ReferenceDataKey[];
+    errors: Record<ReferenceDataKey, string>;
+}
+export interface ReferenceChangeSet<T = unknown> {
+    key: ReferenceDataKey;
+    from_version: string;
+    to_version: string;
+    changes: T;
+}
+export interface ReferenceSyncStatus {
+    lastSyncAt: string | null;
+    isSyncing: boolean;
+    error: string | null;
+}

package/dist/reference/types.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Types for reference data synchronization.
+ *
+ * Reference data is data that changes infrequently and is required for
+ * day-to-day operation: menus, categories, products, modifiers, taxes,
+ * printers, kitchen stations, etc.
+ *
+ * It is synchronized separately from transactional data through the
+ * ReferenceSyncService.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/repositories/order.repository.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Order Repository.
+ *
+ * The interface between application hooks and the Sync Engine.
+ * Converts domain inputs into commands and returns the resulting events.
+ *
+ * In Phase 1, commands execute immediately through the REST transport.
+ * Future phases will queue commands when offline.
+ */
+import type { POSOrderCreateRequest } from "../types/pos.types";
+import type { SellerOrder } from "../types/api/seller.api";
+export interface CreateOrderInput {
+    businessId: string;
+    data: POSOrderCreateRequest;
+    /** Client-generated entity ID for offline-created orders. */
+    entityId?: string;
+}
+export interface AssignRiderInput {
+    orderId: string;
+    riderId: string;
+}
+export interface OrderActionInput {
+    orderId: string;
+    businessId: string;
+}
+export declare const orderRepository: {
+    createOrder(input: CreateOrderInput): Promise<SellerOrder>;
+    acceptOrder(input: OrderActionInput): Promise<SellerOrder>;
+    rejectOrder(input: OrderActionInput): Promise<SellerOrder>;
+    startPreparingOrder(input: OrderActionInput): Promise<SellerOrder>;
+    markOrderReady(input: OrderActionInput): Promise<SellerOrder>;
+    completePickup(input: OrderActionInput): Promise<SellerOrder>;
+    cancelOrder(input: OrderActionInput): Promise<SellerOrder>;
+    confirmHandover(input: {
+        deliveryId: string;
+        businessId: string;
+    }): Promise<{
+        id: string;
+        status: string;
+    }>;
+    assignRider(input: AssignRiderInput & {
+        businessId: string;
+    }): Promise<unknown>;
+};

package/dist/repositories/order.repository.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Order Repository.
+ *
+ * The interface between application hooks and the Sync Engine.
+ * Converts domain inputs into commands and returns the resulting events.
+ *
+ * In Phase 1, commands execute immediately through the REST transport.
+ * Future phases will queue commands when offline.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderRepository = void 0;
+const engine_1 = require("../sync/engine");
+const command_builder_1 = require("../sync/command-builder");
+async function executeCommand(command) {
+    console.debug("[OrderRepository] Dispatching command", JSON.stringify({
+        command_id: command.command_id,
+        command_type: command.command_type,
+        business_id: command.business_id,
+        entity_id: command.entity_id,
+        payload_keys: Object.keys(command.payload ?? {}),
+        timestamp: new Date().toISOString(),
+    }));
+    const events = await engine_1.syncEngine.execute(command);
+    const event = events[0];
+    console.debug("[OrderRepository] Command result", JSON.stringify({
+        command_id: command.command_id,
+        command_type: command.command_type,
+        event_count: events.length,
+        event_type: event?.event_type,
+        order_number: event?.payload?.order_number ?? null,
+        status: event?.payload?.status ?? null,
+        timestamp: new Date().toISOString(),
+    }));
+    if (!event) {
+        throw new Error("OrderRepository: command returned no events");
+    }
+    return event.payload;
+}
+exports.orderRepository = {
+    async createOrder(input) {
+        const command = (0, command_builder_1.buildCommand)({
+            commandType: "order:create",
+            businessId: input.businessId,
+            entityId: input.entityId,
+            payload: input.data,
+        });
+        return executeCommand(command);
+    },
+    async acceptOrder(input) {
+        const command = (0, command_builder_1.buildCommand)({
+            commandType: "order:accept",
+            businessId: input.businessId,
+            entityId: input.orderId,
+            payload: {},
+        });
+        return executeCommand(command);
+    },
+    async rejectOrder(input) {
+        const command = (0, command_builder_1.buildCommand)({
+            commandType: "order:reject",
+            businessId: input.businessId,
+            entityId: input.orderId,
+            payload: {},
+        });
+        return executeCommand(command);
+    },
+    async startPreparingOrder(input) {
+        const command = (0, command_builder_1.buildCommand)({
+            commandType: "order:start_preparing",
+            businessId: input.businessId,
+            entityId: input.orderId,
+            payload: {},
+        });
+        return executeCommand(command);
+    },
+    async markOrderReady(input) {
+        const command = (0, command_builder_1.buildCommand)({
+            commandType: "order:mark_ready",
+            businessId: input.businessId,
+            entityId: input.orderId,
+            payload: {},
+        });
+        return executeCommand(command);
+    },
+    async completePickup(input) {
+        const command = (0, command_builder_1.buildCommand)({
+            commandType: "order:complete_pickup",
+            businessId: input.businessId,
+            entityId: input.orderId,
+            payload: {},
+        });
+        return executeCommand(command);
+    },
+    async cancelOrder(input) {
+        const command = (0, command_builder_1.buildCommand)({
+            commandType: "order:cancel",
+            businessId: input.businessId,
+            entityId: input.orderId,
+            payload: {},
+        });
+        return executeCommand(command);
+    },
+    async confirmHandover(input) {
+        const command = (0, command_builder_1.buildCommand)({
+            commandType: "delivery:confirm_handover",
+            businessId: input.businessId,
+            entityId: input.deliveryId,
+            payload: {},
+        });
+        const events = await engine_1.syncEngine.execute(command);
+        const event = events[0];
+        if (!event) {
+            throw new Error("OrderRepository: confirmHandover returned no events");
+        }
+        return event.payload;
+    },
+    async assignRider(input) {
+        const command = (0, command_builder_1.buildCommand)({
+            commandType: "delivery:assign",
+            businessId: input.businessId,
+            entityId: input.orderId,
+            payload: { rider_id: input.riderId },
+        });
+        const events = await engine_1.syncEngine.execute(command);
+        const event = events[0];
+        if (!event) {
+            throw new Error("OrderRepository: assignRider returned no events");
+        }
+        return event.payload;
+    },
+};

package/dist/repositories/pos.repository.d.ts

@@ -0,0 +1,20 @@
+/**
+ * POS Repository.
+ *
+ * Domain-specific operations for the POS terminal. Builds on OrderRepository
+ * for commands and keeps read/query operations behind a repository interface.
+ */
+import type { POSOrderCreateRequest, POSOrderPreviewRequest, POSOrderPreviewResponse } from "../types/pos.types";
+import type { SellerOrder } from "../types/api/seller.api";
+import type { SellerOrdersResponse } from "../types/api/seller.api";
+export interface POSOrderPreviewInput {
+    businessId: string;
+    items: POSOrderPreviewRequest["items"];
+    orderType: POSOrderPreviewRequest["order_type"];
+    customerName?: string;
+}
+export declare const posRepository: {
+    createOrder(businessId: string, data: POSOrderCreateRequest, entityId?: string): Promise<SellerOrder>;
+    fetchPreview(input: POSOrderPreviewInput): Promise<POSOrderPreviewResponse>;
+    fetchOrders(businessId: string, params?: Record<string, string>): Promise<SellerOrdersResponse>;
+};

package/dist/repositories/pos.repository.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * POS Repository.
+ *
+ * Domain-specific operations for the POS terminal. Builds on OrderRepository
+ * for commands and keeps read/query operations behind a repository interface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.posRepository = void 0;
+const services_1 = require("../adapters/services");
+const order_repository_1 = require("./order.repository");
+exports.posRepository = {
+    async createOrder(businessId, data, entityId) {
+        return order_repository_1.orderRepository.createOrder({ businessId, data, entityId });
+    },
+    async fetchPreview(input) {
+        const res = await services_1.posService.fetchPOSOrderPreview(input.businessId, {
+            items: input.items,
+            order_type: input.orderType,
+            customer_name: input.customerName,
+        });
+        return res;
+    },
+    async fetchOrders(businessId, params) {
+        const res = await services_1.posService.fetchBusinessOrders(businessId, params);
+        return res;
+    },
+};

package/dist/sync/command-builder.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Command builder helpers.
+ *
+ * Centralizes creation of Command objects with consistent metadata
+ * (command_id, user_id, device_id, timestamps).
+ */
+import type { Command } from "./types";
+import { getAppInstanceId } from "../adapters/devices";
+export interface CommandBuilderOptions<T> {
+    commandType: string;
+    commandVersion?: string;
+    businessId: string;
+    entityId?: string;
+    payload: T;
+}
+export declare function buildCommand<T>(options: CommandBuilderOptions<T>): Command<T>;
+export { getAppInstanceId };

package/dist/sync/command-builder.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Command builder helpers.
+ *
+ * Centralizes creation of Command objects with consistent metadata
+ * (command_id, user_id, device_id, timestamps).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppInstanceId = void 0;
+exports.buildCommand = buildCommand;
+const auth_1 = require("../adapters/auth");
+const devices_1 = require("../adapters/devices");
+Object.defineProperty(exports, "getAppInstanceId", { enumerable: true, get: function () { return devices_1.getAppInstanceId; } });
+const uuid_1 = require("../utils/uuid");
+function buildCommand(options) {
+    const user = auth_1.useAuthStore.getState().user;
+    const userId = user?.id ?? "anonymous";
+    const deviceId = (0, devices_1.getAppInstanceId)();
+    return {
+        command_id: (0, uuid_1.generateCommandId)(),
+        command_type: options.commandType,
+        command_version: options.commandVersion ?? "1.0",
+        business_id: options.businessId,
+        entity_id: options.entityId,
+        user_id: userId,
+        device_id: deviceId,
+        timestamp: new Date().toISOString(),
+        payload: options.payload,
+    };
+}

package/dist/sync/command-queue.service.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Command Queue Service.
+ *
+ * Durable SQLite outbox for commands that cannot be executed immediately.
+ * Responsibilities:
+ *   - Persist commands when the cloud and Local Node are both unavailable.
+ *   - Generate local order numbers for offline `order:create` commands.
+ *   - Replay queued commands when a transport becomes available.
+ *   - Provide optimistic domain events so the UI can render pending orders.
+ */
+import type { Command, DomainEvent, PersistedCommand } from "./types";
+import type { SyncEngine } from "./engine";
+declare class CommandQueueService {
+    private replaying;
+    private syncEngine;
+    setSyncEngine(engine: SyncEngine): void;
+    /**
+     * Enqueue a command because no transport is currently available.
+     * Returns an optimistic domain event so the caller can update the UI.
+     */
+    enqueue(command: Command): Promise<DomainEvent>;
+    /**
+     * Try to execute a single pending command through the current transport.
+     */
+    processCommand(command: PersistedCommand): Promise<void>;
+    /**
+     * Replay all pending commands in order. Stops on the first failure to keep
+     * ordering consistent; the next replay will retry from the failed command.
+     */
+    replay(): Promise<void>;
+    /**
+     * Cancel a queued command that has not yet been transmitted.
+     */
+    cancel(commandId: string): Promise<void>;
+    /**
+     * Return the number of commands currently in the outbox.
+     */
+    getPendingCount(): Promise<number>;
+}
+export declare const commandQueueService: CommandQueueService;
+export {};