@teincfood/core 0.1.6 → 0.7.1

package/dist/sync/use-sync-reconciliation.js

@@ -22,7 +22,7 @@ function isLocalOrderEvent(event) {
     if (!payload)
         return false;
     const localOrderNumber = payload.local_order_number;
-    return typeof localOrderNumber === "string" && localOrderNumber.startsWith("TFL-");
+    return typeof localOrderNumber === "string" && /^[0-9]{2}-[0-9]{3}-[0-9]{3}$/.test(localOrderNumber);
 }
 export function useSyncReconciliation() {
     const queryClient = useQueryClient();

package/dist/test-helpers/memory-driver.d.ts

@@ -0,0 +1,8 @@
+/**
+ * In-memory SQLite driver for standalone integration tests (0.7.0).
+ * Covers migrations, reference_data, entity_snapshots, commands, events.
+ * No SQL parsing — string-contains dispatch, JSON payloads.
+ */
+import type { SqliteDriver } from "../adapters/sqlite";
+export declare function createMemoryDriver(): SqliteDriver;
+export declare function resetMemoryDriver(): void;

package/dist/test-helpers/memory-driver.js

@@ -0,0 +1,242 @@
+export function createMemoryDriver() {
+    const tables = {
+        migrations: [],
+        reference_data: [],
+        entity_snapshots: [],
+        commands: [],
+        events: [],
+    };
+    let autoId = { commands: 1, events: 1, migrations: 1 };
+    const driver = {
+        async execAsync(_sql) {
+            // No-op: CREATE TABLE / INDEX / ALTER all just ensure table array exists.
+            // For ALTER ADD COLUMN we don't need to do anything — rows are schemaless.
+            return;
+        },
+        async runAsync(sql, ...args) {
+            const s = sql.replace(/\s+/g, " ").trim();
+            // migrations insert
+            if (s.includes("INSERT INTO migrations")) {
+                const version = args[0];
+                tables.migrations.push({ version, applied_at: args[1] });
+                return { lastInsertRowId: autoId.migrations++, changes: 1 };
+            }
+            // reference_data insert
+            if (s.includes("INSERT INTO reference_data")) {
+                const [business_id, key, version, payload, downloaded_at, last_event_id, last_hlc] = args;
+                const idx = tables.reference_data.findIndex((r) => r.business_id === business_id && r.key === key);
+                const row = { business_id, key, version, payload, downloaded_at, last_event_id, last_hlc };
+                if (idx >= 0)
+                    tables.reference_data[idx] = row;
+                else
+                    tables.reference_data.push(row);
+                return { lastInsertRowId: 1, changes: 1 };
+            }
+            // reference_data delete
+            if (s.includes("DELETE FROM reference_data WHERE business_id = ? AND key =")) {
+                const [business_id, key] = args;
+                tables.reference_data = tables.reference_data.filter((r) => !(r.business_id === business_id && r.key === key));
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            if (s.includes("DELETE FROM reference_data WHERE business_id = ?")) {
+                const [business_id] = args;
+                tables.reference_data = tables.reference_data.filter((r) => r.business_id !== business_id);
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            // entity_snapshots insert
+            if (s.includes("INSERT INTO entity_snapshots")) {
+                const [entity_type, entity_id, business_id, last_event_id, last_event_timestamp, payload] = args;
+                const idx = tables.entity_snapshots.findIndex((r) => r.entity_type === entity_type && r.entity_id === entity_id);
+                const row = { entity_type, entity_id, business_id, last_event_id, last_event_timestamp, payload };
+                if (idx >= 0)
+                    tables.entity_snapshots[idx] = row;
+                else
+                    tables.entity_snapshots.push(row);
+                return { lastInsertRowId: 1, changes: 1 };
+            }
+            // entity_snapshots delete
+            if (s.includes("DELETE FROM entity_snapshots WHERE entity_type = ? AND entity_id =")) {
+                const [entity_type, entity_id] = args;
+                tables.entity_snapshots = tables.entity_snapshots.filter((r) => !(r.entity_type === entity_type && r.entity_id === entity_id));
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            if (s.includes("DELETE FROM entity_snapshots WHERE entity_type = ? AND last_event_timestamp <")) {
+                const [entity_type, cutoff] = args;
+                tables.entity_snapshots = tables.entity_snapshots.filter((r) => !(r.entity_type === entity_type && r.last_event_timestamp < cutoff));
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            // commands insert
+            if (s.includes("INSERT INTO commands")) {
+                const [command_id, command_type, command_version, business_id, entity_id, user_id, device_id, payload, status] = args;
+                const existing = tables.commands.find((r) => r.command_id === command_id);
+                const row = {
+                    id: existing ? existing.id : autoId.commands++,
+                    command_id,
+                    command_type,
+                    command_version,
+                    business_id,
+                    entity_id,
+                    user_id,
+                    device_id,
+                    payload,
+                    status,
+                    error: null,
+                    retry_count: 0,
+                    last_attempted_at: null,
+                    created_at: args[11],
+                    updated_at: args[12],
+                    timestamp: new Date().toISOString(),
+                };
+                if (existing)
+                    Object.assign(existing, row);
+                else
+                    tables.commands.push(row);
+                return { lastInsertRowId: row.id, changes: 1 };
+            }
+            // commands update status
+            if (s.includes("UPDATE commands SET status = ?")) {
+                const [status, error, _now, _now2, command_id] = args;
+                // also handles variants with retry_count increment
+                const row = tables.commands.find((r) => r.command_id === command_id);
+                if (row) {
+                    row.status = status;
+                    row.error = error;
+                    if (s.includes("retry_count = retry_count + 1"))
+                        row.retry_count += 1;
+                }
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            if (s.includes("UPDATE commands SET status = 'in_flight'")) {
+                const [now, _now2, command_id] = args;
+                const row = tables.commands.find((r) => r.command_id === command_id);
+                if (row) {
+                    row.status = "in_flight";
+                    row.last_attempted_at = now;
+                }
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            if (s.includes("DELETE FROM commands WHERE command_id")) {
+                const [command_id] = args;
+                tables.commands = tables.commands.filter((r) => r.command_id !== command_id);
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            if (s.includes("DELETE FROM commands WHERE status = 'completed'")) {
+                const [cutoff] = args;
+                tables.commands = tables.commands.filter((r) => !(r.status === "completed" && r.updated_at < cutoff));
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            if (s.includes("UPDATE commands SET payload")) {
+                const [payload, command_id] = args;
+                const row = tables.commands.find((r) => r.command_id === command_id);
+                if (row)
+                    row.payload = payload;
+                return { lastInsertRowId: 0, changes: 1 };
+            }
+            // events insert
+            if (s.includes("INSERT INTO events")) {
+                const [event_id, event_type, event_version, entity_id, user_id, device_id, payload, origin, synced_to_cloud, timestamp, persisted_at] = args;
+                if (tables.events.find((r) => r.event_id === event_id))
+                    return { lastInsertRowId: 0, changes: 0 };
+                const row = {
+                    id: autoId.events++,
+                    event_id,
+                    event_type,
+                    event_version,
+                    entity_id,
+                    user_id,
+                    device_id,
+                    payload,
+                    origin,
+                    synced_to_cloud,
+                    timestamp,
+                    persisted_at,
+                };
+                tables.events.push(row);
+                return { lastInsertRowId: row.id, changes: 1 };
+            }
+            // events update synced
+            if (s.includes("UPDATE events SET synced_to_cloud = 1 WHERE event_id IN")) {
+                const ids = args;
+                for (const row of tables.events)
+                    if (ids.includes(row.event_id))
+                        row.synced_to_cloud = 1;
+                return { lastInsertRowId: 0, changes: ids.length };
+            }
+            return { lastInsertRowId: 0, changes: 0 };
+        },
+        async getFirstAsync(sql, ...args) {
+            const s = sql.replace(/\s+/g, " ").trim();
+            if (s.includes("SELECT version FROM migrations WHERE version =")) {
+                const version = args[0];
+                const row = tables.migrations.find((r) => r.version === version);
+                return (row ? { version: row.version } : null);
+            }
+            if (s.includes("SELECT * FROM reference_data WHERE business_id = ? AND key =")) {
+                const [business_id, key] = args;
+                const row = tables.reference_data.find((r) => r.business_id === business_id && r.key === key);
+                return row ?? null;
+            }
+            if (s.includes("SELECT version FROM reference_data WHERE business_id = ? AND key =")) {
+                const [business_id, key] = args;
+                const row = tables.reference_data.find((r) => r.business_id === business_id && r.key === key);
+                return (row ? { version: row.version } : null);
+            }
+            if (s.includes("SELECT last_event_timestamp FROM entity_snapshots WHERE entity_type = ? AND entity_id =")) {
+                const [entity_type, entity_id] = args;
+                const row = tables.entity_snapshots.find((r) => r.entity_type === entity_type && r.entity_id === entity_id);
+                return (row ? { last_event_timestamp: row.last_event_timestamp } : null);
+            }
+            if (s.includes("SELECT * FROM entity_snapshots WHERE entity_type = ? AND entity_id =")) {
+                const [entity_type, entity_id] = args;
+                const row = tables.entity_snapshots.find((r) => r.entity_type === entity_type && r.entity_id === entity_id);
+                return row ?? null;
+            }
+            if (s.includes("SELECT * FROM commands WHERE id =")) {
+                const id = args[0];
+                const row = tables.commands.find((r) => r.id === id);
+                return row ?? null;
+            }
+            return null;
+        },
+        async getAllAsync(sql, ...args) {
+            const s = sql.replace(/\s+/g, " ").trim();
+            if (s.includes("SELECT key FROM reference_data WHERE business_id = ? ORDER BY key")) {
+                const [business_id] = args;
+                return tables.reference_data.filter((r) => r.business_id === business_id).map((r) => ({ key: r.key }));
+            }
+            if (s.includes("SELECT * FROM entity_snapshots WHERE entity_type = ? ORDER BY last_event_timestamp DESC")) {
+                const [entity_type] = args;
+                const rows = tables.entity_snapshots.filter((r) => r.entity_type === entity_type).sort((a, b) => (a.last_event_timestamp < b.last_event_timestamp ? 1 : -1));
+                return rows;
+            }
+            if (s.includes("SELECT * FROM commands") && s.includes("WHERE status IN")) {
+                const limit = args[args.length - 1];
+                let rows = tables.commands.filter((r) => r.status === "pending" || r.status === "failed").sort((a, b) => (a.created_at < b.created_at ? -1 : 1));
+                if (limit)
+                    rows = rows.slice(0, limit);
+                return rows;
+            }
+            if (s.includes("SELECT * FROM events") && s.includes("WHERE entity_id = ?")) {
+                const [entity_id, limit] = args;
+                let rows = tables.events.filter((r) => r.entity_id === entity_id).sort((a, b) => (a.timestamp < b.timestamp ? -1 : 1));
+                if (limit)
+                    rows = rows.slice(0, limit);
+                return rows;
+            }
+            if (s.includes("SELECT * FROM events") && s.includes("WHERE origin = ? AND synced_to_cloud = 0")) {
+                const [origin, limit] = args;
+                let rows = tables.events.filter((r) => r.origin === origin && r.synced_to_cloud === 0).sort((a, b) => (a.timestamp < b.timestamp ? -1 : 1));
+                if (limit && limit !== Number.MAX_SAFE_INTEGER)
+                    rows = rows.slice(0, limit);
+                return rows;
+            }
+            return [];
+        },
+    };
+    // expose tables for inspection in tests
+    driver._tables = tables;
+    return driver;
+}
+export function resetMemoryDriver() {
+    // helper for isolation — callers create new driver per test
+}

package/dist/utils/constants.d.ts

@@ -10,7 +10,7 @@ export declare function setApiBaseUrl(url: string | undefined): void;
 export declare function setWsBaseUrl(url: string | undefined): void;
 /** App metadata */
 export declare const APP_NAME = "Teinc Food Business";
-export declare const APP_VERSION = "1.0.0";
+export declare const APP_VERSION = "0.7.1";
 /** Async storage keys */
 export declare const STORAGE_KEYS: {
     readonly AUTH_TOKEN: "auth_token";
@@ -49,13 +49,13 @@ export declare const DEFAULT_PAGE_SIZE = 20;
  * Keeps the terminal responsive (fast) even when the internet is slow.
  */
 export declare const CLOUD_COMMAND_TIMEOUT_MS = 2500;
-export declare const appVersion = "1.0.0";
+export declare const appVersion = "0.7.1";
 /** Default config bundle for createTeincCore overrides */
 export declare const DEFAULTS: {
     readonly API_BASE_URL: string;
     readonly WS_BASE_URL: string;
     readonly APP_NAME: "Teinc Food Business";
-    readonly APP_VERSION: "1.0.0";
+    readonly APP_VERSION: "0.7.1";
     readonly STORAGE_KEYS: {
         readonly AUTH_TOKEN: "auth_token";
         readonly REFRESH_TOKEN: "refresh_token";

package/dist/utils/constants.js

@@ -38,7 +38,7 @@ export function setWsBaseUrl(url) {
 }
 /** App metadata */
 export const APP_NAME = "Teinc Food Business";
-export const APP_VERSION = "1.0.0";
+export const APP_VERSION = "0.7.1";
 /** Async storage keys */
 export const STORAGE_KEYS = {
     AUTH_TOKEN: "auth_token",

package/dist/utils/hlc.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Hybrid Logical Clock (HLC) for offline-first causal ordering.
+ *
+ * Encodes as "wallMs-counter-deviceId" (e.g. "1714560000000-2-01").
+ * Ordering: wallMs → counter → deviceId lexical.
+ * Guarantees monotonic per-device even if wall clock skews.
+ */
+export interface HLC {
+    wallMs: number;
+    counter: number;
+    deviceId: string;
+}
+export declare function hlcToString(h: HLC): string;
+export declare function hlcFromString(s: string): HLC | null;
+export declare function compareHLC(a: HLC, b: HLC): number;
+export declare function compareHLCString(a: string, b: string): number;
+export declare function tickHLC(wallMs: number, last: HLC | null, deviceId: string): HLC;
+export declare function maxHLC(a: HLC | null, b: HLC | null): HLC | null;

package/dist/utils/hlc.js

@@ -0,0 +1,60 @@
+/**
+ * Hybrid Logical Clock (HLC) for offline-first causal ordering.
+ *
+ * Encodes as "wallMs-counter-deviceId" (e.g. "1714560000000-2-01").
+ * Ordering: wallMs → counter → deviceId lexical.
+ * Guarantees monotonic per-device even if wall clock skews.
+ */
+export function hlcToString(h) {
+    return `${h.wallMs}-${String(h.counter).padStart(6, "0")}-${h.deviceId}`;
+}
+export function hlcFromString(s) {
+    const parts = s.split("-");
+    if (parts.length < 3)
+        return null;
+    const wallMs = Number(parts[0]);
+    const counter = Number(parts[1]);
+    const deviceId = parts.slice(2).join("-");
+    if (!Number.isFinite(wallMs) || !Number.isFinite(counter) || !deviceId)
+        return null;
+    return { wallMs, counter, deviceId };
+}
+export function compareHLC(a, b) {
+    if (a.wallMs !== b.wallMs)
+        return a.wallMs - b.wallMs;
+    if (a.counter !== b.counter)
+        return a.counter - b.counter;
+    if (a.deviceId < b.deviceId)
+        return -1;
+    if (a.deviceId > b.deviceId)
+        return 1;
+    return 0;
+}
+export function compareHLCString(a, b) {
+    const ha = hlcFromString(a);
+    const hb = hlcFromString(b);
+    if (!ha && !hb)
+        return a.localeCompare(b);
+    if (!ha)
+        return -1;
+    if (!hb)
+        return 1;
+    return compareHLC(ha, hb);
+}
+export function tickHLC(wallMs, last, deviceId) {
+    if (!last)
+        return { wallMs, counter: 0, deviceId };
+    if (wallMs > last.wallMs)
+        return { wallMs, counter: 0, deviceId };
+    if (wallMs === last.wallMs)
+        return { wallMs, counter: last.counter + 1, deviceId };
+    // wallMs < last.wallMs (clock skew) — bump counter
+    return { wallMs: last.wallMs, counter: last.counter + 1, deviceId };
+}
+export function maxHLC(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return compareHLC(a, b) >= 0 ? a : b;
+}

package/dist/utils/hlc.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/hlc.test.js

@@ -0,0 +1,29 @@
+import { describe, it, expect } from "vitest";
+import { tickHLC, compareHLCString, hlcToString, hlcFromString } from "./hlc";
+describe("HLC", () => {
+    it("monotonic wall", () => {
+        const a = tickHLC(1000, null, "01");
+        const b = tickHLC(1001, a, "01");
+        expect(compareHLCString(hlcToString(b), hlcToString(a))).toBeGreaterThan(0);
+    });
+    it("counter on same wall", () => {
+        const a = tickHLC(1000, null, "01");
+        const b = tickHLC(1000, a, "01");
+        expect(b.counter).toBe(1);
+    });
+    it("skew bump", () => {
+        const a = tickHLC(1000, null, "01");
+        const b = tickHLC(999, a, "02");
+        expect(b.wallMs).toBe(1000);
+        expect(b.counter).toBe(1);
+    });
+    it("deviceId tie-break", () => {
+        const a = { wallMs: 1000, counter: 0, deviceId: "01" };
+        const b = { wallMs: 1000, counter: 0, deviceId: "02" };
+        expect(compareHLCString(hlcToString(a), hlcToString(b))).toBeLessThan(0);
+    });
+    it("roundtrip", () => {
+        const h = { wallMs: 1714560000000, counter: 2, deviceId: "10" };
+        expect(hlcFromString(hlcToString(h))).toEqual(h);
+    });
+});

package/package.json

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