@teincfood/core 0.1.0

package/dist/adapters/services.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Service stubs for pos/seller/kiosk/menu/business/roles.
+ * Host apps can replace via setServiceImpls; core defaults to no-op that throws helpful error.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLocationStore = exports.rolesService = exports.businessService = exports.menuService = exports.kioskService = exports.sellerService = exports.posService = void 0;
+exports.getRegionConfig = getRegionConfig;
+exports.formatCurrencyByRegion = formatCurrencyByRegion;
+function notImpl(name) {
+    throw new Error(`Service ${name} not injected. Wire via adapters/services.ts or setHttpClient.`);
+}
+// pos.service
+exports.posService = {
+    createPOSOrder: async (_businessId, _payload) => {
+        notImpl("posService.createPOSOrder");
+    },
+    fetchPOSOrderPreview: async (_businessId, _payload) => {
+        notImpl("posService.fetchPOSOrderPreview");
+    },
+    fetchBusinessOrders: async (_businessId, _params) => {
+        notImpl("posService.fetchBusinessOrders");
+    },
+};
+// seller.service
+exports.sellerService = {
+    acceptOrder: async (_orderId) => {
+        notImpl("sellerService.acceptOrder");
+    },
+    rejectOrder: async (_orderId) => {
+        notImpl("sellerService.rejectOrder");
+    },
+    startPreparingOrder: async (_orderId) => {
+        notImpl("sellerService.startPreparingOrder");
+    },
+    markOrderReady: async (_orderId) => {
+        notImpl("sellerService.markOrderReady");
+    },
+    completeOrderPickup: async (_orderId) => {
+        notImpl("sellerService.completeOrderPickup");
+    },
+    cancelOrder: async (_orderId) => {
+        notImpl("sellerService.cancelOrder");
+    },
+    confirmHandover: async (_deliveryId) => {
+        notImpl("sellerService.confirmHandover");
+    },
+};
+// kiosk.service
+exports.kioskService = {
+    assignKioskOrderToRider: async (_orderId, _riderId) => {
+        notImpl("kioskService.assignKioskOrderToRider");
+    },
+};
+// menu.service etc. for reference fallback
+exports.menuService = {
+    fetchBusinessMenuItems: async (_businessId, _page) => {
+        notImpl("menuService.fetchBusinessMenuItems");
+    },
+    fetchBusinessCategories: async (_businessId) => {
+        notImpl("menuService.fetchBusinessCategories");
+    },
+};
+exports.businessService = {
+    fetchBusinessMembers: async (_businessId) => {
+        notImpl("businessService.fetchBusinessMembers");
+    },
+    fetchBusinessTaxRules: async (_businessId) => {
+        notImpl("businessService.fetchBusinessTaxRules");
+    },
+    fetchBusinessById: async (_businessId) => {
+        notImpl("businessService.fetchBusinessById");
+    },
+    fetchOperatingHours: async (_businessId) => {
+        notImpl("businessService.fetchOperatingHours");
+    },
+};
+exports.rolesService = {
+    fetchBusinessRoles: async () => {
+        notImpl("rolesService.fetchBusinessRoles");
+    },
+};
+// region pricing + location stubs for currency utils
+function getRegionConfig(_countryCode) {
+    return { currencyCode: "GHS" };
+}
+function formatCurrencyByRegion(amountMinor, _config) {
+    return `GH₵${(amountMinor / 100).toFixed(2)}`;
+}
+exports.useLocationStore = {
+    getState: () => ({ currentLocation: null }),
+    // hook form: selector
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    subscribe: (_fn) => () => { },
+};

package/dist/adapters/sqlite.d.ts

