supastash 0.1.34 → 0.1.35

package/dist/constants/syncDefaults.d.ts

@@ -0,0 +1,5 @@
+import { FieldEnforcement, SupastashSyncPolicy } from "../types/supastashConfig.types";
+export declare const DEFAULT_POLICY: SupastashSyncPolicy;
+export declare const DEFAULT_FIELDS: FieldEnforcement;
+export declare const DEFAULT_CHUNK_SIZE = 500;
+//# sourceMappingURL=syncDefaults.d.ts.map

package/dist/constants/syncDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncDefaults.d.ts","sourceRoot":"","sources":["../../src/constants/syncDefaults.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,gCAAgC,CAAC;AAExC,eAAO,MAAM,cAAc,EAAE,mBAU5B,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,gBAO5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,MAAM,CAAC"}

package/dist/constants/syncDefaults.js

@@ -0,0 +1,19 @@
+export const DEFAULT_POLICY = {
+    nonRetryableCodes: new Set(["23505", "23502", "23514", "23P01"]),
+    retryableCodes: new Set(["40001", "40P01", "55P03"]),
+    fkCode: "23503",
+    onNonRetryable: "accept-server",
+    maxTransientMs: 20 * 60 * 1000, // 20m
+    maxFkBlockMs: 24 * 60 * 60 * 1000, // 24h
+    backoffDelaysMs: [10000, 30000, 120000, 300000, 600000],
+    maxBatchAttempts: 5,
+};
+export const DEFAULT_FIELDS = {
+    requireCreatedAt: true,
+    requireUpdatedAt: true,
+    createdAtField: "created_at",
+    updatedAtField: "updated_at",
+    autoFillMissing: true,
+    autoFillDefaultISO: "1970-01-01T00:00:00Z",
+};
+export const DEFAULT_CHUNK_SIZE = 500;

package/dist/core/config/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC3B,MAAM,mCAAmC,CAAC;AAuB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,0BAA0B,EACrE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG;IAAE,gBAAgB,EAAE,CAAC,CAAA;CAAE,QAqBrD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,SAAS,0BAA0B,KACjC,eAAe,CAAC,CAAC,CAAC,CAEtB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,SAAS,0BAA0B,EACpC,MAAM,EAAE;IACR,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG;QAC9B,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;KAC3B,CAAC;CACH,QAEA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/config/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC3B,MAAM,mCAAmC,CAAC;AA0B3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,0BAA0B,EACrE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG;IAAE,gBAAgB,EAAE,CAAC,CAAA;CAAE,QAuCrD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,SAAS,0BAA0B,KACjC,eAAe,CAAC,CAAC,CAAC,CAEtB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,SAAS,0BAA0B,EACpC,MAAM,EAAE;IACR,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG;QAC9B,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;KAC3B,CAAC;CACH,QAEA"}

package/dist/core/config/index.js

