local-lite 0.0.1 → 0.0.3

package/dist/react/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLiveQuery = useLiveQuery;
-exports.useOutboxStatus = useOutboxStatus;
+exports.useSyncStatus = useSyncStatus;
+exports.useSyncMetrics = useSyncMetrics;
 const react_1 = require("react");
 /**
  * Hook to execute a live reactive table query that automatically re-runs
@@ -11,9 +12,9 @@ const react_1 = require("react");
  * 1. Zero-SQL (all rows):
  *    const { data: todos } = useLiveQuery<Todo>(client, 'todos');
  *
- * 2. Declarative options (filtering & sorting without SQL):
+ * 2. Declarative options (filtering with rich operators & sorting without SQL):
  *    const { data: active } = useLiveQuery<Todo>(client, 'todos', {
- *      where: { completed: 0 },
+ *      where: { completed: 0, priority: { $gte: 2 } },
  *      orderBy: 'created_at',
  *      order: 'desc'
  *    });
@@ -71,33 +72,114 @@ function useLiveQuery(client, tableName, queryOrOptions) {
     return { data, refetch, loading };
 }
 /**
- * Hook that tracks the status and pending items in sync_outbox in real time.
+ * Consolidated hook that tracks real-time sync connectivity, sync worker activity
+ * (pushing/pulling/syncing), and pending items in the local SQLite outbox queue.
  */
-function useOutboxStatus(client) {
+function useSyncStatus(client) {
+    const [isOnline, setIsOnline] = (0, react_1.useState)(true);
+    const [isPushing, setIsPushing] = (0, react_1.useState)(false);
+    const [isPulling, setIsPulling] = (0, react_1.useState)(false);
     const [pendingCount, setPendingCount] = (0, react_1.useState)(0);
     const [pendingRecords, setPendingRecords] = (0, react_1.useState)([]);
+    const [lastSyncedAt, setLastSyncedAt] = (0, react_1.useState)(null);
     const refresh = (0, react_1.useCallback)(async () => {
         if (!client || !client.db)
             return;
         try {
-            const records = await client.db.execute('SELECT * FROM sync_outbox ORDER BY timestamp DESC');
-            setPendingRecords(records || []);
-            setPendingCount((records || []).length);
+            const [metrics, records, lastSynced] = await Promise.all([
+                client.getMetrics().catch(() => null),
+                client.getOutboxRecords().catch(() => []),
+                client.getLastSyncedAt().catch(() => null),
+            ]);
+            if (metrics) {
+                setIsOnline(metrics.isOnline);
+                setIsPushing(metrics.isPushing);
+                setIsPulling(metrics.isPulling);
+            }
+            if (records) {
+                setPendingRecords(records);
+                setPendingCount(records.filter((r) => r.status === 'PENDING').length);
+            }
+            if (lastSynced !== null && lastSynced !== undefined) {
+                setLastSyncedAt(lastSynced > 0 ? lastSynced : null);
+            }
         }
         catch {
-            // Ignored if table doesn't exist yet
+            // Ignored if client is stopping or tables initializing
         }
     }, [client]);
     (0, react_1.useEffect)(() => {
         if (!client || !client.db)
             return;
         refresh();
-        const unsubscribe = client.events.on('sync_outbox', () => {
+        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', () => {
+            refresh();
+        });
+        const unsubPush = client.events.on('sync:push', () => {
+            refresh();
+        });
+        const unsubPull = client.events.on('sync:pull', () => {
             refresh();
         });
         return () => {
-            unsubscribe();
+            unsubStatus();
+            unsubOutbox();
+            unsubPush();
+            unsubPull();
         };
     }, [client, refresh]);
-    return { pendingCount, pendingRecords, refresh };
+    return {
+        isOnline,
+        isPushing,
+        isPulling,
+        isSyncing: isPushing || isPulling,
+        pendingCount,
+        pendingRecords,
+        lastSyncedAt,
+        refresh,
+    };
+}
+/**
+ * Hook that provides real-time sync telemetry and engine performance metrics.
+ */
+function useSyncMetrics(client, pollIntervalMs = 3000) {
+    const [metrics, setMetrics] = (0, react_1.useState)(null);
+    const refresh = (0, react_1.useCallback)(async () => {
+        if (!client)
+            return;
+        try {
+            const data = await client.getMetrics();
+            setMetrics(data);
+        }
+        catch {
+            // Ignored
+        }
+    }, [client]);
+    (0, react_1.useEffect)(() => {
+        if (!client)
+            return;
+        refresh();
+        // Listen to sync events for immediate refresh
+        const unsubs = [
+            client.events.on('sync:push', () => refresh()),
+            client.events.on('sync:pull', () => refresh()),
+            client.events.on('sync:status', () => refresh()),
+        ];
+        let timer;
+        if (pollIntervalMs > 0) {
+            timer = setInterval(refresh, pollIntervalMs);
+        }
+        return () => {
+            unsubs.forEach((u) => u());
+            if (timer)
+                clearInterval(timer);
+        };
+    }, [client, refresh, pollIntervalMs]);
+    return { metrics, refresh };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "local-lite",
-  "version": "0.0.1",
-  "description": "Vendor-agnostic local-first sync engine with outbox pattern, Supabase, Convex, and Firebase support",
+  "version": "0.0.3",
+  "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",
   "types": "dist/index.d.ts",
@@ -130,4 +130,4 @@
   "dependencies": {
     "uuid": "^14.0.3"
   }
-}
+}