@@ -0,0 +1,20 @@
+/**
+ * SQLite driver adapter — decouples core from expo-sqlite.
+ * Host apps inject a concrete driver via setSqliteDriver().
+ */
+export interface SQLiteRunResult {
+    lastInsertRowId: number;
+    changes: number;
+}
+export interface SqliteDriver {
+    execAsync(sql: string, ...args: unknown[]): Promise<void>;
+    runAsync(sql: string, ...args: unknown[]): Promise<SQLiteRunResult>;
+    getFirstAsync<T>(sql: string, ...args: unknown[]): Promise<T | null>;
+    getAllAsync<T>(sql: string, ...args: unknown[]): Promise<T[]>;
+    withTransactionAsync?(fn: () => Promise<void>): Promise<void>;
+    closeAsync?(): Promise<void>;
+}
+export type SQLiteDatabase = SqliteDriver;
+export declare function setSqliteDriver(d: SqliteDriver): void;
+export declare function getSqliteDriver(): SqliteDriver;
+export declare function hasSqliteDriver(): boolean;

package/dist/adapters/sqlite.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * SQLite driver adapter — decouples core from expo-sqlite.
+ * Host apps inject a concrete driver via setSqliteDriver().
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSqliteDriver = setSqliteDriver;
+exports.getSqliteDriver = getSqliteDriver;
+exports.hasSqliteDriver = hasSqliteDriver;
+let driver = null;
+function setSqliteDriver(d) {
+    driver = d;
+}
+function getSqliteDriver() {
+    if (!driver) {
+        throw new Error("SQLite driver not injected. Call setSqliteDriver(driver) before openSyncDatabase(). " +
+            "Provide an object implementing SqliteDriver (see src/adapters/sqlite.ts).");
+    }
+    return driver;
+}
+function hasSqliteDriver() {
+    return driver !== null;
+}

package/dist/db/connection.d.ts

@@ -0,0 +1,8 @@
+/**
+ * SQLite connection for the offline-first command outbox and event journal.
+ * Delegates to injected SqliteDriver (see src/adapters/sqlite.ts).
+ */
+import { type SQLiteDatabase } from "../adapters/sqlite";
+export declare function openSyncDatabase(): Promise<SQLiteDatabase>;
+export declare function getSyncDatabase(): SQLiteDatabase;
+export declare function closeSyncDatabase(): Promise<void>;

package/dist/db/connection.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * SQLite connection for the offline-first command outbox and event journal.
+ * Delegates to injected SqliteDriver (see src/adapters/sqlite.ts).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openSyncDatabase = openSyncDatabase;
+exports.getSyncDatabase = getSyncDatabase;
+exports.closeSyncDatabase = closeSyncDatabase;
+const sync_logger_1 = require("../utils/sync-logger");
+const migrations_1 = require("./migrations");
+const sqlite_1 = require("../adapters/sqlite");
+const DB_NAME = "teincfood_sync.db";
+let dbInstance = null;
+let initPromise = null;
+async function openSyncDatabase() {
+    if (dbInstance)
+        return dbInstance;
+    if (initPromise)
+        return initPromise;
+    if (!(0, sqlite_1.hasSqliteDriver)()) {
+        throw new Error("SQLite driver not injected. Call setSqliteDriver(driver) before openSyncDatabase().");
+    }
+    const driver = (0, sqlite_1.getSqliteDriver)();
+    initPromise = (async () => {
+        await runMigrations(driver);
+        dbInstance = driver;
+        sync_logger_1.syncLogger.info("SQLite", "Database opened and migrated", {
+            name: DB_NAME,
+        });
+        return driver;
+    })();
+    initPromise = initPromise.catch((error) => {
+        initPromise = null;
+        sync_logger_1.syncLogger.error("SQLite", "Failed to open sync database", {
+            error: String(error),
+        });
+        throw error;
+    });
+    return initPromise;
+}
+function getSyncDatabase() {
+    if (!dbInstance) {
+        // If driver injected but not yet opened, return driver directly to avoid "not initialized"
+        // during early replay (cold start). Migration will run on openSyncDatabase.
+        if ((0, sqlite_1.hasSqliteDriver)()) {
+            return (0, sqlite_1.getSqliteDriver)();
+        }
+        throw new Error("Sync database not initialized. Call openSyncDatabase() first.");
+    }
+    return dbInstance;
+}
+async function runMigrations(db) {
+    const doMigrate = async () => {
+        await db.execAsync(`
+      CREATE TABLE IF NOT EXISTS migrations (
+        version INTEGER PRIMARY KEY NOT NULL,
+        applied_at TEXT NOT NULL
+      );
+    `);
+        for (const migration of migrations_1.MIGRATIONS) {
+            const row = await db.getFirstAsync("SELECT version FROM migrations WHERE version = ?;", migration.version);
+            if (row)
+                continue;
+            await migration.up(db);
+            await db.runAsync("INSERT INTO migrations (version, applied_at) VALUES (?, ?);", migration.version, new Date().toISOString());
+            sync_logger_1.syncLogger.info("SQLite", "Applied migration", {
+                version: migration.version,
+            });
+        }
+    };
+    if (db.withTransactionAsync) {
+        await db.withTransactionAsync(doMigrate);
+    }
+    else {
+        await doMigrate();
+    }
+}
+async function closeSyncDatabase() {
+    if (dbInstance) {
+        if (dbInstance.closeAsync)
+            await dbInstance.closeAsync();
+        dbInstance = null;
+        initPromise = null;
+        sync_logger_1.syncLogger.info("SQLite", "Database closed");
+    }
+}

