local-lite 0.0.5 → 0.0.7

package/dist/react/index.js

@@ -33,14 +33,14 @@ function areRowsEqual(a, b) {
     if (aObj.id !== undefined && bObj.id !== undefined && aObj.id !== bObj.id) {
         return false;
     }
-    // Fast path: if both records have an identical updated_at timestamp, they are equal.
-    // This bypasses expensive Object.keys loops and JSON.stringify on large metadata columns.
+    const aTs = aObj.updated_at ?? aObj.updatedAt;
+    const bTs = bObj.updated_at ?? bObj.updatedAt;
     if (aObj.id !== undefined &&
         bObj.id !== undefined &&
         aObj.id === bObj.id &&
-        aObj.updated_at !== undefined &&
-        bObj.updated_at !== undefined) {
-        return aObj.updated_at === bObj.updated_at;
+        aTs !== undefined &&
+        bTs !== undefined) {
+        return aTs === bTs;
     }
     const aKeys = Object.keys(aObj);
     const bKeys = Object.keys(bObj);
@@ -80,9 +80,83 @@ function areRowArraysEqual(a, b) {
     }
     return true;
 }
-// In-memory query result cache to eliminate initial render latency and flickering
-const queryCache = new Map();
+const MAX_QUERY_CACHE_SIZE = 100;
+class LRUQueryCache {
+    map = new Map();
+    get(key) {
+        const val = this.map.get(key);
+        if (val !== undefined) {
+            this.map.delete(key);
+            this.map.set(key, val);
+        }
+        return val;
+    }
+    set(key, val) {
+        if (this.map.has(key)) {
+            this.map.delete(key);
+        }
+        else if (this.map.size >= MAX_QUERY_CACHE_SIZE) {
+            const oldestKey = this.map.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.map.delete(oldestKey);
+            }
+        }
+        this.map.set(key, val);
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    delete(key) {
+        return this.map.delete(key);
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+// In-memory query result cache capped with LRU eviction to prevent memory leaks
+const queryCache = new LRUQueryCache();
 const inFlightQueries = new Map();
+const tableVersions = new WeakMap();
+const clientIds = new WeakMap();
+let nextClientId = 1;
+function getClientScope(client) {
+    if (!client)
+        return 'no-client';
+    let id = clientIds.get(client);
+    if (!id) {
+        id = nextClientId++;
+        clientIds.set(client, id);
+    }
+    return 'client-' + id;
+}
+function getScopedCacheKey(client, key) {
+    return getClientScope(client) + ':' + key;
+}
+function getTableVersion(client, tableName) {
+    if (!client)
+        return 0;
+    return tableVersions.get(client)?.get(tableName) || 0;
+}
+function advanceTableVersion(client, tableName) {
+    if (!client)
+        return 0;
+    let versions = tableVersions.get(client);
+    if (!versions) {
+        versions = new Map();
+        tableVersions.set(client, versions);
+    }
+    const nextVersion = getTableVersion(client, tableName) + 1;
+    versions.set(tableName, nextVersion);
+    return nextVersion;
+}
+async function fetchDeduped(key, fn) {
+    let inFlight = inFlightQueries.get(key);
+    if (!inFlight) {
+        inFlight = fn().finally(() => inFlightQueries.delete(key));
+        inFlightQueries.set(key, inFlight);
+    }
+    return inFlight;
+}
 /**
  * Clears the in-memory live query cache.
  */
@@ -114,7 +188,7 @@ function useLiveQuery(client, tableName, queryOrOptions) {
         : typeof queryOrOptions === 'function'
             ? 'custom'
             : 'all';
-    const cacheKey = `${tableName}:${queryKey}`;
+    const cacheKey = getScopedCacheKey(client, `${tableName}:${queryKey}`);
     // Read-through cache: return instant cached rows on mount (0ms latency, zero flicker)
     const [data, setData] = (0, react_1.useState)(() => queryCache.get(cacheKey) || []);
     const [loading, setLoading] = (0, react_1.useState)(() => !queryCache.has(cacheKey));
@@ -123,28 +197,18 @@ function useLiveQuery(client, tableName, queryOrOptions) {
     const refetch = (0, react_1.useCallback)(async () => {
         if (!client || !client.db)
             return;
+        const versionAtStart = getTableVersion(client, tableName);
         try {
-            // De-duplicate simultaneous identical in-flight queries
-            let inFlight = inFlightQueries.get(cacheKey);
-            if (!inFlight) {
-                inFlight = (async () => {
-                    const param = queryParamRef.current;
-                    if (typeof param === 'function') {
-                        return (await param(client)) || [];
-                    }
-                    else if (typeof param === 'object' && param !== null) {
-                        return await client.findMany(tableName, param);
-                    }
-                    else {
-                        return await client.findMany(tableName);
-                    }
-                })();
-                inFlightQueries.set(cacheKey, inFlight);
-                inFlight.finally(() => {
-                    inFlightQueries.delete(cacheKey);
-                });
-            }
-            const res = (await inFlight) || [];
+            const res = await fetchDeduped(cacheKey + ':v' + versionAtStart, async () => {
+                const param = queryParamRef.current;
+                if (typeof param === 'function')
+                    return (await param(client)) || [];
+                if (typeof param === 'object' && param !== null)
+                    return await client.findMany(tableName, param);
+                return await client.findMany(tableName);
+            });
+            if (versionAtStart !== getTableVersion(client, tableName))
+                return;
             queryCache.set(cacheKey, res);
             setData((prev) => (areRowArraysEqual(prev, res) ? prev : res));
         }
@@ -168,6 +232,7 @@ function useLiveQuery(client, tableName, queryOrOptions) {
             return;
         refetch();
         const unsubscribe = client.events.on(tableName, () => {
+            advanceTableVersion(client, tableName);
             scheduleRefetch();
         });
         return () => {
@@ -269,10 +334,11 @@ function useLiveQueries(client, queries) {
         return JSON.stringify(queries, (_, val) => (typeof val === 'function' ? 'fn' : val));
     }, [queries]);
     const items = (0, react_1.useMemo)(() => normalizeMultiQueries(queries), [signature]);
+    const clientScope = getClientScope(client);
     const [data, setData] = (0, react_1.useState)(() => {
         const initial = {};
         for (const item of items) {
-            const cached = queryCache.get(item.cacheKey);
+            const cached = queryCache.get(clientScope + ':' + item.cacheKey);
             initial[item.key] = cached ? cached : [];
         }
         return initial;
@@ -281,7 +347,7 @@ function useLiveQueries(client, queries) {
         if (items.length === 0)
             return false;
         for (const item of items) {
-            if (!queryCache.has(item.cacheKey))
+            if (!queryCache.has(clientScope + ':' + item.cacheKey))
                 return true;
         }
         return false;
@@ -291,27 +357,19 @@ function useLiveQueries(client, queries) {
             return;
         try {
             const results = await Promise.all(items.map(async (item) => {
-                let inFlight = inFlightQueries.get(item.cacheKey);
-                if (!inFlight) {
-                    inFlight = (async () => {
-                        if (item.fn) {
+                try {
+                    const versionAtStart = getTableVersion(client, item.table);
+                    const scopedCacheKey = clientScope + ':' + item.cacheKey;
+                    const rows = await fetchDeduped(scopedCacheKey + ':v' + versionAtStart, async () => {
+                        if (item.fn)
                             return (await item.fn(client)) || [];
-                        }
-                        else if (item.options) {
+                        if (item.options)
                             return await client.findMany(item.table, item.options);
-                        }
-                        else {
-                            return await client.findMany(item.table);
-                        }
-                    })();
-                    inFlightQueries.set(item.cacheKey, inFlight);
-                    inFlight.finally(() => {
-                        inFlightQueries.delete(item.cacheKey);
+                        return await client.findMany(item.table);
                     });
-                }
-                try {
-                    const rows = (await inFlight) || [];
-                    queryCache.set(item.cacheKey, rows);
+                    if (versionAtStart !== getTableVersion(client, item.table))
+                        return null;
+                    queryCache.set(scopedCacheKey, rows);
                     return { key: item.key, rows };
                 }
                 catch (err) {
@@ -327,6 +385,8 @@ function useLiveQueries(client, queries) {
                 let changed = false;
                 const next = { ...prev };
                 for (const res of results) {
+                    if (!res)
+                        continue;
                     if (!areRowArraysEqual(prev[res.key], res.rows)) {
                         next[res.key] = res.rows;
                         changed = true;
@@ -346,6 +406,7 @@ function useLiveQueries(client, queries) {
         refetch();
         const tables = Array.from(new Set(items.map((i) => i.table).filter(Boolean)));
         const unsubs = tables.map((tbl) => client.events.on(tbl, () => {
+            advanceTableVersion(client, tbl);
             scheduleRefetch();
         }));
         return () => {
@@ -361,7 +422,7 @@ function useLiveQueries(client, queries) {
  * Automatically re-renders only when this specific row or table changes.
  */
 function useLiveRow(client, tableName, rowId, options) {
-    const cacheKey = `${tableName}:row:${rowId || 'null'}:${Boolean(options?.includeDeleted)}`;
+    const cacheKey = getScopedCacheKey(client, `${tableName}:row:${rowId || 'null'}:${Boolean(options?.includeDeleted)}`);
     const [data, setData] = (0, react_1.useState)(() => {
         if (!rowId)
             return null;
@@ -376,13 +437,13 @@ function useLiveRow(client, tableName, rowId, options) {
             return;
         }
         try {
-            let inFlight = inFlightQueries.get(cacheKey);
-            if (!inFlight) {
-                inFlight = client.findById(tableName, rowId, options).then((r) => (r ? [r] : []));
-                inFlightQueries.set(cacheKey, inFlight);
-                inFlight.finally(() => inFlightQueries.delete(cacheKey));
-            }
-            const res = await inFlight;
+            const versionAtStart = getTableVersion(client, tableName);
+            const res = await fetchDeduped(cacheKey + ':v' + versionAtStart, async () => {
+                const r = await client.findById(tableName, rowId, options);
+                return r ? [r] : [];
+            });
+            if (versionAtStart !== getTableVersion(client, tableName))
+                return;
             const row = res.length > 0 ? res[0] : null;
             if (row) {
                 queryCache.set(cacheKey, [row]);
@@ -411,6 +472,7 @@ function useLiveRow(client, tableName, rowId, options) {
             return;
         refetch();
         const unsubscribe = client.events.on(tableName, (event) => {
+            advanceTableVersion(client, tableName);
             // Precise row-level invalidation: only refetch if event affects this rowId or is a bulk event
             if (!event || !event.rowId || event.rowId === rowId || event.rowId === 'batch') {
                 scheduleRefetch();
@@ -442,6 +504,7 @@ function useLiveInfiniteQuery(client, tableName, options = {}) {
             return;
         if (isNextPage)
             setIsFetchingNextPage(true);
+        const versionAtStart = getTableVersion(client, tableName);
         try {
             const currentOpts = optionsRef.current;
             const fetchLimit = pages * pageSize + 1; // +1 to check for hasNextPage
@@ -450,6 +513,8 @@ function useLiveInfiniteQuery(client, tableName, options = {}) {
                 limit: fetchLimit,
                 offset: currentOpts.offset || 0,
             });
+            if (versionAtStart !== getTableVersion(client, tableName))
+                return;
             if (rows.length > pages * pageSize) {
                 setHasNextPage(true);
                 setData(rows.slice(0, pages * pageSize));
@@ -491,6 +556,7 @@ function useLiveInfiniteQuery(client, tableName, options = {}) {
             return;
         loadData(1, false);
         const unsubscribe = client.events.on(tableName, () => {
+            advanceTableVersion(client, tableName);
             scheduleRefetch();
         });
         return () => {

package/dist/react/status.d.ts

@@ -13,6 +13,11 @@ export interface UseSyncStatusResult {
 /**
  * Consolidated hook that tracks real-time sync connectivity, sync worker activity
  * (pushing/pulling/syncing), and pending items in the local SQLite outbox queue.
+ *
+ * Performance notes:
+ * - sync:status events update isOnline/isPushing/isPulling/pendingCount in-place (no DB query).
+ * - The 50-record outbox fetch (pendingRecords) only runs on mount and on explicit refresh().
+ * - sync:push / sync:pull only trigger a lightweight pendingCount update via sync:status.
  */
 export declare function useSyncStatus(client: LocalFirstClient | null | undefined): UseSyncStatusResult;
 /**

package/dist/react/status.js

@@ -7,6 +7,11 @@ const runner_js_1 = require("./runner.js");
 /**
  * Consolidated hook that tracks real-time sync connectivity, sync worker activity
  * (pushing/pulling/syncing), and pending items in the local SQLite outbox queue.
+ *
+ * Performance notes:
+ * - sync:status events update isOnline/isPushing/isPulling/pendingCount in-place (no DB query).
+ * - The 50-record outbox fetch (pendingRecords) only runs on mount and on explicit refresh().
+ * - sync:push / sync:pull only trigger a lightweight pendingCount update via sync:status.
  */
 function useSyncStatus(client) {
     const [isOnline, setIsOnline] = (0, react_1.useState)(true);
@@ -44,33 +49,36 @@ function useSyncStatus(client) {
             // Ignored if client is stopping or tables initializing
         }
     }, [client]);
-    const scheduleRefresh = (0, runner_js_1.useCoalescedRunner)(refresh);
     (0, react_1.useEffect)(() => {
         if (!client || !client.db)
             return;
+        // Initial full fetch on mount
         refresh();
+        // sync:status fires after every push/pull cycle — update scalar fields directly,
+        // no DB round-trip needed. pendingCount comes from the event payload.
         const unsubStatus = client.events.on('sync:status', (e) => {
             setIsOnline(e.isOnline);
             setIsPushing(e.isPushing);
             setIsPulling(e.isPulling);
             setPendingCount(e.pendingCount);
         });
-        const unsubOutbox = client.events.on('sync_outbox', () => {
-            scheduleRefresh();
-        });
-        const unsubPush = client.events.on('sync:push', () => {
-            scheduleRefresh();
-        });
-        const unsubPull = client.events.on('sync:pull', () => {
-            scheduleRefresh();
+        // Only refresh lastSyncedAt after a completed pull (lightweight meta query only)
+        const unsubPull = client.events.on('sync:pull', async (e) => {
+            if (e?.success) {
+                try {
+                    const ts = await client.getLastSyncedAt().catch(() => null);
+                    if (ts !== null && ts !== undefined) {
+                        setLastSyncedAt(ts > 0 ? ts : null);
+                    }
+                }
+                catch { /* ignored */ }
+            }
         });
         return () => {
             unsubStatus();
-            unsubOutbox();
-            unsubPush();
             unsubPull();
         };
-    }, [client, refresh, scheduleRefresh]);
+    }, [client, refresh]);
     return {
         isOnline,
         isPushing,

package/dist/utils/uuid.d.ts

@@ -1,7 +1,7 @@
 import { v4 as uuidv4 } from 'uuid';
 /**
  * Generates an RFC4122 v4 compliant UUID.
- * Uses native crypto.randomUUID() when supported, with uuid.v4 fallback.
+ * Uses native crypto.randomUUID() when available (detected once at import), with uuid.v4 fallback.
  */
 export declare function generateUUID(): string;
 export { uuidv4 };

package/dist/utils/uuid.js

@@ -4,24 +4,15 @@ exports.uuidv4 = void 0;
 exports.generateUUID = generateUUID;
 const uuid_1 = require("uuid");
 Object.defineProperty(exports, "uuidv4", { enumerable: true, get: function () { return uuid_1.v4; } });
+// Detect once at module load — avoids 3 typeof checks per UUID call
+const nativeRandomUUID = typeof globalThis !== 'undefined' &&
+    typeof globalThis.crypto?.randomUUID === 'function'
+    ? () => globalThis.crypto.randomUUID()
+    : null;
 /**
  * Generates an RFC4122 v4 compliant UUID.
- * Uses native crypto.randomUUID() when supported, with uuid.v4 fallback.
+ * Uses native crypto.randomUUID() when available (detected once at import), with uuid.v4 fallback.
  */
 function generateUUID() {
-    try {
-        if (typeof globalThis !== 'undefined' &&
-            globalThis.crypto &&
-            typeof globalThis.crypto.randomUUID === 'function') {
-            return globalThis.crypto.randomUUID();
-        }
-        return (0, uuid_1.v4)();
-    }
-    catch {
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-            const r = (Math.random() * 16) | 0;
-            const v = c === 'x' ? r : (r & 0x3) | 0x8;
-            return v.toString(16);
-        });
-    }
+    return nativeRandomUUID ? nativeRandomUUID() : (0, uuid_1.v4)();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-lite",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Never let a lost connection break a promise. Local-first sync that faithfully keeps data safe until you're back online.",
   "license": "MIT",
   "main": "dist/index.js",
@@ -129,8 +129,9 @@
     }
   },
   "devDependencies": {
-    "@supabase/supabase-js": "^2.118.0",
-    "@types/react": "^19.3.0",
+    "@supabase/supabase-js": "^2.118.0",
+    "@types/node": "^26.6.5",
+    "@types/react": "^19.3.0",
     "@types/uuid": "^11.0.0",
     "expo-sqlite": "^58.0.13",
     "react": "^19.3.1",
@@ -140,4 +141,4 @@
   "dependencies": {
     "uuid": "^14.0.3"
   }
-}
+}