@@ -1,3 +1,4 @@
+import { DEFAULT_FIELDS, DEFAULT_POLICY } from "../../constants/syncDefaults";
 let _config = {
     dbName: "supastash_db",
     supabaseClient: null,
@@ -15,6 +16,9 @@ let _config = {
     },
     listeners: 250,
     debugMode: true,
+    syncPolicy: DEFAULT_POLICY,
+    fieldEnforcement: DEFAULT_FIELDS,
+    deleteConflictedRows: false,
 };
 let _configured = false;
 /**
@@ -76,6 +80,22 @@ export function configureSupastash(config) {
             pull: config.pollingInterval?.pull ?? _config.pollingInterval?.pull ?? 30000,
             push: config.pollingInterval?.push ?? _config.pollingInterval?.push ?? 30000,
         },
+        syncPolicy: {
+            ...DEFAULT_POLICY,
+            ..._config.syncPolicy,
+            ...config.syncPolicy,
+            nonRetryableCodes: config.syncPolicy?.nonRetryableCodes ??
+                _config.syncPolicy?.nonRetryableCodes ??
+                DEFAULT_POLICY.nonRetryableCodes,
+            retryableCodes: config.syncPolicy?.retryableCodes ??
+                _config.syncPolicy?.retryableCodes ??
+                DEFAULT_POLICY.retryableCodes,
+        },
+        fieldEnforcement: {
+            ...DEFAULT_FIELDS,
+            ..._config.fieldEnforcement,
+            ...config.fieldEnforcement,
+        },
     };
     _configured = true;
 }

package/dist/hooks/supastashData/fetchCalls.js

@@ -11,13 +11,13 @@ export function fetchCalls(table, options, initialized) {
         if (filter && useFilterWhileSyncing && !tableFiltersUsed.has(table)) {
             tableFilters.set(table, [filter]);
         }
-        if (onPushToRemote) {
+        if (onPushToRemote && !syncCalls.get(table)?.push) {
             syncCalls.set(table, {
                 ...(syncCalls.get(table) || {}),
                 push: onPushToRemote,
             });
         }
-        if (onInsertAndUpdate) {
+        if (onInsertAndUpdate && !syncCalls.get(table)?.pull) {
             syncCalls.set(table, {
                 ...(syncCalls.get(table) || {}),
                 pull: onInsertAndUpdate,

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/supastashFilters/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAarE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,OAAO,EAAE,eAAe,QA6BnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/supastashFilters/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAarE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,OAAO,EAAE,eAAe,QAmDnE"}

package/dist/hooks/supastashFilters/index.js

@@ -1,5 +1,5 @@
 import { useEffect } from "react";
-import { tableFilters, tableFiltersUsed } from "../../store/tableFilters";
+import { filterTracker, tableFilters, tableFiltersUsed, } from "../../store/tableFilters";
 import { logWarn } from "../../utils/logs";
 import isValidFilter, { warnOnMisMatch, } from "../../utils/sync/pullFromRemote/validateFilters";
 import { checkIfTableExist } from "../../utils/tableValidator";
@@ -41,31 +41,43 @@ function warnInvalidFilter(filter, table) {
  */
 export default function useSupastashFilters(filters) {
     useEffect(() => {
-        const addFilters = async () => {
-            for (const table in filters) {
-                const tableInDb = await checkIfTableExist(table);
-                if (!tableInDb) {
-                    logWarn(`Table ${table} does not exist`);
-                    continue;
+        let cancelled = false;
+        async function run() {
+            const incoming = Object.keys(filters ?? {});
+            // Remove stale tables
+            for (const t of Array.from(tableFilters.keys())) {
+                if (!incoming.includes(t)) {
+                    tableFilters.delete(t);
+                    tableFiltersUsed.delete(t);
+                    filterTracker.delete(t);
                 }
-                const filtersForTable = filters[table];
-                if (!filtersForTable) {
-                    logWarn(`No filters for table ${table}`);
+            }
+            // Existence check + per-table registration
+            const existence = await Promise.all(incoming.map(async (t) => [t, await checkIfTableExist(t)]));
+            if (cancelled)
+                return;
+            for (const [table, exists] of existence) {
+                if (!exists) {
+                    logWarn(`Table '${table}' does not exist; skipping filters`);
                     continue;
                 }
-                const validFilters = filtersForTable.filter((f) => {
-                    const isValid = isValidFilter([f]);
-                    if (!isValid)
-                        warnInvalidFilter(f, table);
-                    return isValid;
-                });
-                if (validFilters.length > 0) {
-                    warnOnMisMatch(table, validFilters);
-                    tableFilters.set(table, validFilters);
-                    tableFiltersUsed.add(table);
+                const raw = filters[table] ?? [];
+                const valid = raw.filter((f) => isValidFilter([f]));
+                if (!valid.length) {
+                    tableFilters.delete(table);
+                    tableFiltersUsed.delete(table);
+                    filterTracker.delete(table);
+                    continue;
                 }
+                // Warn on signature change and store a cloned array
+                warnOnMisMatch(table, valid);
+                tableFilters.set(table, valid.map((v) => ({ ...v })));
+                tableFiltersUsed.add(table);
             }
+        }
+        void run();
+        return () => {
+            cancelled = true;
         };
-        void addFilters();
     }, [filters]);
 }

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

@@ -1,37 +1,28 @@
 /**
- * Syncs the local data to the remote database
+ * Push then (optionally) pull.
+ * - Single flight across entire app via module-scoped flags.
+ * - Both directions gated on connectivity.
+ * - "force" ignores pull cadence timing.
  */
 export declare function syncAll(force?: boolean): Promise<void>;
+/**
+ * Hook to start/stop the periodic sync engine.
+ * - Staggers push & pull timers.
+ * - Debounced foreground trigger.
+ * - Shares module-level single-flight guards with syncAll().
+ */
 export declare function useSyncEngine(): {
     startSync: () => void;
     stopSync: () => void;
 };
 /**
- * Manually syncs a **single** table with Supabase.
- *
- * This function:
- * - Pulls remote data into local SQLite (if a pull handler is registered)
- * - Pushes unsynced local data to Supabase
- * - Skips syncing if already in progress for this table
- * - Applies filter if `useFiltersFromStore` is enabled
- *
- * Use this for explicit sync triggers (e.g., pull-to-refresh).
- *
- * @param {string} table - The name of the table to sync.
- * @returns {Promise<void>}
+ * Manually sync a single table (pull then push for that table).
+ * - Uses table-specific handlers from syncCalls if provided.
+ * - Respects configured filters when enabled.
  */
 export declare function syncTable(table: string): Promise<void>;
 /**
- * Manually syncs **all registered tables** with Supabase.
- *
- * This function:
- * - Triggers a full sync of all registered tables
- * - Forces a sync outside the normal polling schedule
- * - Skips any table that is already syncing
- *
- * Useful for global refreshes (e.g., on app foreground).
- *
- * @returns {Promise<void>}
+ * Force a global sync pass now (push then pull if due).
  */
 export declare function syncAllTables(): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/syncEngine/index.ts"],"names":[],"mappings":"AAgBA;;GAEG;AACH,wBAAsB,OAAO,CAAC,KAAK,GAAE,OAAe,iBA2BnD;AAED,wBAAgB,aAAa;;;EA+B5B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAEnD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/syncEngine/index.ts"],"names":[],"mappings":"AA4BA;;;;;GAKG;AACH,wBAAsB,OAAO,CAAC,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAgCnE;AAmDD;;;;;GAKG;AACH,wBAAgB,aAAa;;;EA8D5B;AAMD;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgC5D;AAED;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAEnD"}

package/dist/hooks/syncEngine/index.js

@@ -1,4 +1,4 @@
-import { useRef } from "react";
+import { useEffect, useRef } from "react";
 import { AppState } from "react-native";
 import { getSupastashConfig } from "../../core/config";
 import { syncCalls } from "../../store/syncCalls";
@@ -7,103 +7,215 @@ import { isOnline } from "../../utils/connection";
 import log from "../../utils/logs";
 import { updateLocalDb } from "../../utils/sync/pullFromRemote/updateLocalDb";
 import { pushLocalDataToRemote } from "../../utils/sync/pushLocal/sendUnsyncedToSupabase";
-import { pullFromRemote } from "./pullFromRemote";
-import { pushLocalData } from "./pushLocal";
+import { pullFromRemote as doPullFromRemote } from "./pullFromRemote";
+import { pushLocalData as doPushLocalData } from "./pushLocal";
+// -----------------------------
+// Module-scoped state & tunables
+// -----------------------------
 let isSyncing = false;
-let lastFullSync = 0;
-const syncPollingInterval = getSupastashConfig().pollingInterval?.push || 30000;
+let isPushing = false;
+let isPulling = false;
+let lastPullAt = 0;
+let lastPushAt = 0;
+const MIN_FOREGROUND_GAP = 5000; // ms
+// -----------------------------
+// Core orchestration
+// -----------------------------
 /**
- * Syncs the local data to the remote database
+ * Push then (optionally) pull.
+ * - Single flight across entire app via module-scoped flags.
+ * - Both directions gated on connectivity.
+ * - "force" ignores pull cadence timing.
  */
 export async function syncAll(force = false) {
-    if (isSyncing) {
+    if (isSyncing)
         return;
-    }
     if (!(await isOnline()))
         return;
+    isSyncing = true;
+    const started = Date.now();
     try {
-        isSyncing = true;
-        if (getSupastashConfig().syncEngine?.pull) {
+        const cfg = getSupastashConfig();
+        // PUSH
+        if (cfg.syncEngine?.push) {
+            await pushLocalDataSafe();
+        }
+        // PULL
+        if (cfg.syncEngine?.pull) {
+            const pullInterval = cfg.pollingInterval?.pull ?? 30000;
             const now = Date.now();
-            const shouldPull = force ||
-                now - lastFullSync >
-                    (getSupastashConfig().pollingInterval?.pull || 30000);
-            if (shouldPull) {
-                await pullFromRemote();
-                lastFullSync = now;
+            const due = force || now - lastPullAt >= pullInterval;
+            if (due) {
+                await pullFromRemoteSafe();
+                lastPullAt = now;
             }
         }
-        await pushLocalData();
     }
-    catch (error) {
-        log(`[Supastash] Error syncing: ${error}`);
+    catch (e) {
+        log("[Supastash] Error in syncAll", {
+            msg: String(e),
+            code: e?.code ?? e?.name ?? "UNKNOWN",
+        });
     }
     finally {
         isSyncing = false;
+        log(`[Supastash] syncAll finished in ${Date.now() - started}ms`);
+    }
+}
+// -----------------------------
+// Directional helpers
+// -----------------------------
+async function pushLocalDataSafe() {
+    if (isPushing)
+        return;
+    if (!(await isOnline()))
+        return;
+    const cfg = getSupastashConfig();
+    if (!cfg.syncEngine?.push)
+        return;
+    isPushing = true;
+    try {
+        await doPushLocalData();
+        lastPushAt = Date.now();
+    }
+    catch (e) {
+        log("[Supastash] push error", {
+            msg: String(e),
+            code: e?.code ?? e?.name ?? "UNKNOWN",
+        });
+    }
+    finally {
+        isPushing = false;
     }
 }
+async function pullFromRemoteSafe() {
+    if (isPulling)
+        return;
+    if (!(await isOnline()))
+        return;
+    const cfg = getSupastashConfig();
+    if (!cfg.syncEngine?.pull)
+        return;
+    isPulling = true;
+    try {
+        await doPullFromRemote();
+        lastPullAt = Date.now();
+    }
+    catch (e) {
+        log("[Supastash] pull error", {
+            msg: String(e),
+            code: e?.code ?? e?.name ?? "UNKNOWN",
+        });
+    }
+    finally {
+        isPulling = false;
+    }
+}
+// -----------------------------
+// React hook: timer & lifecycle management
+// -----------------------------
+/**
+ * Hook to start/stop the periodic sync engine.
+ * - Staggers push & pull timers.
+ * - Debounced foreground trigger.
+ * - Shares module-level single-flight guards with syncAll().
+ */
 export function useSyncEngine() {
-    const isSyncingRef = useRef(false);
-    const intervalRef = useRef(null);
-    const appStateRef = useRef(null);
+    // Timers & lifecycle
+    const intervalRefPush = useRef(null);
+    const intervalRefPull = useRef(null);
+    const appStateSubRef = useRef(null);
+    // Debounce foreground re-entry
+    const lastForeground = useRef(0);
     function startSync() {
-        if (isSyncingRef.current)
+        if (intervalRefPush.current ||
+            intervalRefPull.current ||
+            appStateSubRef.current) {
             return;
-        isSyncingRef.current = true;
-        syncAll(true);
-        const config = getSupastashConfig();
-        const syncPollingInterval = config.pollingInterval?.push ?? 30000;
-        intervalRef.current = setInterval(() => {
-            syncAll();
-        }, syncPollingInterval);
-        appStateRef.current = AppState.addEventListener("change", (state) => {
-            if (state === "active") {
-                syncAll(true);
-            }
+        }
+        // Kick a one-shot global sync on start
+        void syncAll(true);
+        const cfg = getSupastashConfig();
+        const pushEvery = cfg.pollingInterval?.push ?? 30000;
+        const pullEvery = cfg.pollingInterval?.pull ?? 30000;
+        // Push ticker
+        intervalRefPush.current = setInterval(() => {
+            void pushLocalDataSafe();
+        }, pushEvery);
+        // Pull ticker
+        intervalRefPull.current = setInterval(() => {
+            void pullFromRemoteSafe();
+        }, pullEvery + 500);
+        // Foreground trigger
+        appStateSubRef.current = AppState.addEventListener("change", (state) => {
+            if (state !== "active")
+                return;
+            const now = Date.now();
+            if (now - lastForeground.current < MIN_FOREGROUND_GAP)
+                return;
+            lastForeground.current = now;
+            void syncAll(true);
         });
     }
     function stopSync() {
-        if (intervalRef.current)
-            clearInterval(intervalRef.current);
-        appStateRef.current?.remove?.();
-        isSyncingRef.current = false;
+        if (intervalRefPush.current) {
+            clearInterval(intervalRefPush.current);
+            intervalRefPush.current = null;
+        }
+        if (intervalRefPull.current) {
+            clearInterval(intervalRefPull.current);
+            intervalRefPull.current = null;
+        }
+        appStateSubRef.current?.remove?.();
+        appStateSubRef.current = null;
     }
+    // Auto-cleanup if the hook lives in a component lifecycle
+    useEffect(() => stopSync, []);
     return { startSync, stopSync };
 }
+// -----------------------------
+// Manual triggers
+// -----------------------------
 /**
- * Manually syncs a **single** table with Supabase.
- *
- * This function:
- * - Pulls remote data into local SQLite (if a pull handler is registered)
- * - Pushes unsynced local data to Supabase
- * - Skips syncing if already in progress for this table
- * - Applies filter if `useFiltersFromStore` is enabled
- *
- * Use this for explicit sync triggers (e.g., pull-to-refresh).
- *
- * @param {string} table - The name of the table to sync.
- * @returns {Promise<void>}
+ * Manually sync a single table (pull then push for that table).
+ * - Uses table-specific handlers from syncCalls if provided.
+ * - Respects configured filters when enabled.
  */
 export async function syncTable(table) {
-    const config = getSupastashConfig();
-    const { useFiltersFromStore = true } = config?.syncEngine || {};
+    if (!(await isOnline()))
+        return;
+    const cfg = getSupastashConfig();
+    const { useFiltersFromStore = true } = cfg?.syncEngine || {};
     const filter = useFiltersFromStore ? tableFilters.get(table) : undefined;
-    if (getSupastashConfig().syncEngine?.pull) {
-        await updateLocalDb(table, filter, syncCalls.get(table)?.pull);
+    // Pull
+    if (cfg.syncEngine?.pull) {
+        try {
+            await updateLocalDb(table, filter, syncCalls.get(table)?.pull);
+        }
+        catch (e) {
+            log("[Supastash] syncTable pull error", {
+                table,
+                msg: String(e),
+                code: e?.code ?? e?.name ?? "UNKNOWN",
+            });
+        }
+    }
+    // Push (use table handler if present)
+    if (cfg.syncEngine?.push) {
+        try {
+            await pushLocalDataToRemote(table, syncCalls.get(table)?.push);
+        }
+        catch (e) {
+            log("[Supastash] syncTable push error", {
+                table,
+                msg: String(e),
+                code: e?.code ?? e?.name ?? "UNKNOWN",
+            });
+        }
     }
-    await pushLocalDataToRemote(table, syncCalls.get(table)?.push);
 }
 /**
- * Manually syncs **all registered tables** with Supabase.
- *
- * This function:
- * - Triggers a full sync of all registered tables
- * - Forces a sync outside the normal polling schedule
- * - Skips any table that is already syncing
- *
- * Useful for global refreshes (e.g., on app foreground).
- *
- * @returns {Promise<void>}
+ * Force a global sync pass now (push then pull if due).
  */
 export async function syncAllTables() {
     await syncAll(true);

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":"AAOA;;GAEG;AACH,wBAAsB,cAAc,kBAyBnC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/syncEngine/pullFromRemote/index.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,wBAAsB,cAAc,kBA8BnC"}

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

@@ -3,6 +3,7 @@ import { syncCalls } from "../../../store/syncCalls";
 import { tableFilters } from "../../../store/tableFilters";
 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";
 /**
  * Pulls the data from the remote database to the local database
@@ -16,9 +17,17 @@ export async function pullFromRemote() {
         }
         const excludeTables = getSupastashConfig()?.excludeTables?.pull || [];
         const tablesToPull = tables.filter((table) => !excludeTables?.includes(table));
-        for (const table of tablesToPull) {
-            await updateLocalDb(table, tableFilters.get(table), syncCalls.get(table)?.pull);
-        }
+        const toPull = tablesToPull.map((table) => async () => {
+            try {
+                const filter = tableFilters.get(table);
+                const onReceiveRecord = syncCalls.get(table)?.pull;
+                await updateLocalDb(table, filter, onReceiveRecord);
+            }
+            catch (e) {
+                log(`[Supastash] pull table failed: ${table} — ${e?.code ?? e?.name ?? e}`);
+            }
+        });
+        await runLimitedConcurrency(toPull, 3);
     }
     catch (error) {
         log(`[Supastash] Error pulling from remote: ${error}`);

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":"AASA;;GAEG;AACH,wBAAsB,aAAa,kBAmClC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/syncEngine/pushLocal/index.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,wBAAsB,aAAa,kBA4DlC"}

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

@@ -1,10 +1,13 @@
 import { getSupastashConfig } from "../../../core/config";
 import { syncCalls } from "../../../store/syncCalls";
+import { isOnline } from "../../../utils/connection";
 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";
-let timesPushed = 0;
-let lastPushed = 0;
+let emptyPassCount = 0;
+let lastEmptyPassAt = 0;
+const tablePushLock = new Map();
 /**
  * Pushes the local data to the remote database
  */
@@ -12,23 +15,49 @@ export async function pushLocalData() {
     try {
         const tables = await getAllTables();
         if (!tables) {
-            log("No tables found");
+            log("[Supastash] No tables found");
             return;
         }
+        if (!(await isOnline()))
+            return;
         const excludeTables = getSupastashConfig()?.excludeTables?.push || [];
         const tablesToPush = tables.filter((table) => !excludeTables?.includes(table));
-        const noSync = [];
-        for (const table of tablesToPush) {
-            await pushLocalDataToRemote(table, syncCalls.get(table)?.push, noSync);
-        }
-        if (noSync.length > 0) {
-            timesPushed++;
-            if (timesPushed >= 150) {
-                const timeSinceLastPush = Date.now() - lastPushed;
-                lastPushed = Date.now();
-                log(`[Supastash] No sync data found for tables: ${noSync.join(", ")} (times pushed: ${timesPushed}) in the last ${timeSinceLastPush}ms`);
-                timesPushed = 0;
+        const results = [];
+        const jobs = tablesToPush.map((table) => async () => {
+            if (tablePushLock.get(table)) {
+                results.push({ table, hadWork: false });
+                return;
+            }
+            tablePushLock.set(table, true);
+            try {
+                const onPush = syncCalls.get(table)?.push;
+                const hadWork = await pushLocalDataToRemote(table, onPush);
+                results.push({ table, hadWork: !!hadWork });
+            }
+            catch (e) {
+                const msg = e?.code ?? e?.name ?? String(e);
+                results.push({ table, hadWork: false, error: msg });
+                log(`[Supastash] Push table failed: ${table} — ${msg}`);
             }
+            finally {
+                tablePushLock.set(table, false);
+            }
+        });
+        await runLimitedConcurrency(jobs, 3);
+        const hadAnyWork = results.some((r) => r.hadWork);
+        if (!hadAnyWork) {
+            emptyPassCount += 1;
+            if (emptyPassCount % 150 === 0) {
+                const now = Date.now();
+                const gap = lastEmptyPassAt ? now - lastEmptyPassAt : 0;
+                lastEmptyPassAt = now;
+                const noSyncTables = results.map((r) => r.table).join(", ");
+                log(`[Supastash] No pushable data for: ${noSyncTables} (empty passes: ${emptyPassCount})${gap ? ` in the last ${gap}ms` : ""}`);
+            }
+        }
+        else {
+            emptyPassCount = 0;
+            lastEmptyPassAt = Date.now();
         }
     }
     catch (error) {

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export { supastash } from "./utils/query/builder";
 export { dropAllTables, dropTable, wipeAllTables, wipeOldDataForAllTables, wipeOldDataForATable, wipeTable, } from "./utils/schema/wipeTables";
 export { getAllTables } from "./utils/sync/getAllTables";
 export { refreshAllTables, refreshTable, refreshTableWithPayload, } from "./utils/sync/refreshTables";
+export { clearSyncCalls, getAllSyncTables, getSyncCall, registerSyncCall, unregisterSyncCall, } from "./utils/sync/registration/syncCalls";
 export { clearAllLocalDeleteLog, clearAllLocalSyncLog, clearLocalDeleteLog, clearLocalSyncLog, getLocalDeleteLog, getLocalSyncLog, setLocalDeleteLog, setLocalSyncLog, } from "./utils/syncStatus";
 export type { CrudMethods } from "./types/query.types";
 export type { RealtimeOptions, SupastashDataResult, SupastashFilter, } from "./types/realtimeData.types";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EACL,aAAa,EACb,SAAS,EACT,aAAa,EACb,uBAAuB,EACvB,oBAAoB,EACpB,SAAS,GACV,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,eAAe,GAChB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EACL,aAAa,EACb,SAAS,EACT,aAAa,EACb,uBAAuB,EACvB,oBAAoB,EACpB,SAAS,GACV,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,eAAe,GAChB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,+BAA+B,CAAC"}