package/dist/db/migrations.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SQLite migrations for the offline-first command outbox and event journal.
+ */
+import type { SQLiteDatabase } from "../adapters/sqlite";
+export interface Migration {
+    version: number;
+    up: (db: SQLiteDatabase) => Promise<void>;
+}
+export declare const MIGRATIONS: Migration[];

package/dist/db/migrations.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * SQLite migrations for the offline-first command outbox and event journal.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIGRATIONS = void 0;
+exports.MIGRATIONS = [
+    {
+        version: 1,
+        up: async (db) => {
+            await db.execAsync(`
+          CREATE TABLE IF NOT EXISTS commands (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            command_id TEXT NOT NULL UNIQUE,
+            command_type TEXT NOT NULL,
+            command_version TEXT NOT NULL,
+            business_id TEXT NOT NULL,
+            entity_id TEXT,
+            user_id TEXT NOT NULL,
+            device_id TEXT NOT NULL,
+            payload TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'pending',
+            error TEXT,
+            retry_count INTEGER NOT NULL DEFAULT 0,
+            last_attempted_at TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+          );
+
+          CREATE INDEX IF NOT EXISTS idx_commands_status ON commands(status);
+          CREATE INDEX IF NOT EXISTS idx_commands_business ON commands(business_id);
+          CREATE INDEX IF NOT EXISTS idx_commands_entity ON commands(entity_id);
+          CREATE INDEX IF NOT EXISTS idx_commands_created_at ON commands(created_at);
+        `);
+            await db.execAsync(`
+          CREATE TABLE IF NOT EXISTS events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            event_id TEXT NOT NULL UNIQUE,
+            event_type TEXT NOT NULL,
+            event_version TEXT NOT NULL,
+            entity_id TEXT NOT NULL,
+            user_id TEXT NOT NULL,
+            device_id TEXT NOT NULL,
+            payload TEXT NOT NULL,
+            origin TEXT NOT NULL,
+            synced_to_cloud INTEGER NOT NULL DEFAULT 0,
+            timestamp TEXT NOT NULL,
+            persisted_at TEXT NOT NULL
+          );
+
+          CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
+          CREATE INDEX IF NOT EXISTS idx_events_entity ON events(entity_id);
+          CREATE INDEX IF NOT EXISTS idx_events_synced ON events(synced_to_cloud);
+          CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+          CREATE INDEX IF NOT EXISTS idx_events_origin ON events(origin);
+        `);
+            await db.execAsync(`
+          CREATE TABLE IF NOT EXISTS entity_snapshots (
+            entity_type TEXT NOT NULL,
+            entity_id TEXT NOT NULL,
+            last_event_id TEXT NOT NULL,
+            last_event_timestamp TEXT NOT NULL,
+            payload TEXT NOT NULL,
+            PRIMARY KEY (entity_type, entity_id)
+          );
+
+          CREATE INDEX IF NOT EXISTS idx_snapshots_entity_id ON entity_snapshots(entity_id);
+        `);
+            await db.execAsync(`
+          CREATE TABLE IF NOT EXISTS reference_data (
+            key TEXT NOT NULL PRIMARY KEY,
+            version TEXT NOT NULL,
+            payload TEXT NOT NULL,
+            downloaded_at TEXT NOT NULL
+          );
+        `);
+        },
+    },
+    {
+        version: 2,
+        up: async (db) => {
+            await db.execAsync(`
+          ALTER TABLE entity_snapshots ADD COLUMN business_id TEXT;
+          CREATE INDEX IF NOT EXISTS idx_snapshots_business ON entity_snapshots(business_id, entity_type);
+
+          CREATE TABLE reference_data_new (
+            business_id TEXT NOT NULL,
+            key TEXT NOT NULL,
+            version TEXT NOT NULL,
+            payload TEXT NOT NULL,
+            downloaded_at TEXT NOT NULL,
+            PRIMARY KEY (business_id, key)
+          );
+        `);
+            await db.execAsync(`
+          INSERT INTO reference_data_new (business_id, key, version, payload, downloaded_at)
+          SELECT '', key, version, payload, downloaded_at FROM reference_data;
+        `);
+            await db.execAsync(`
+          DROP TABLE reference_data;
+          ALTER TABLE reference_data_new RENAME TO reference_data;
+          CREATE INDEX IF NOT EXISTS idx_reference_data_business ON reference_data(business_id);
+        `);
+        },
+    },
+];

