supastash 0.1.43 → 0.1.45

package/README.md

@@ -8,7 +8,10 @@
 
 ---
 
-## 📚 [Full Docs](https://0xzekea.github.io/supastash/)
+## 📚 Documentation
+
+→ [Full Docs](https://0xzekea.github.io/supastash/)  
+→ [Getting Started Guide](./docs/getting-started.md)
 
 ---
 
@@ -21,7 +24,7 @@
 
   - `expo-sqlite`
   - `react-native-nitro-sqlite`
-  - `react-native-sqlite-storage`
+  - `react-native-sqlite-storage` (beta)
 
 - 🧠 Built-in:
 
@@ -59,7 +62,7 @@ npm install expo-sqlite
 # Bare RN with better speed
 npm install react-native-nitro-sqlite
 
-# Classic RN SQLite
+# Classic RN SQLite (beta)
 npm install react-native-sqlite-storage
 ```
 
@@ -134,12 +137,13 @@ Use this in a hook like `useHydrateStores()` to stay in sync without polling.
 
 ---
 
-### 🔁 `useSupastashData` (Global, Realtime)
+### 🔁 `useSupastashData` (with Realtime)
 
 ```ts
 const { data, groupedBy } = useSupastashData("orders", {
   filter: { column: "user_id", operator: "eq", value: userId },
   extraMapKeys: ["status"],
+  realtime: true, // Default: true
 });
 ```
 
@@ -169,7 +173,7 @@ useSupastashFilters({
 - Your Supabase tables must have:
 
   - A primary key `id` (string or UUID)
-  - `timestamptz` columns for `created_at`, `updated_at`, and optionally `deleted_at`
+  - `timestamptz` columns for `created_at`, `updated_at`, and `deleted_at`
 
 - Run this SQL in Supabase to allow schema reflection:
 
@@ -204,7 +208,7 @@ const { data: orders } = useSupatashData("orders", {
 
 - Tracks rows using `updated_at`, `deleted_at`, and `created_at`
 - Batches changes in background and retries failed ones
-- Keeps **local database as the source of truth**
+- Local cache backed by Supabase
 - Runs pull/push jobs efficiently using staged task pipelines
 
 ---
@@ -223,18 +227,6 @@ await supastash
 
 ---
 
-## 🗂 Recommended Project Structure
-
-```
-src/
-  ├─ core/         # Supastash config, Supabase client
-  ├─ hooks/        # useSupatashData, useSupastashFilters etc.
-  ├─ types/        # Zod schemas, DB types
-  ├─ utils/        # Local helpers
-```
-
----
-
 ## 🔧 API Docs
 
 - [`configureSupastash()`](https://0xzekea.github.io/supastash/docs/configuration)

package/dist/hooks/supastashData/fetchCalls.d.ts

@@ -4,5 +4,6 @@ export declare function fetchCalls<R = any>(table: string, options: RealtimeOpti
     trigger: () => void;
     cancel: () => void;
     initialFetchAndSync: () => Promise<void>;
+    isFetching: boolean;
 };
 //# sourceMappingURL=fetchCalls.d.ts.map

package/dist/hooks/supastashData/fetchCalls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetchCalls.d.ts","sourceRoot":"","sources":["../../../src/hooks/supastashData/fetchCalls.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,eAAe,EAChB,MAAM,gCAAgC,CAAC;AAKxC,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAChC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,EAC3B,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC;;;;;EAuGtC"}
+{"version":3,"file":"fetchCalls.d.ts","sourceRoot":"","sources":["../../../src/hooks/supastashData/fetchCalls.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,eAAe,EAChB,MAAM,gCAAgC,CAAC;AAKxC,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAChC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,EAC3B,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC;;;;;;EA4GtC"}

package/dist/hooks/supastashData/fetchCalls.js

@@ -1,4 +1,4 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useRef, useState } from "react";
 import { syncCalls } from "../../store/syncCalls";
 import { tableFilters, tableFiltersUsed } from "../../store/tableFilters";
 import { fetchLocalData } from "../../utils/fetchData/fetchLocalData";
@@ -7,6 +7,7 @@ import { logError } from "../../utils/logs";
 export function fetchCalls(table, options, initialized) {
     const { shouldFetch = true, limit, filter, onPushToRemote, onInsertAndUpdate, useFilterWhileSyncing = true, extraMapKeys, daylength, onlyUseFilterForRealtime, orderBy, orderDesc, sqlFilter, } = options;
     const cancelled = useRef(false);
+    const [isFetching, setIsFetching] = useState(false);
     useEffect(() => {
         if (filter && useFilterWhileSyncing && !tableFiltersUsed.has(table)) {
             tableFilters.set(table, [filter]);
@@ -66,17 +67,22 @@ export function fetchCalls(table, options, initialized) {
             filters = filter ? [filter] : undefined;
         }
         try {
+            setIsFetching(true);
             await initialFetch(table, filters, onInsertAndUpdate, onPushToRemote);
             await fetch();
         }
         catch (error) {
             logError(`[Supastash] Error on initial fetch for ${table}`, error);
         }
+        finally {
+            setIsFetching(false);
+        }
     };
     return {
         triggerRefresh,
         trigger,
         cancel,
         initialFetchAndSync,
+        isFetching,
     };
 }

package/dist/hooks/supastashData/index.d.ts

@@ -59,7 +59,8 @@ import { RealtimeOptions, SupastashDataResult } from "../../types/realtimeData.t
  *   dataMap: Map of records by ID,
  *   groupedBy: Optional maps grouped by field,
  *   trigger: Manually trigger sync,
- *   cancel: Cancel pending fetch or sync
+ *   cancel: Cancel pending fetch or
+ *   isFetching: Whether the data is being fetched
  * }
  */
 export declare function useSupastashData<R = any>(table: string, options?: RealtimeOptions): SupastashDataResult<R>;

package/dist/hooks/supastashData/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/supastashData/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EACf,mBAAmB,EACpB,MAAM,gCAAgC,CAAC;AAWxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,GAAG,EACtC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAAoB,GAC5B,mBAAmB,CAAC,CAAC,CAAC,CA8FxB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/supastashData/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EACf,mBAAmB,EACpB,MAAM,gCAAgC,CAAC;AAWxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,GAAG,EACtC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAAoB,GAC5B,mBAAmB,CAAC,CAAC,CAAC,CA4FxB"}

package/dist/hooks/supastashData/index.js

@@ -69,7 +69,8 @@ const tableSubscriptions = new Map();
  *   dataMap: Map of records by ID,
  *   groupedBy: Optional maps grouped by field,
  *   trigger: Manually trigger sync,
- *   cancel: Cancel pending fetch or sync
+ *   cancel: Cancel pending fetch or
+ *   isFetching: Whether the data is being fetched
  * }
  */
 export function useSupastashData(table, options = {}) {
@@ -78,7 +79,7 @@ export function useSupastashData(table, options = {}) {
     const unsub = useRef(null);
     const { dataMap, data, groupedBy, } = useDataState(table);
     const queueHandler = useEventQueues(table, options, flushIntervalMs);
-    const { triggerRefresh, trigger, cancel, initialFetchAndSync } = fetchCalls(table, options, hasTriggeredRef);
+    const { triggerRefresh, trigger, cancel, initialFetchAndSync, isFetching } = fetchCalls(table, options, hasTriggeredRef);
     const subKey = useMemo(() => `${table}:${buildFilterString(filter)}`, [table, filter]);
     const isAnyNullish = useMemo(() => {
         if (!options.sqlFilter)
@@ -124,5 +125,6 @@ export function useSupastashData(table, options = {}) {
         trigger,
         cancel,
         groupedBy,
-    }), [data]);
+        isFetching,
+    }), [data, isFetching]);
 }

package/dist/hooks/syncEngine/pullFromRemote/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/syncEngine/pullFromRemote/index.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,wBAAsB,cAAc,kBA8BnC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/syncEngine/pullFromRemote/index.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,wBAAsB,cAAc,kBAoEnC"}

package/dist/hooks/syncEngine/pullFromRemote/index.js

@@ -5,10 +5,13 @@ import log from "../../../utils/logs";
 import { getAllTables } from "../../../utils/sync/getAllTables";
 import { runLimitedConcurrency } from "../../../utils/sync/pullFromRemote/runLimitedConcurrency";
 import { updateLocalDb } from "../../../utils/sync/pullFromRemote/updateLocalDb";
+import { SyncInfoUpdater } from "../../../utils/sync/queryStatus";
 /**
  * Pulls the data from the remote database to the local database
  */
 export async function pullFromRemote() {
+    let numberOfTables = 0;
+    let tablesCompleted = 0;
     try {
         const tables = await getAllTables();
         if (!tables) {
@@ -17,19 +20,54 @@ export async function pullFromRemote() {
         }
         const excludeTables = getSupastashConfig()?.excludeTables?.pull || [];
         const tablesToPull = tables.filter((table) => !excludeTables?.includes(table));
+        numberOfTables = tablesToPull.length;
+        SyncInfoUpdater.setInProgress({
+            action: "start",
+            type: "pull",
+        });
+        SyncInfoUpdater.setNumberOfTables({
+            amount: numberOfTables,
+            type: "pull",
+        });
         const toPull = tablesToPull.map((table) => async () => {
             try {
+                SyncInfoUpdater.markLogStart({
+                    type: "pull",
+                    table,
+                });
                 const filter = tableFilters.get(table);
                 const onReceiveRecord = syncCalls.get(table)?.pull;
                 await updateLocalDb(table, filter, onReceiveRecord);
+                SyncInfoUpdater.markLogSuccess({
+                    type: "pull",
+                    table,
+                });
             }
             catch (e) {
+                SyncInfoUpdater.markLogError({
+                    type: "pull",
+                    table,
+                    lastError: e,
+                    errorCount: 1,
+                });
                 log(`[Supastash] pull table failed: ${table} — ${e?.code ?? e?.name ?? e}`);
             }
+            finally {
+                tablesCompleted++;
+                SyncInfoUpdater.setTablesCompleted({
+                    amount: tablesCompleted,
+                    type: "pull",
+                });
+            }
         });
         await runLimitedConcurrency(toPull, 3);
     }
     catch (error) {
         log(`[Supastash] Error pulling from remote: ${error}`);
     }
+    finally {
+        SyncInfoUpdater.reset({
+            type: "pull",
+        });
+    }
 }

package/dist/hooks/syncEngine/pushLocal/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/syncEngine/pushLocal/index.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,wBAAsB,aAAa,kBA4DlC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/syncEngine/pushLocal/index.ts"],"names":[],"mappings":"AAcA;;GAEG;AACH,wBAAsB,aAAa,kBAiGlC"}

package/dist/hooks/syncEngine/pushLocal/index.js

@@ -5,6 +5,7 @@ import log from "../../../utils/logs";
 import { getAllTables } from "../../../utils/sync/getAllTables";
 import { runLimitedConcurrency } from "../../../utils/sync/pullFromRemote/runLimitedConcurrency";
 import { pushLocalDataToRemote } from "../../../utils/sync/pushLocal/sendUnsyncedToSupabase";
+import { SyncInfoUpdater } from "../../../utils/sync/queryStatus";
 let emptyPassCount = 0;
 let lastEmptyPassAt = 0;
 const tablePushLock = new Map();
@@ -12,6 +13,8 @@ const tablePushLock = new Map();
  * Pushes the local data to the remote database
  */
 export async function pushLocalData() {
+    let tablesCompleted = 0;
+    let numberOfTables = 0;
     try {
         const tables = await getAllTables();
         if (!tables) {
@@ -22,8 +25,21 @@ export async function pushLocalData() {
             return;
         const excludeTables = getSupastashConfig()?.excludeTables?.push || [];
         const tablesToPush = tables.filter((table) => !excludeTables?.includes(table));
+        numberOfTables = tablesToPush.length;
+        SyncInfoUpdater.setInProgress({
+            action: "start",
+            type: "push",
+        });
+        SyncInfoUpdater.setNumberOfTables({
+            amount: numberOfTables,
+            type: "push",
+        });
         const results = [];
         const jobs = tablesToPush.map((table) => async () => {
+            SyncInfoUpdater.setCurrentTable({
+                table,
+                type: "push",
+            });
             if (tablePushLock.get(table)) {
                 results.push({ table, hadWork: false });
                 return;
@@ -31,15 +47,34 @@ export async function pushLocalData() {
             tablePushLock.set(table, true);
             try {
                 const onPush = syncCalls.get(table)?.push;
+                SyncInfoUpdater.markLogStart({
+                    type: "push",
+                    table,
+                });
                 const hadWork = await pushLocalDataToRemote(table, onPush);
                 results.push({ table, hadWork: !!hadWork });
+                SyncInfoUpdater.markLogSuccess({
+                    type: "push",
+                    table,
+                });
             }
             catch (e) {
                 const msg = e?.code ?? e?.name ?? String(e);
+                SyncInfoUpdater.markLogError({
+                    type: "push",
+                    table,
+                    lastError: e,
+                    errorCount: 1,
+                });
                 results.push({ table, hadWork: false, error: msg });
                 log(`[Supastash] Push table failed: ${table} — ${msg}`);
             }
             finally {
+                tablesCompleted++;
+                SyncInfoUpdater.setTablesCompleted({
+                    amount: tablesCompleted,
+                    type: "push",
+                });
                 tablePushLock.set(table, false);
             }
         });
@@ -63,4 +98,7 @@ export async function pushLocalData() {
     catch (error) {
         log(`[Supastash] Error pushing local data to remote database: ${error}`);
     }
+    finally {
+        SyncInfoUpdater.reset({ type: "push" });
+    }
 }

package/dist/hooks/syncStatus/index.d.ts

@@ -1,18 +1,42 @@
+import { SyncInfo } from "../../types/syncEngine.types";
 /**
- * React hook that returns the current global sync status across all tracked Supastash tables.
+ * React hook that provides a **live snapshot of Supastash sync state** across all tracked tables.
  *
- * - Listens for the "updateSyncStatus" event from the event bus.
- * - Recomputes sync status whenever the event is emitted (e.g. after CRUD operations).
- * - Status can be:
- *   - "pending" → at least one table has pending sync rows
- *   - "error" → at least one table has failed sync rows
- *   - "synced" → all tracked tables are fully synced
+ * It listens for two global events:
+ * - `"updateSyncStatus"` → high-level sync state (`pending`, `error`, or `synced`)
+ * - `"updateSyncInfo"` → detailed sync progress (tables, logs, counts, etc.)
  *
- * @returns {"pending" | "error" | "synced"} The current sync status
+ * Debouncing is used internally to prevent rapid UI re-renders during
+ * frequent background sync updates.
  *
- * @example
- * const syncStatus = useSupastashSyncStatus();
- * if (syncStatus === "pending") showSyncingIndicator();
+ * ---
+ * **Returned Values**
+ * - `syncStatus` → `"pending" | "error" | "synced"`
+ * - `syncInfo` → `SyncInfo` object containing `pull` and `push` progress
+ *
+ * ---
+ * **Example**
+ * ```ts
+ * const { syncStatus, syncInfo } = useSupastashSyncStatus(50); // 50ms debounce delay
+ *
+ * if (syncInfo.pull.inProgress) showPullingIndicator();
+ * if (syncInfo.push.inProgress) showPushingIndicator();
+ *
+ * if (syncStatus === "pending") showSyncingBadge();
+ * ```
+ *
+ * ---
+ * **SyncInfo Structure**
+ * - pull / push: `SyncInfoItem`
+ *   - inProgress: boolean
+ *   - numberOfTables: number
+ *   - tablesCompleted: number
+ *   - currentTable: { name, unsyncedDataCount, unsyncedDeletedCount }
+ *   - lastSyncedAt: number
+ *   - lastSyncLog: SyncLogEntry[]
  */
-export declare function useSupastashSyncStatus(): "error" | "pending" | "synced";
+export declare function useSupastashSyncStatus(debounceDelay?: number): {
+    syncStatus: "error" | "pending" | "synced";
+    syncInfo: SyncInfo;
+};
 //# sourceMappingURL=index.d.ts.map

package/dist/hooks/syncStatus/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/syncStatus/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,mCAiBrC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/syncStatus/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAOxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,sBAAsB,CAAC,aAAa,SAAK;;;EAqCxD"}

package/dist/hooks/syncStatus/index.js

@@ -1,34 +1,75 @@
 import { useEffect, useState } from "react";
 import { supastashEventBus } from "../../utils/events/eventBus";
-import { getSupastashStatus } from "../../utils/sync/queryStatus";
+import { getSupastashStatus, SyncInfoUpdater, } from "../../utils/sync/queryStatus";
 /**
- * React hook that returns the current global sync status across all tracked Supastash tables.
+ * React hook that provides a **live snapshot of Supastash sync state** across all tracked tables.
  *
- * - Listens for the "updateSyncStatus" event from the event bus.
- * - Recomputes sync status whenever the event is emitted (e.g. after CRUD operations).
- * - Status can be:
- *   - "pending" → at least one table has pending sync rows
- *   - "error" → at least one table has failed sync rows
- *   - "synced" → all tracked tables are fully synced
+ * It listens for two global events:
+ * - `"updateSyncStatus"` → high-level sync state (`pending`, `error`, or `synced`)
+ * - `"updateSyncInfo"` → detailed sync progress (tables, logs, counts, etc.)
  *
- * @returns {"pending" | "error" | "synced"} The current sync status
+ * Debouncing is used internally to prevent rapid UI re-renders during
+ * frequent background sync updates.
  *
- * @example
- * const syncStatus = useSupastashSyncStatus();
- * if (syncStatus === "pending") showSyncingIndicator();
+ * ---
+ * **Returned Values**
+ * - `syncStatus` → `"pending" | "error" | "synced"`
+ * - `syncInfo` → `SyncInfo` object containing `pull` and `push` progress
+ *
+ * ---
+ * **Example**
+ * ```ts
+ * const { syncStatus, syncInfo } = useSupastashSyncStatus(50); // 50ms debounce delay
+ *
+ * if (syncInfo.pull.inProgress) showPullingIndicator();
+ * if (syncInfo.push.inProgress) showPushingIndicator();
+ *
+ * if (syncStatus === "pending") showSyncingBadge();
+ * ```
+ *
+ * ---
+ * **SyncInfo Structure**
+ * - pull / push: `SyncInfoItem`
+ *   - inProgress: boolean
+ *   - numberOfTables: number
+ *   - tablesCompleted: number
+ *   - currentTable: { name, unsyncedDataCount, unsyncedDeletedCount }
+ *   - lastSyncedAt: number
+ *   - lastSyncLog: SyncLogEntry[]
  */
-export function useSupastashSyncStatus() {
+export function useSupastashSyncStatus(debounceDelay = 40) {
     const [syncStatus, setSyncStatus] = useState("synced");
+    const [syncInfo, setSyncInfo] = useState(() => SyncInfoUpdater.getSnapshot());
     useEffect(() => {
-        const refreshSyncStatus = () => {
-            const status = getSupastashStatus();
-            setSyncStatus(status);
+        const handleStatusUpdate = debounce(() => {
+            setSyncStatus(getSupastashStatus());
+        }, debounceDelay);
+        handleStatusUpdate();
+        supastashEventBus.on("updateSyncStatus", handleStatusUpdate);
+        return () => {
+            supastashEventBus.off("updateSyncStatus", handleStatusUpdate);
+            handleStatusUpdate.cancel();
         };
-        refreshSyncStatus();
-        supastashEventBus.on("updateSyncStatus", refreshSyncStatus);
+    }, []);
+    useEffect(() => {
+        const handleInfoUpdate = debounce((next) => {
+            setSyncInfo(next);
+        }, debounceDelay);
+        setSyncInfo(SyncInfoUpdater.getSnapshot());
+        supastashEventBus.on("updateSyncInfo", handleInfoUpdate);
         return () => {
-            supastashEventBus.off("updateSyncStatus", refreshSyncStatus);
+            supastashEventBus.off("updateSyncInfo", handleInfoUpdate);
+            handleInfoUpdate.cancel();
         };
     }, []);
-    return syncStatus;
+    return { syncStatus, syncInfo };
+}
+function debounce(fn, delay = 40) {
+    let timeout;
+    const debounced = (...args) => {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => fn(...args), delay);
+    };
+    debounced.cancel = () => clearTimeout(timeout);
+    return debounced;
 }

package/dist/store/syncStatus.d.ts

@@ -1,3 +1,4 @@
+import { SyncInfo, SyncLogEntry } from "../types/syncEngine.types";
 /**
  * A map tracking sync status for each row in each table.
  *
@@ -21,4 +22,6 @@
  * - Value = sync status of that row
  */
 export declare const syncStatusMap: Map<string, Map<string, "error" | "pending" | "success">>;
+export declare const syncInfo: SyncInfo;
+export declare const DEFAULT_SYNC_LOG_ENTRY: SyncLogEntry;
 //# sourceMappingURL=syncStatus.d.ts.map

package/dist/store/syncStatus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syncStatus.d.ts","sourceRoot":"","sources":["../../src/store/syncStatus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,aAAa,2DAGvB,CAAC"}
+{"version":3,"file":"syncStatus.d.ts","sourceRoot":"","sources":["../../src/store/syncStatus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,aAAa,2DAGvB,CAAC;AAEJ,eAAO,MAAM,QAAQ,EAAE,QAyBtB,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,YAapC,CAAC"}

package/dist/store/syncStatus.js

@@ -21,3 +21,43 @@
  * - Value = sync status of that row
  */
 export const syncStatusMap = new Map();
+export const syncInfo = {
+    pull: {
+        inProgress: false,
+        numberOfTables: 0,
+        tablesCompleted: 0,
+        currentTable: {
+            name: "",
+            unsyncedDataCount: 0,
+            unsyncedDeletedCount: 0,
+        },
+        lastSyncedAt: 0,
+        lastSyncLog: [],
+    },
+    push: {
+        inProgress: false,
+        numberOfTables: 0,
+        tablesCompleted: 0,
+        currentTable: {
+            name: "",
+            unsyncedDataCount: 0,
+            unsyncedDeletedCount: 0,
+        },
+        lastSyncedAt: 0,
+        lastSyncLog: [],
+    },
+};
+export const DEFAULT_SYNC_LOG_ENTRY = {
+    table: "",
+    filterKey: "",
+    filterJson: [],
+    action: "push",
+    success: true,
+    errorCount: 0,
+    unsyncedDataCount: 0,
+    unsyncedDeletedCount: 0,
+    rowsFailed: 0,
+    lastError: null,
+    startTime: 0,
+    endTime: 0,
+};

package/dist/types/realtimeData.types.d.ts

@@ -235,13 +235,43 @@ export interface RealtimeOptions<R = any> {
 }
 
 export type SupastashDataResult<R = any> = {
+  /**
+   * Array of records.
+   * @example
+   * data: [user1, user2],
+   */
   data: Array<R>;
+  /**
+   * Map of records by ID.
+   * @example
+   * dataMap: new Map([[1, user1], [2, user2]]),
+   */
   dataMap: Map<string, R>;
+  /**
+   * Trigger the fetch or sync.
+   */
   trigger: () => void;
+  /**
+   * Cancel the pending fetch or sync.
+   */
   cancel: () => void;
+  /**
+   * Optional maps grouped by field.
+   * @example
+   * groupedBy: {
+   *   userId: new Map([[1, [user1, user2]]]),
+   *   groupId: new Map([[1, [group1, group2]]]),
+   * }
+   */
   groupedBy?: {
     [K in keyof R]: Map<R[K], Array<R>>;
   };
+  /**
+   * Whether the data is being fetched.
+   * @example
+   * isFetching: true
+   */
+  isFetching: boolean;
 };
 
 export type SupastashDataHook<R = any> = (

package/dist/types/syncEngine.types.d.ts

@@ -1,3 +1,5 @@
+import { SupastashFilter } from "./realtimeData.types";
+
 export type SyncResult = {
   success: string[]; // IDs that were successfully upserted
   skipped: { id: string; reason: string }[]; // IDs that were skipped with reason
@@ -40,3 +42,80 @@ export type PublicScope =
   | "last_synced_at"
   | "last_created_at"
   | "last_deleted_at";
+
+export type CurrentTableInfo = {
+  /** Table currently being synced */
+  name: string;
+
+  /** Number of local records pending upload or download */
+  unsyncedDataCount: number;
+
+  /** Number of soft-deleted records pending sync */
+  unsyncedDeletedCount: number;
+};
+
+export type SyncLogEntry = {
+  /** Table this log entry belongs to */
+  table: string;
+
+  /** Optional filter key used for pull operations */
+  filterKey?: string;
+
+  /** JSON array of filters used for pull operations */
+  filterJson?: SupastashFilter[];
+
+  /** Sync direction for this log entry ("push" or "pull") */
+  action: "push" | "pull";
+
+  /** Whether the sync operation completed successfully */
+  success: boolean;
+
+  /** Number of errors encountered during the operation */
+  errorCount: number;
+
+  /** Last recorded error (if any) */
+  lastError: Error | null;
+
+  /** Number of unsynced data rows before this operation */
+  unsyncedDataCount: number;
+
+  /** Number of unsynced deleted rows before this operation */
+  unsyncedDeletedCount: number;
+
+  /** Timestamp (ms) when the operation started */
+  startTime: number;
+
+  /** Timestamp (ms) when the operation ended */
+  endTime: number;
+
+  /** Number of rows that failed to push (push only) */
+  rowsFailed: number;
+};
+
+export type SyncInfoItem = {
+  /** Whether a sync process is currently active */
+  inProgress: boolean;
+
+  /** Total number of tables scheduled for this sync cycle */
+  numberOfTables: number;
+
+  /** Number of tables successfully completed so far */
+  tablesCompleted: number;
+
+  /** Details of the table currently being processed */
+  currentTable: CurrentTableInfo;
+
+  /** Timestamp (ms) of the most recent completed sync */
+  lastSyncedAt: number;
+
+  /** Collection of detailed logs for recent table syncs */
+  lastSyncLog: SyncLogEntry[];
+};
+
+export type SyncInfo = {
+  /** Sync information for pull operations (server → local) */
+  pull: SyncInfoItem;
+
+  /** Sync information for push operations (local → server) */
+  push: SyncInfoItem;
+};

package/dist/utils/sync/pullFromRemote/pullData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pullData.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pullFromRemote/pullData.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAOnE;;;;GAIG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,cAAc,EAAE,GACzB,OAAO,CAAC;IAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CA8D/D"}
+{"version":3,"file":"pullData.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pullFromRemote/pullData.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AASnE;;;;GAIG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,cAAc,EAAE,GACzB,OAAO,CAAC;IAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CA2E/D"}

package/dist/utils/sync/pullFromRemote/pullData.js

@@ -2,6 +2,8 @@ import { getSupastashConfig } from "../../../core/config";
 import { getSupastashDb } from "../../../db/dbInitializer";
 import log, { logWarn } from "../../logs";
 import { supabaseClientErr } from "../../supabaseClientErr";
+import { SyncInfoUpdater } from "../queryStatus";
+import { computeFilterKey } from "../status/filterKey";
 import { selectAndAddAMillisecond } from "../status/repo";
 import { setSupastashSyncStatus } from "../status/services";
 import { getMaxDate, logNoUpdates, pageThrough } from "./helpers";
@@ -14,6 +16,18 @@ export async function pullData(table, filters) {
     const supabase = getSupastashConfig().supabaseClient;
     if (!supabase)
         throw new Error(`No supabase client found: ${supabaseClientErr}`);
+    SyncInfoUpdater.setLastSyncLog({
+        key: "filterJson",
+        value: filters ?? [],
+        type: "pull",
+        table,
+    });
+    SyncInfoUpdater.setLastSyncLog({
+        key: "filterKey",
+        value: (await computeFilterKey(filters, "global")) ?? "",
+        type: "pull",
+        table,
+    });
     const db = await getSupastashDb();
     const { last_created_at, last_synced_at, last_deleted_at } = await selectAndAddAMillisecond(db, table, filters);
     const [createdRows, updatedRows, deletedRows] = await Promise.all([

package/dist/utils/sync/pullFromRemote/updateLocalDb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updateLocalDb.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pullFromRemote/updateLocalDb.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAcnE;;;GAGG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,cAAc,EAAE,EAC1B,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,iBA6EhD;AAID;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,GAAG,EACX,SAAS,CAAC,EAAE,OAAO,iBAoEpB"}
+{"version":3,"file":"updateLocalDb.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pullFromRemote/updateLocalDb.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAenE;;;GAGG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,cAAc,EAAE,EAC1B,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,iBAyFhD;AAID;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,GAAG,EACX,SAAS,CAAC,EAAE,OAAO,iBAoEpB"}

package/dist/utils/sync/pullFromRemote/updateLocalDb.js

@@ -4,6 +4,7 @@ import { isOnline } from "../../connection";
 import { getTableSchema } from "../../getTableSchema";
 import log, { logError, logWarn } from "../../logs";
 import { refreshScreen } from "../../refreshScreenCalls";
+import { SyncInfoUpdater } from "../queryStatus";
 import { updateLocalSyncedAt } from "../status/syncUpdate";
 import { pullData } from "./pullData";
 import { stringifyValue } from "./stringifyFields";
@@ -27,6 +28,16 @@ export async function updateLocalDb(table, filters, onReceiveData) {
         const data = dataResult?.data;
         const deletedIds = dataResult?.deletedIds;
         const deletedIdSet = new Set(deletedIds ?? []);
+        SyncInfoUpdater.setUnsyncedDataCount({
+            amount: data?.length ?? 0,
+            type: "pull",
+            table,
+        });
+        SyncInfoUpdater.setUnsyncedDeletedCount({
+            amount: deletedIds?.length ?? 0,
+            type: "pull",
+            table,
+        });
         const refreshNeeded = !!data?.length || !!deletedIds?.length;
         // Delete records that are no longer in the remote data
         if (deletedIds && deletedIds.length > 0) {
@@ -80,6 +91,7 @@ export async function updateLocalDb(table, filters, onReceiveData) {
     }
     catch (error) {
         logError(`[Supastash] Error updating local db for ${table}`, error);
+        throw error;
     }
     finally {
         isInSync.delete(table);

package/dist/utils/sync/pushLocal/sendUnsyncedToSupabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sendUnsyncedToSupabase.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/sendUnsyncedToSupabase.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,EACrD,MAAM,CAAC,EAAE,MAAM,EAAE,gCAuClB"}
+{"version":3,"file":"sendUnsyncedToSupabase.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/sendUnsyncedToSupabase.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,EACrD,MAAM,CAAC,EAAE,MAAM,EAAE,gCA8ClB"}

package/dist/utils/sync/pushLocal/sendUnsyncedToSupabase.js

@@ -1,6 +1,6 @@
 import { isOnline } from "../../connection";
-import { logError } from "../../logs";
 import { refreshScreen } from "../../refreshScreenCalls";
+import { SyncInfoUpdater } from "../queryStatus";
 import { deleteData } from "./deleteChunks";
 import { getAllDeletedData, getAllUnsyncedData } from "./getAllUnsyncedData";
 import { uploadData } from "./uploadChunk";
@@ -18,6 +18,16 @@ export async function pushLocalDataToRemote(table, onPushToRemote, noSync) {
             return false;
         const data = await getAllUnsyncedData(table);
         const deletedData = await getAllDeletedData(table);
+        SyncInfoUpdater.setUnsyncedDataCount({
+            amount: data?.length ?? 0,
+            type: "push",
+            table,
+        });
+        SyncInfoUpdater.setUnsyncedDeletedCount({
+            amount: deletedData?.length ?? 0,
+            type: "push",
+            table,
+        });
         const hasData = !!data?.length;
         const hasDeletes = !!deletedData?.length;
         if (!hasData && !hasDeletes) {
@@ -38,8 +48,7 @@ export async function pushLocalDataToRemote(table, onPushToRemote, noSync) {
         return didWork;
     }
     catch (error) {
-        logError(`[Supastash] Error pushing local data to remote for ${table}`, error);
-        return false;
+        throw error;
     }
     finally {
         isInSync.delete(table);

package/dist/utils/sync/pushLocal/uploadChunk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uploadChunk.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/uploadChunk.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AA+IzD;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,WAAW,EAAE,EAC9B,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,iBActD"}
+{"version":3,"file":"uploadChunk.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/uploadChunk.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AA6JzD;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,WAAW,EAAE,EAC9B,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,iBActD"}

package/dist/utils/sync/pushLocal/uploadChunk.js

@@ -4,7 +4,7 @@ import { isOnline } from "../../../utils/connection";
 import { normalizeForSupabase } from "../../getSafeValues";
 import log from "../../logs";
 import { supabaseClientErr } from "../../supabaseClientErr";
-import { setQueryStatus } from "../queryStatus";
+import { setQueryStatus, SyncInfoUpdater } from "../queryStatus";
 import { enforceTimestamps } from "./normalize";
 import { batchUpsert, fetchRemoteHeadsChunked, filterRowsByUpdatedAt, handleRowFailure, markSynced, singleUpsert, } from "./uploadHelpers";
 /**
@@ -26,6 +26,8 @@ async function uploadChunk(table, chunk, onPushToRemote) {
     const online = await isOnline();
     if (!online)
         return;
+    let errorCount = 0;
+    let lastError = null;
     const ids = chunk.map((row) => row.id);
     // Fetch remote data for the current chunk
     const remoteIds = await fetchRemoteHeadsChunked(table, ids, supabase);
@@ -88,6 +90,8 @@ async function uploadChunk(table, chunk, onPushToRemote) {
                 syncedNow.push(row.id);
                 continue;
             }
+            errorCount++;
+            lastError = res.error;
             const decision = await handleRowFailure(config, table, row, res.error, supabase);
             if (decision === "DROP" || decision === "REPLACED") {
                 continue;
@@ -107,6 +111,15 @@ async function uploadChunk(table, chunk, onPushToRemote) {
         await new Promise((r) => setTimeout(r, delay));
         pending = keep;
     }
+    if (pending.length > 0) {
+        SyncInfoUpdater.markLogError({
+            type: "push",
+            table,
+            lastError: lastError ?? new Error("Unknown error"),
+            errorCount: errorCount ?? 0,
+            rowsFailed: pending.length,
+        });
+    }
     // Gave up this pass — rows left in `pending` will be retried by outer scheduler
     for (const r of pending)
         setQueryStatus(r.id, table, "error");

package/dist/utils/sync/queryStatus.d.ts

@@ -1,3 +1,4 @@
+import { SyncInfo, SyncLogEntry } from "../../types/syncEngine.types";
 /**
  * Sets the sync status of a query (row) in a specific table.
  * Automatically removes the entry if the status is 'success'.
@@ -37,4 +38,59 @@ export declare function getTableStatus(table: string): {
  *          "synced" if all tables are fully synced
  */
 export declare function getSupastashStatus(): "error" | "pending" | "synced";
+declare function snapshot(): SyncInfo;
+export declare const SyncInfoUpdater: {
+    setInProgress: ({ action, type, }: {
+        action: "start" | "stop";
+        type: "pull" | "push";
+    }) => void;
+    setTablesCompleted: ({ amount, type, }: {
+        amount: number;
+        type: "pull" | "push";
+    }) => void;
+    setNumberOfTables: ({ amount, type, }: {
+        amount: number;
+        type: "pull" | "push";
+    }) => void;
+    setCurrentTable: ({ table, type, }: {
+        table: string;
+        type: "pull" | "push";
+    }) => void;
+    setLastSyncLog: ({ key, value, type, table, }: {
+        key: keyof SyncLogEntry;
+        value: SyncLogEntry[keyof SyncLogEntry];
+        type: "pull" | "push";
+        table: string;
+    }) => void;
+    setUnsyncedDataCount: ({ amount, type, table, }: {
+        amount: number;
+        type: "pull" | "push";
+        table: string;
+    }) => void;
+    setUnsyncedDeletedCount: ({ amount, type, table, }: {
+        amount: number;
+        type: "pull" | "push";
+        table: string;
+    }) => void;
+    markLogStart: ({ type, table }: {
+        type: "pull" | "push";
+        table: string;
+    }) => void;
+    markLogSuccess: ({ type, table, }: {
+        type: "pull" | "push";
+        table: string;
+    }) => void;
+    markLogError: ({ type, table, lastError, errorCount, rowsFailed, }: {
+        type: "pull" | "push";
+        table: string;
+        lastError: Error;
+        errorCount: number;
+        rowsFailed?: number;
+    }) => void;
+    reset: ({ type }: {
+        type: "pull" | "push";
+    }) => void;
+    getSnapshot: typeof snapshot;
+};
+export {};
 //# sourceMappingURL=queryStatus.d.ts.map

package/dist/utils/sync/queryStatus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queryStatus.d.ts","sourceRoot":"","sources":["../../../src/utils/sync/queryStatus.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,QAYxC;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,MAAM,iBAgBvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM;;;;;EAwB3C;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,mCAcjC"}
+{"version":3,"file":"queryStatus.d.ts","sourceRoot":"","sources":["../../../src/utils/sync/queryStatus.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAGtE;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,QAYxC;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,MAAM,iBAgBvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM;;;;;EAwB3C;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,mCAcjC;AAID,iBAAS,QAAQ,IAAI,QAAQ,CAE5B;AAKD,eAAO,MAAM,eAAe;uCAIvB;QACD,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;QACzB,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;KACvB;4CAUE;QACD,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;KACvB;2CAUE;QACD,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;KACvB;wCAUE;QACD,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;KACvB;mDAgBE;QACD,GAAG,EAAE,MAAM,YAAY,CAAC;QACxB,KAAK,EAAE,YAAY,CAAC,MAAM,YAAY,CAAC,CAAC;QACxC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;KACf;qDAqBE;QACD,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;KACf;wDAiBE;QACD,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;KACf;oCAc+B;QAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;uCAWrE;QACD,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;KACf;wEAqBE;QACD,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,KAAK,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB;sBAiCiB;QAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE;;CAe5C,CAAC"}

package/dist/utils/sync/queryStatus.js

@@ -1,5 +1,6 @@
 import { getSupastashDb } from "../../db/dbInitializer";
-import { syncStatusMap } from "../../store/syncStatus";
+import { DEFAULT_SYNC_LOG_ENTRY, syncInfo, syncStatusMap, } from "../../store/syncStatus";
+import { supastashEventBus } from "../events/eventBus";
 /**
  * Sets the sync status of a query (row) in a specific table.
  * Automatically removes the entry if the status is 'success'.
@@ -91,3 +92,148 @@ export function getSupastashStatus() {
     }
     return "synced";
 }
+let storeSyncInfo = structuredClone(syncInfo);
+function snapshot() {
+    return structuredClone(storeSyncInfo);
+}
+function emit() {
+    supastashEventBus.emit("updateSyncInfo", snapshot());
+}
+export const SyncInfoUpdater = {
+    setInProgress: ({ action, type, }) => {
+        const next = structuredClone(storeSyncInfo);
+        next[type].inProgress = action === "start";
+        storeSyncInfo = next;
+        emit();
+    },
+    setTablesCompleted: ({ amount, type, }) => {
+        const next = structuredClone(storeSyncInfo);
+        next[type].tablesCompleted = amount;
+        storeSyncInfo = next;
+        emit();
+    },
+    setNumberOfTables: ({ amount, type, }) => {
+        const next = structuredClone(storeSyncInfo);
+        next[type].numberOfTables = amount;
+        storeSyncInfo = next;
+        emit();
+    },
+    setCurrentTable: ({ table, type, }) => {
+        const next = structuredClone(storeSyncInfo);
+        next[type].currentTable = {
+            name: table,
+            unsyncedDataCount: 0,
+            unsyncedDeletedCount: 0,
+        };
+        storeSyncInfo = next;
+        emit();
+    },
+    setLastSyncLog: ({ key, value, type, table, }) => {
+        const next = structuredClone(storeSyncInfo);
+        const arr = next[type].lastSyncLog;
+        const row = arr.find((l) => l.table === table);
+        if (!row) {
+            arr.push({
+                ...DEFAULT_SYNC_LOG_ENTRY,
+                table,
+                [key]: value,
+            });
+        }
+        else {
+            row[key] = value;
+        }
+        storeSyncInfo = next;
+        emit();
+    },
+    setUnsyncedDataCount: ({ amount, type, table, }) => {
+        const next = structuredClone(storeSyncInfo);
+        next[type].currentTable.unsyncedDataCount = amount;
+        SyncInfoUpdater.setLastSyncLog({
+            type,
+            table,
+            key: "unsyncedDataCount",
+            value: amount,
+        });
+        storeSyncInfo = next;
+        emit();
+    },
+    setUnsyncedDeletedCount: ({ amount, type, table, }) => {
+        const next = structuredClone(storeSyncInfo);
+        next[type].currentTable.unsyncedDeletedCount = amount;
+        SyncInfoUpdater.setLastSyncLog({
+            type,
+            table,
+            key: "unsyncedDeletedCount",
+            value: amount,
+        });
+        storeSyncInfo = next;
+        emit();
+    },
+    // convenience helpers (optional)
+    markLogStart: ({ type, table }) => SyncInfoUpdater.setLastSyncLog({
+        type,
+        table,
+        key: "startTime",
+        value: Date.now(),
+    }),
+    markLogSuccess: ({ type, table, }) => {
+        SyncInfoUpdater.setLastSyncLog({
+            type,
+            table,
+            key: "success",
+            value: true,
+        });
+        SyncInfoUpdater.setLastSyncLog({
+            type,
+            table,
+            key: "endTime",
+            value: Date.now(),
+        });
+    },
+    markLogError: ({ type, table, lastError, errorCount, rowsFailed = 0, }) => {
+        SyncInfoUpdater.setLastSyncLog({
+            type,
+            table,
+            key: "success",
+            value: false,
+        });
+        SyncInfoUpdater.setLastSyncLog({
+            type,
+            table,
+            key: "lastError",
+            value: lastError,
+        });
+        SyncInfoUpdater.setLastSyncLog({
+            type,
+            table,
+            key: "errorCount",
+            value: errorCount,
+        });
+        SyncInfoUpdater.setLastSyncLog({
+            type,
+            table,
+            key: "endTime",
+            value: Date.now(),
+        });
+        SyncInfoUpdater.setLastSyncLog({
+            type,
+            table,
+            key: "rowsFailed",
+            value: rowsFailed ?? 0,
+        });
+    },
+    reset: ({ type }) => {
+        const next = structuredClone(storeSyncInfo);
+        next[type] = {
+            ...next[type],
+            inProgress: false,
+            numberOfTables: 0,
+            tablesCompleted: 0,
+            currentTable: { name: "", unsyncedDataCount: 0, unsyncedDeletedCount: 0 },
+            lastSyncedAt: Date.now(),
+        };
+        storeSyncInfo = next;
+        emit();
+    },
+    getSnapshot: snapshot,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supastash",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",