local-lite 0.0.5 → 0.0.6

package/dist/core/sync-worker.js

@@ -611,9 +611,12 @@ class SyncWorker {
             const isLastChunk = i + DELTA_CHUNK_SIZE >= totalChanges;
             const queuedEvents = [];
             await this.db.transaction(async (tx) => {
+                // Pre-fetch active pending outbox records in 1 query for this chunk to eliminate N+1 bridge roundtrips
+                const pendingOutboxMap = await outbox_store_js_1.OutboxStore.getActivePendingMap(tx);
                 for (const change of chunk) {
-                    // 1. Check for pending local mutations for this (table_name, row_id)
-                    const localPendingRecord = await outbox_store_js_1.OutboxStore.findPendingByRow(tx, change.tableName, change.rowId);
+                    const outboxKey = `${change.tableName}:${change.rowId}`;
+                    // 1. Check in-memory map for pending local mutations for this (table_name, row_id)
+                    const localPendingRecord = pendingOutboxMap.get(outboxKey);
                     // 2. Conflict resolution if there is a pending local change
                     if (localPendingRecord) {
                         // Only load the current local row when a resolver actually needs it.
@@ -640,11 +643,13 @@ class SyncWorker {
                         if (resolution === 'apply-remote') {
                             // Remote change wins: remove the superseded local pending outbox mutation
                             await outbox_store_js_1.OutboxStore.deleteRecord(tx, localPendingRecord.id);
+                            pendingOutboxMap.delete(outboxKey);
                         }
                         else if (typeof resolution === 'object' && resolution.mergePayload) {
                             // Merge scenario
                             change.payload = resolution.mergePayload;
                             await outbox_store_js_1.OutboxStore.updatePayload(tx, localPendingRecord.id, resolution.mergePayload);
+                            localPendingRecord.payload = resolution.mergePayload;
                         }
                     }
                     // 3. Apply remote change to local database

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,50 @@ 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();
+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.
  */
@@ -124,27 +165,14 @@ function useLiveQuery(client, tableName, queryOrOptions) {
         if (!client || !client.db)
             return;
         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, 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);
+            });
             queryCache.set(cacheKey, res);
             setData((prev) => (areRowArraysEqual(prev, res) ? prev : res));
         }
@@ -291,26 +319,14 @@ 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 rows = await fetchDeduped(item.cacheKey, 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);
                     return { key: item.key, rows };
                 }
@@ -376,13 +392,10 @@ 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 res = await fetchDeduped(cacheKey, async () => {
+                const r = await client.findById(tableName, rowId, options);
+                return r ? [r] : [];
+            });
             const row = res.length > 0 ? res[0] : null;
             if (row) {
                 queryCache.set(cacheKey, [row]);

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.6",
   "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",