package/dist/db/operations.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Low-level SQLite operations for the command outbox and event journal.
+ */
+import type { SQLiteDatabase } from "../adapters/sqlite";
+import type { Command, DomainEvent, PersistedCommand } from "../sync/types";
+export interface InsertCommandInput {
+    command: Command;
+    status?: PersistedCommand["status"];
+}
+export declare function insertCommand(db: SQLiteDatabase, input: InsertCommandInput): Promise<PersistedCommand>;
+export declare function getPendingCommands(db: SQLiteDatabase, limit?: number): Promise<PersistedCommand[]>;
+export declare function updateCommandStatus(db: SQLiteDatabase, commandId: string, status: PersistedCommand["status"], error?: string): Promise<void>;
+export declare function markCommandInFlight(db: SQLiteDatabase, commandId: string): Promise<void>;
+export declare function deleteCommand(db: SQLiteDatabase, commandId: string): Promise<void>;
+export declare function clearCompletedCommands(db: SQLiteDatabase, olderThanHours?: number): Promise<void>;
+export interface InsertEventInput {
+    event: DomainEvent;
+    origin: "local" | "cloud" | "lan";
+    syncedToCloud?: boolean;
+}
+export declare function insertEvent(db: SQLiteDatabase, input: InsertEventInput): Promise<void>;
+export declare function getEventsForEntity(db: SQLiteDatabase, entityId: string, limit?: number): Promise<DomainEvent[]>;
+export declare function getUnsyncedEvents(db: SQLiteDatabase, origin?: "local" | "lan", limit?: number): Promise<DomainEvent[]>;
+export declare function markEventsSynced(db: SQLiteDatabase, eventIds: string[]): Promise<void>;
+export interface EntitySnapshot<T = unknown> {
+    entity_type: string;
+    entity_id: string;
+    business_id: string | null;
+    last_event_id: string;
+    last_event_timestamp: string;
+    payload: T;
+}
+export interface UpsertEntitySnapshotInput<T = unknown> {
+    entityType: string;
+    entityId: string;
+    businessId?: string | null;
+    lastEventId: string;
+    lastEventTimestamp: string;
+    payload: T;
+}
+export declare function upsertEntitySnapshot<T>(db: SQLiteDatabase, input: UpsertEntitySnapshotInput<T>): Promise<void>;
+export declare function getEntitySnapshot<T>(db: SQLiteDatabase, entityType: string, entityId: string): Promise<EntitySnapshot<T> | null>;
+export declare function getEntitySnapshotsByType<T>(db: SQLiteDatabase, entityType: string): Promise<EntitySnapshot<T>[]>;
+export declare function deleteEntitySnapshot(db: SQLiteDatabase, entityType: string, entityId: string): Promise<void>;
+export declare function pruneEntitySnapshots(db: SQLiteDatabase, entityType: string, cutoffIso: string): Promise<void>;

package/dist/db/operations.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Low-level SQLite operations for the command outbox and event journal.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertCommand = insertCommand;
+exports.getPendingCommands = getPendingCommands;
+exports.updateCommandStatus = updateCommandStatus;
+exports.markCommandInFlight = markCommandInFlight;
+exports.deleteCommand = deleteCommand;
+exports.clearCompletedCommands = clearCompletedCommands;
+exports.insertEvent = insertEvent;
+exports.getEventsForEntity = getEventsForEntity;
+exports.getUnsyncedEvents = getUnsyncedEvents;
+exports.markEventsSynced = markEventsSynced;
+exports.upsertEntitySnapshot = upsertEntitySnapshot;
+exports.getEntitySnapshot = getEntitySnapshot;
+exports.getEntitySnapshotsByType = getEntitySnapshotsByType;
+exports.deleteEntitySnapshot = deleteEntitySnapshot;
+exports.pruneEntitySnapshots = pruneEntitySnapshots;
+const sync_logger_1 = require("../utils/sync-logger");
+async function insertCommand(db, input) {
+    const { command, status = "pending" } = input;
+    const now = new Date().toISOString();
+    const payload = JSON.stringify(command.payload);
+    const result = await db.runAsync(`
+      INSERT INTO commands (
+        command_id, command_type, command_version, business_id, entity_id,
+        user_id, device_id, payload, status, retry_count, last_attempted_at,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(command_id) DO UPDATE SET
+        status = excluded.status,
+        payload = excluded.payload,
+        updated_at = excluded.updated_at;
+    `, command.command_id, command.command_type, command.command_version, command.business_id, command.entity_id ?? null, command.user_id, command.device_id, payload, status, 0, null, now, now);
+    const row = await db.getFirstAsync("SELECT * FROM commands WHERE id = ?;", result.lastInsertRowId);
+    if (!row) {
+        throw new Error(`Failed to insert command ${command.command_id}`);
+    }
+    sync_logger_1.syncLogger.command(command, "queued");
+    return rowToPersistedCommand(row);
+}
+async function getPendingCommands(db, limit = 100) {
+    const rows = await db.getAllAsync(`
+      SELECT * FROM commands
+      WHERE status IN ('pending', 'failed')
+      ORDER BY created_at ASC
+      LIMIT ?;
+    `, limit);
+    return rows.map(rowToPersistedCommand);
+}
+async function updateCommandStatus(db, commandId, status, error) {
+    const now = new Date().toISOString();
+    if (status === "failed") {
+        await db.runAsync(`
+        UPDATE commands
+        SET status = ?, error = ?, retry_count = retry_count + 1,
+            last_attempted_at = ?, updated_at = ?
+        WHERE command_id = ?;
+      `, status, error ?? null, now, now, commandId);
+    }
+    else if (status === "completed") {
+        await db.runAsync("UPDATE commands SET status = ?, error = NULL, updated_at = ? WHERE command_id = ?;", status, now, commandId);
+    }
+    else {
+        await db.runAsync("UPDATE commands SET status = ?, error = ?, updated_at = ? WHERE command_id = ?;", status, error ?? null, now, commandId);
+    }
+    sync_logger_1.syncLogger.debug("CommandOutbox", "Status updated", { commandId, status });
+}
+async function markCommandInFlight(db, commandId) {
+    const now = new Date().toISOString();
+    await db.runAsync(`
+      UPDATE commands
+      SET status = 'in_flight', last_attempted_at = ?, updated_at = ?
+      WHERE command_id = ?;
+    `, now, now, commandId);
+}
+async function deleteCommand(db, commandId) {
+    await db.runAsync("DELETE FROM commands WHERE command_id = ?;", commandId);
+}
+async function clearCompletedCommands(db, olderThanHours = 24) {
+    const cutoff = new Date(Date.now() - olderThanHours * 60 * 60 * 1000).toISOString();
+    await db.runAsync("DELETE FROM commands WHERE status = 'completed' AND updated_at < ?;", cutoff);
+}
+async function insertEvent(db, input) {
+    const { event, origin, syncedToCloud = false } = input;
+    await db.runAsync(`
+      INSERT INTO events (
+        event_id, event_type, event_version, entity_id, user_id, device_id,
+        payload, origin, synced_to_cloud, timestamp, persisted_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(event_id) DO NOTHING;
+    `, event.event_id, event.event_type, event.event_version, event.entity_id, event.user_id, event.device_id, JSON.stringify(event.payload), origin, syncedToCloud ? 1 : 0, event.timestamp, new Date().toISOString());
+    sync_logger_1.syncLogger.event(event, "persisted", { origin, syncedToCloud });
+}
+async function getEventsForEntity(db, entityId, limit = 100) {
+    const rows = await db.getAllAsync(`
+      SELECT * FROM events
+      WHERE entity_id = ?
+      ORDER BY timestamp ASC
+      LIMIT ?;
+    `, entityId, limit);
+    return rows.map(rowToDomainEvent);
+}
+async function getUnsyncedEvents(db, origin = "local", limit = 100) {
+    const rows = await db.getAllAsync(`
+      SELECT * FROM events
+      WHERE origin = ? AND synced_to_cloud = 0
+      ORDER BY timestamp ASC
+      LIMIT ?;
+    `, origin, limit);
+    return rows.map(rowToDomainEvent);
+}
+async function markEventsSynced(db, eventIds) {
+    if (eventIds.length === 0)
+        return;
+    const placeholders = eventIds.map(() => "?").join(",");
+    await db.runAsync(`UPDATE events SET synced_to_cloud = 1 WHERE event_id IN (${placeholders});`, ...eventIds);
+}
+function rowToEntitySnapshot(row) {
+    return {
+        entity_type: row.entity_type,
+        entity_id: row.entity_id,
+        business_id: row.business_id,
+        last_event_id: row.last_event_id,
+        last_event_timestamp: row.last_event_timestamp,
+        payload: JSON.parse(row.payload),
+    };
+}
+async function upsertEntitySnapshot(db, input) {
+    const { entityType, entityId, businessId = null, lastEventId, lastEventTimestamp, payload, } = input;
+    const existing = await db.getFirstAsync("SELECT last_event_timestamp FROM entity_snapshots WHERE entity_type = ? AND entity_id = ?;", entityType, entityId);
+    if (existing && existing.last_event_timestamp > lastEventTimestamp) {
+        return;
+    }
+    await db.runAsync(`
+      INSERT INTO entity_snapshots (entity_type, entity_id, business_id, last_event_id, last_event_timestamp, payload)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(entity_type, entity_id) DO UPDATE SET
+        business_id = excluded.business_id,
+        last_event_id = excluded.last_event_id,
+        last_event_timestamp = excluded.last_event_timestamp,
+        payload = excluded.payload;
+    `, entityType, entityId, businessId, lastEventId, lastEventTimestamp, JSON.stringify(payload));
+}
+async function getEntitySnapshot(db, entityType, entityId) {
+    const row = await db.getFirstAsync("SELECT * FROM entity_snapshots WHERE entity_type = ? AND entity_id = ?;", entityType, entityId);
+    return row ? rowToEntitySnapshot(row) : null;
+}
+async function getEntitySnapshotsByType(db, entityType) {
+    const rows = await db.getAllAsync("SELECT * FROM entity_snapshots WHERE entity_type = ? ORDER BY last_event_timestamp DESC;", entityType);
+    return rows.map(rowToEntitySnapshot);
+}
+async function deleteEntitySnapshot(db, entityType, entityId) {
+    await db.runAsync("DELETE FROM entity_snapshots WHERE entity_type = ? AND entity_id = ?;", entityType, entityId);
+}
+async function pruneEntitySnapshots(db, entityType, cutoffIso) {
+    await db.runAsync("DELETE FROM entity_snapshots WHERE entity_type = ? AND last_event_timestamp < ?;", entityType, cutoffIso);
+}
+function rowToPersistedCommand(row) {
+    return {
+        id: row.id,
+        command_id: row.command_id,
+        command_type: row.command_type,
+        command_version: row.command_version,
+        business_id: row.business_id,
+        entity_id: row.entity_id ?? undefined,
+        user_id: row.user_id,
+        device_id: row.device_id,
+        payload: JSON.parse(row.payload),
+        status: row.status,
+        error: row.error,
+        retry_count: row.retry_count,
+        last_attempted_at: row.last_attempted_at ?? undefined,
+        timestamp: row.timestamp,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
+function rowToDomainEvent(row) {
+    return {
+        event_id: row.event_id,
+        event_type: row.event_type,
+        event_version: row.event_version,
+        entity_id: row.entity_id,
+        user_id: row.user_id,
+        device_id: row.device_id,
+        payload: JSON.parse(row.payload),
+        timestamp: row.timestamp,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @teincfood/core — shared offline-first backbone
+ *
+ * Entry point. Re-exports types, sync engine, DB, reference service, repos and adapters.
+ * Host apps call `createTeincCore` once at bootstrap to wire platform adapters.
+ */
+export * from "./types/api";
+export * from "./types/pos.types";
+export * from "./utils/constants";
+export * from "./utils/currency";
+export * from "./utils/error";
+export * from "./utils/uuid";
+export * from "./utils/sync-logger";
+export * from "./db/migrations";
+export * as dbOps from "./db/operations";
+export { openSyncDatabase, getSyncDatabase } from "./db/connection";
+export * from "./sync/types";
+export { SyncEngine } from "./sync/engine";
+export { commandQueueService } from "./sync/command-queue.service";
+export { buildCommand } from "./sync/command-builder";
+export { generateLocalOrderNumber, generateLocalCalloutNumber, isLocalOrderNumber } from "./sync/order-number";
+export { orderSnapshotsService } from "./sync/order-snapshots.service";
+export * from "./sync/pending-orders.service";
+export { orderRepository } from "./repositories/order.repository";
+export { posRepository } from "./repositories/pos.repository";
+export * from "./reference/types";
+export { referenceSyncService } from "./reference/service";
+export * from "./adapters/sqlite";
+export * from "./adapters/kv";
+export * from "./adapters/connectivity";
+export * from "./adapters/http";
+export * from "./adapters/local-node";
+import { type SqliteDriver } from "./adapters/sqlite";
+import { type KVDriver } from "./adapters/kv";
+import { type HttpClient } from "./adapters/http";
+import { SyncEngine } from "./sync/engine";
+export interface CoreConfig {
+    sqliteDriver?: SqliteDriver;
+    kvDriver?: KVDriver;
+    httpClient?: HttpClient;
+    /** Optional initial connectivity override */
+    initialConnectivity?: {
+        isOnline?: boolean;
+        isCloudReachable?: "reachable" | "unreachable" | "unknown";
+    };
+}
+export declare function createTeincCore(config?: CoreConfig): {
+    engine: SyncEngine;
+};
+export declare function getCoreEngine(): SyncEngine;