supastash 0.2.9 → 0.2.11

package/dist/native/utils/sync/pullFromRemote/pullFromRemoteBatch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Batch pull: fetches all tables in a single RPC call per round,
+ * looping until `remaining_tables` is empty.
+ *
+ * Requires `useBatchPullSync: true` in config and the
+ * `supastash_pull_sync` Postgres function to be deployed.
+ */
+export declare function pullFromRemoteBatch(): Promise<void>;
+//# sourceMappingURL=pullFromRemoteBatch.d.ts.map

package/dist/native/utils/sync/pullFromRemote/pullFromRemoteBatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pullFromRemoteBatch.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/pullFromRemote/pullFromRemoteBatch.ts"],"names":[],"mappings":"AA4CA;;;;;;GAMG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CA+KzD"}

package/dist/native/utils/sync/pullFromRemote/pullFromRemoteBatch.js

@@ -0,0 +1,183 @@
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { getSupastashDb } from "../../../../shared/db/dbInitializer";
+import { rpcTableFilters } from "../../../../shared/store/rpcTableFilters";
+import { tableFilters } from "../../../../shared/store/tableFilters";
+import { postgrestFiltersToRpc } from "../../../../shared/utils/sync/pullFromRemote/postgrestToRpc";
+import { getAllTables } from "../../../../shared/utils/sync/getAllTables";
+import { getMaxSyncLookBack, logNoUpdates, returnMaxDate, } from "../../../../shared/utils/sync/pullFromRemote/helpers";
+import { SyncInfoUpdater } from "../../../../shared/utils/sync/queryStatus";
+import { refreshScreen } from "../../../../shared/utils/refreshScreenCalls";
+import log, { logError, logWarn } from "../../../../shared/utils/logs";
+import { supabaseClientErr } from "../../../../shared/utils/supabaseClientErr";
+import { prefetchRemoteTableSchemas } from "../../../../shared/utils/sync/status/remoteSchema";
+import { setSupastashSyncStatus } from "../status/services";
+import { selectSyncStatus } from "../status/repo";
+import { upsertChunkData } from "./updateLocalDb";
+const CHUNK_SIZE = 999;
+function buildCursorFilter(tsCol, lastSyncedAt, lastPk) {
+    if (lastPk) {
+        return {
+            or: [
+                { col: tsCol, op: "gt", val: lastSyncedAt },
+                {
+                    and: [
+                        { col: tsCol, op: "eq", val: lastSyncedAt },
+                        { col: "id", op: "gt", val: lastPk },
+                    ],
+                },
+            ],
+        };
+    }
+    return { col: tsCol, op: "gte", val: lastSyncedAt };
+}
+/**
+ * Batch pull: fetches all tables in a single RPC call per round,
+ * looping until `remaining_tables` is empty.
+ *
+ * Requires `useBatchPullSync: true` in config and the
+ * `supastash_pull_sync` Postgres function to be deployed.
+ */
+export async function pullFromRemoteBatch() {
+    const cfg = getSupastashConfig();
+    const supabase = cfg.supabaseClient;
+    if (!supabase)
+        throw new Error(`No supabase client found: ${supabaseClientErr}`);
+    if (cfg.supastashMode === "ghost")
+        return;
+    const tables = await getAllTables();
+    if (!tables) {
+        log("[Supastash] Batch pull: no tables found");
+        return;
+    }
+    const excludeTables = cfg.excludeTables?.pull ?? [];
+    const tablesToPull = tables.filter((t) => !excludeTables.includes(t));
+    if (!tablesToPull.length)
+        return;
+    const tsCol = cfg.replicationMode === "server-side" ? "arrived_at" : "updated_at";
+    const db = await getSupastashDb();
+    const completedTables = new Set();
+    SyncInfoUpdater.setInProgress({ action: "start", type: "pull" });
+    SyncInfoUpdater.setNumberOfTables({ amount: tablesToPull.length, type: "pull" });
+    // Warm schema cache for all tables in one call if enabled
+    if (cfg.useBatchSchemaFetch) {
+        await prefetchRemoteTableSchemas(tablesToPull);
+    }
+    let remainingTables = tablesToPull;
+    try {
+        while (remainingTables.length > 0) {
+            // ── Build per-table filters: base filters + cursor ──────────────────
+            const p_filters = {};
+            for (const table of remainingTables) {
+                const syncStatus = await selectSyncStatus(db, table, tableFilters.get(table) ?? []);
+                // Mirror pageThrough: cap the cursor to maxSyncLookbackDays so a
+                // first-time sync doesn't try to pull decades of data.
+                // fullSyncTables bypass the cap (getMaxSyncLookBack returns undefined).
+                const maxLookBack = getMaxSyncLookBack({ table });
+                const effectiveSince = maxLookBack &&
+                    Date.parse(syncStatus.last_synced_at) < Date.parse(maxLookBack)
+                    ? maxLookBack
+                    : syncStatus.last_synced_at;
+                const cursorFilter = buildCursorFilter(tsCol, effectiveSince, syncStatus.last_synced_at_pk);
+                // Merge explicit RPC filters + PostgREST filters auto-converted at query time
+                const rpcBase = rpcTableFilters.get(table) ?? [];
+                const converted = postgrestFiltersToRpc(tableFilters.get(table));
+                const baseFilters = [...rpcBase, ...converted];
+                p_filters[table] = [...baseFilters, cursorFilter];
+            }
+            // ── Single RPC call ─────────────────────────────────────────────────
+            const { data, error } = await supabase.rpc("supastash_pull_sync", {
+                p_tables: remainingTables,
+                p_filters,
+                p_ts_col: tsCol,
+            });
+            if (error)
+                throw error;
+            const result = data;
+            const nextRemaining = result.remaining_tables ?? [];
+            // ── Process each table ──────────────────────────────────────────────
+            for (const [table, rows] of Object.entries(result.tables ?? {})) {
+                SyncInfoUpdater.markLogStart({ type: "pull", table });
+                try {
+                    if (!rows?.length) {
+                        logNoUpdates(table);
+                        SyncInfoUpdater.markLogSuccess({ type: "pull", table });
+                        continue;
+                    }
+                    const toDelete = [];
+                    const toUpsert = [];
+                    let prevMaxSyncedAt = null;
+                    let prevMaxDeletedAt = null;
+                    for (const row of rows) {
+                        if (!row?.id) {
+                            logWarn(`[Supastash] Batch: skipped row without id from "${table}"`);
+                            continue;
+                        }
+                        prevMaxSyncedAt = returnMaxDate({ row, prevMax: prevMaxSyncedAt, col: tsCol });
+                        prevMaxDeletedAt = returnMaxDate({ row, prevMax: prevMaxDeletedAt, col: "deleted_at" });
+                        if (row.deleted_at) {
+                            toDelete.push(row.id);
+                        }
+                        else {
+                            toUpsert.push(row);
+                        }
+                    }
+                    SyncInfoUpdater.setUnsyncedDataCount({ amount: toUpsert.length, type: "pull", table });
+                    SyncInfoUpdater.setUnsyncedDeletedCount({ amount: toDelete.length, type: "pull", table });
+                    // Delete soft-deleted rows
+                    if (toDelete.length > 0) {
+                        for (let i = 0; i < toDelete.length; i += CHUNK_SIZE) {
+                            const slice = toDelete.slice(i, i + CHUNK_SIZE);
+                            const placeholders = slice.map(() => "?").join(", ");
+                            await db.runAsync(`DELETE FROM ${table} WHERE id IN (${placeholders})`, slice);
+                        }
+                    }
+                    // Upsert live rows
+                    if (toUpsert.length > 0) {
+                        await upsertChunkData({ table, records: toUpsert });
+                    }
+                    // Update sync cursor so the next round starts from the right place
+                    if (prevMaxSyncedAt || prevMaxDeletedAt) {
+                        await setSupastashSyncStatus(table, tableFilters.get(table) ?? [], {
+                            lastSyncedAt: prevMaxSyncedAt?.value ?? undefined,
+                            lastDeletedAt: prevMaxDeletedAt?.value ?? undefined,
+                            lastSyncedAtPk: prevMaxSyncedAt?.pk ?? null,
+                            filterNamespace: "global",
+                        });
+                    }
+                    if (toUpsert.length > 0 || toDelete.length > 0) {
+                        refreshScreen(table);
+                    }
+                    log(`[Supastash] Batch received ${rows.length} rows for "${table}" ` +
+                        `(u${toUpsert.length}/d${toDelete.length})`);
+                    SyncInfoUpdater.markLogSuccess({ type: "pull", table });
+                }
+                catch (e) {
+                    SyncInfoUpdater.markLogError({
+                        type: "pull",
+                        table,
+                        lastError: e,
+                        errorCount: 1,
+                    });
+                    logError(`[Supastash] Batch pull failed for "${table}"`, e);
+                }
+                finally {
+                    // Mark table as fully completed only once it leaves remaining_tables
+                    if (!nextRemaining.includes(table)) {
+                        completedTables.add(table);
+                        SyncInfoUpdater.setTablesCompleted({
+                            amount: completedTables.size,
+                            type: "pull",
+                        });
+                    }
+                }
+            }
+            remainingTables = nextRemaining;
+        }
+    }
+    catch (error) {
+        logError("[Supastash] Error in batch pull from remote", error);
+    }
+    finally {
+        SyncInfoUpdater.reset({ type: "pull" });
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"uploadChunk.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/pushLocal/uploadChunk.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAmMnE;;;;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,iBAetD"}
+{"version":3,"file":"uploadChunk.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/pushLocal/uploadChunk.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAgPnE;;;;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,iBAetD"}

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

@@ -32,6 +32,7 @@ async function uploadChunk(table, chunk, onPushToRemote) {
     const hasRPCPath = !!config.pushRPCPath;
     const ids = chunk.map((row) => row.id);
     const toPush = [];
+    let remoteExistsMap = new Map();
     // If we have a RPC path, we can push the whole chunk. Server validates freshness.
     if (hasRPCPath) {
         toPush.push(...chunk);
@@ -39,6 +40,8 @@ async function uploadChunk(table, chunk, onPushToRemote) {
     else {
         // Fetch remote data for the current chunk
         const remoteIds = await fetchRemoteHeadsChunked(table, ids, supabase);
+        for (const id of ids)
+            remoteExistsMap.set(id, remoteIds.has(id));
         // Loop through the initial chunk and check if the id is in the remote data
         const filtered = filterRowsByUpdatedAt(table, chunk, remoteIds);
         toPush.push(...filtered);
@@ -74,7 +77,7 @@ async function uploadChunk(table, chunk, onPushToRemote) {
         let batchOk = false;
         // RPC return values
         let completed = [];
-        let existsMap = new Map();
+        let existsMap = new Map(remoteExistsMap);
         if (onPushToRemote) {
             const ok = await onPushToRemote(pending);
             if (ok)
@@ -86,12 +89,43 @@ async function uploadChunk(table, chunk, onPushToRemote) {
             pending = [...res.data.skipped];
             existsMap = res.data.existsMap;
             batchOk = res.error == null && pending.length === 0;
-            // If there was an RPC error, we need to retry the main function
             if (res.error) {
-                attempts++;
-                await backoff(attempts);
-                pending = [...preflightOK];
-                continue;
+                if (!(await isOnline())) {
+                    attempts++;
+                    await backoff(attempts);
+                    pending = [...preflightOK];
+                    continue;
+                }
+                // Online: RPC failed — run per-row single upserts immediately, no retry.
+                // pending was reassigned to res.data.skipped (empty on error), so use preflightOK.
+                const rowsToProcess = [...preflightOK];
+                try {
+                    const heads = await fetchRemoteHeadsChunked(table, rowsToProcess.map((r) => r.id), supabase);
+                    for (const r of rowsToProcess)
+                        existsMap.set(r.id, heads.has(r.id));
+                }
+                catch {
+                    // existsMap stays empty — singleUpsert will fall back to upsert
+                }
+                const syncedNow = [];
+                const keep = [];
+                for (const row of rowsToProcess) {
+                    const rowRes = await singleUpsert(table, row, supabase, existsMap);
+                    if (!rowRes.error) {
+                        syncedNow.push(row.id);
+                        continue;
+                    }
+                    errorCount++;
+                    lastError = rowRes.error;
+                    const decision = await handleRowFailure(config, table, row, rowRes.error, supabase);
+                    if (decision !== "KEEP")
+                        continue;
+                    keep.push(row);
+                }
+                if (syncedNow.length)
+                    await markSynced(table, syncedNow);
+                pending = keep;
+                break;
             }
         }
         else {
@@ -119,7 +153,7 @@ async function uploadChunk(table, chunk, onPushToRemote) {
                 res = await rpcUpsertSingle({ table, row, supabase, existsMap });
             }
             else {
-                res = await singleUpsert(table, row, supabase);
+                res = await singleUpsert(table, row, supabase, existsMap);
             }
             if (!res.error) {
                 syncedNow.push(row.id);
@@ -137,10 +171,18 @@ async function uploadChunk(table, chunk, onPushToRemote) {
             await markSynced(table, syncedNow);
         if (keep.length === 0)
             return;
-        // Backoff before next batch round (exponential, bounded by policy)
-        attempts++;
-        await backoff(attempts);
-        pending = keep;
+        if (!(await isOnline())) {
+            attempts++;
+            await backoff(attempts);
+            pending = keep;
+        }
+        else {
+            // Online: errors are genuine failures, not network issues — don't retry
+            for (const r of keep)
+                setQueryStatus(r.id, table, "error");
+            pending = keep; // update pending so post-loop markLogError reflects only true failures
+            break;
+        }
     }
     if (pending.length > 0) {
         SyncInfoUpdater.markLogError({

package/dist/native/utils/sync/pushLocal/uploadHelpers.d.ts

@@ -2,7 +2,7 @@ import { SupastashConfig } from "../../../../shared/types/supastashConfig.types"
 import { RowLike } from "../../../../shared/types/syncEngine.types";
 export declare function classifyFailure(cfg: SupastashConfig<any>, code?: string | number): "HTTP" | "UNKNOWN" | "NON_RETRYABLE" | "FK_BLOCK" | "UNIQUE_VIOLATION" | "RETRYABLE";
 declare function batchUpsert(table: string, rows: RowLike[], supabase: any): Promise<any>;
-declare function singleUpsert(table: string, row: RowLike, supabase: any): Promise<any>;
+declare function singleUpsert(table: string, row: RowLike, supabase: any, existsMap?: Map<string, boolean>): Promise<any>;
 declare function backoff(attempts: number): Promise<void>;
 declare function rpcUpsert({ table, rows, supabase, }: {
     table: string;

package/dist/native/utils/sync/pushLocal/uploadHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uploadHelpers.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/pushLocal/uploadHelpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,gDAAgD,CAAC;AACjF,OAAO,EAAE,OAAO,EAAE,MAAM,2CAA2C,CAAC;AAOpE,wBAAgB,eAAe,CAC7B,GAAG,EAAE,eAAe,CAAC,GAAG,CAAC,EACzB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,wFAYvB;AAED,iBAAe,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,GAAG,gBAEvE;AAED,iBAAe,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,gBAErE;AAED,iBAAe,OAAO,CAAC,QAAQ,EAAE,MAAM,iBAOtC;AAmBD,iBAAe,SAAS,CAAC,EACvB,KAAK,EACL,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,QAAQ,EAAE,GAAG,CAAC;CACf;;;;;;;GA+CA;AAED,iBAAe,eAAe,CAAC,EAC7B,KAAK,EACL,GAAG,EACH,QAAQ,EACR,SAAS,GACV,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;IACb,QAAQ,EAAE,GAAG,CAAC;IACd,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;;;;;;GAaA;AAMD,iBAAe,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,iBAIrD;AAWD,iBAAS,qBAAqB,CAC5B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,EAAE,EAChB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,aAiCjC;AAMD,iBAAe,gBAAgB,CAC7B,GAAG,EAAE,eAAe,CAAC,GAAG,CAAC,EACzB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,GAAG,GACZ,OAAO,CAAC,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC,CA4DvC;AAgBD,OAAO,EACL,OAAO,EACP,WAAW,EACX,qBAAqB,EACrB,gBAAgB,EAChB,UAAU,EACV,SAAS,EACT,eAAe,EACf,YAAY,GACb,CAAC;AAEF;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,GAAG,iBAkBd;AASD,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EAAE,EACb,QAAQ,EAAE,GAAG,gCAcd"}
+{"version":3,"file":"uploadHelpers.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/pushLocal/uploadHelpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,gDAAgD,CAAC;AACjF,OAAO,EAAE,OAAO,EAAE,MAAM,2CAA2C,CAAC;AAOpE,wBAAgB,eAAe,CAC7B,GAAG,EAAE,eAAe,CAAC,GAAG,CAAC,EACzB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,wFAYvB;AAED,iBAAe,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,GAAG,gBAEvE;AAED,iBAAe,YAAY,CACzB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,GAAG,EACb,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,gBAwBjC;AAED,iBAAe,OAAO,CAAC,QAAQ,EAAE,MAAM,iBAOtC;AAmBD,iBAAe,SAAS,CAAC,EACvB,KAAK,EACL,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,QAAQ,EAAE,GAAG,CAAC;CACf;;;;;;;GA+CA;AAED,iBAAe,eAAe,CAAC,EAC7B,KAAK,EACL,GAAG,EACH,QAAQ,EACR,SAAS,GACV,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;IACb,QAAQ,EAAE,GAAG,CAAC;IACd,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;;;;;;GAaA;AAMD,iBAAe,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,iBAIrD;AAWD,iBAAS,qBAAqB,CAC5B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,EAAE,EAChB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,aAiCjC;AAMD,iBAAe,gBAAgB,CAC7B,GAAG,EAAE,eAAe,CAAC,GAAG,CAAC,EACzB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,GAAG,GACZ,OAAO,CAAC,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC,CA4DvC;AAgBD,OAAO,EACL,OAAO,EACP,WAAW,EACX,qBAAqB,EACrB,gBAAgB,EAChB,UAAU,EACV,SAAS,EACT,eAAe,EACf,YAAY,GACb,CAAC;AAEF;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,GAAG,iBAkBd;AASD,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EAAE,EACb,QAAQ,EAAE,GAAG,gCAcd"}

package/dist/native/utils/sync/pushLocal/uploadHelpers.js

@@ -26,8 +26,30 @@ export function classifyFailure(cfg, code) {
 async function batchUpsert(table, rows, supabase) {
     return await supabase.from(table).upsert(rows);
 }
-async function singleUpsert(table, row, supabase) {
-    return await supabase.from(table).upsert(row).select("id").maybeSingle();
+async function singleUpsert(table, row, supabase, existsMap) {
+    const exists = existsMap?.get(row.id);
+    if (exists === true) {
+        const { data, error } = await supabase
+            .from(table)
+            .update(row)
+            .eq("id", row.id)
+            .select("id")
+            .maybeSingle();
+        if (!error)
+            return { data, error: null };
+        // RLS may block update — fall through to upsert
+    }
+    else if (exists === false) {
+        const { data, error } = await supabase
+            .from(table)
+            .insert(row)
+            .select("id")
+            .maybeSingle();
+        if (!error)
+            return { data, error: null };
+        // RLS may block insert — fall through to upsert
+    }
+    return supabase.from(table).upsert(row).select("id").maybeSingle();
 }
 async function backoff(attempts) {
     const config = getSupastashConfig();

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/shared/core/config/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC3B,MAAM,mCAAmC,CAAC;AAmC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,0BAA0B,EACrE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG;IAAE,gBAAgB,EAAE,CAAC,CAAA;CAAE,QAwCrD;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/shared/core/config/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC3B,MAAM,mCAAmC,CAAC;AAqC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,0BAA0B,EACrE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG;IAAE,gBAAgB,EAAE,CAAC,CAAA;CAAE,QAwCrD;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/shared/core/config/index.js

@@ -16,6 +16,8 @@ let _config = {
     },
     platform: "native",
     replicationMode: "client-side",
+    useBatchPullSync: false,
+    useBatchSchemaFetch: false,
     hasEnabledSimpleNullHandling: false,
     maxSyncLookbackDays: 365,
     perTableSyncLookbackDays: undefined,

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

@@ -1,4 +1,5 @@
 import { SupastashFilter } from "../../types/realtimeData.types";
+import { RpcTableFilters } from "../../types/rpcFilter.types";
 /**
  * useSupastashFilters
  *
@@ -26,11 +27,15 @@ import { SupastashFilter } from "../../types/realtimeData.types";
  * });
  * ```
  *
- * @param {SupastashFilter} filters - An object where each key is a table name, and its value is
- *   an array of `SupastashFilter` objects that define the filter criteria for that table's pull sync.
+ * @param {Record<string, SupastashFilter[]>} filters - Per-table filters applied to both the
+ *   per-table pull path and (automatically converted) the batch RPC pull path.
+ *   Covers eq, neq, gt, gte, lt, lte, in, is (null / not-null), and or-groups.
+ * @param {RpcTableFilters} rpcFilters - Optional supplemental RPC filter nodes for the batch
+ *   pull path only. Only needed when you require `and` groups, which `SupastashFilter` doesn't
+ *   support. These are merged with the auto-converted `filters` before the RPC call.
  *
- * @note This hook does not re-run unless the `filters` object reference changes.
+ * @note This hook does not re-run unless the `filters` or `rpcFilters` object reference changes.
  *       To force re-evaluation, pass a fresh object (not just mutated data).
  */
-export declare function useSupastashFilters(filters?: Record<string, SupastashFilter[]>): void;
+export declare function useSupastashFilters(filters?: Record<string, SupastashFilter[]>, rpcFilters?: RpcTableFilters): void;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/shared/hooks/supastashFilters/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAMjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,QAyD5C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/shared/hooks/supastashFilters/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAO9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,EAC3C,UAAU,CAAC,EAAE,eAAe,QA6D7B"}

package/dist/shared/hooks/supastashFilters/index.js

@@ -2,6 +2,7 @@ import { useEffect } from "react";
 import { filterTracker, tableFilters, tableFiltersUsed, } from "../../store/tableFilters";
 import { logWarn } from "../../utils/logs";
 import { ReusedHelpers } from "../../utils/reusedHelpers";
+import { updateRpcFilters } from "../../utils/sync/pullFromRemote/updateRpcFilters";
 import { warnOnMisMatch } from "../../utils/sync/pullFromRemote/validateFilters";
 import { checkIfTableExist } from "../../utils/tableValidator";
 /**
@@ -31,16 +32,23 @@ import { checkIfTableExist } from "../../utils/tableValidator";
  * });
  * ```
  *
- * @param {SupastashFilter} filters - An object where each key is a table name, and its value is
- *   an array of `SupastashFilter` objects that define the filter criteria for that table's pull sync.
+ * @param {Record<string, SupastashFilter[]>} filters - Per-table filters applied to both the
+ *   per-table pull path and (automatically converted) the batch RPC pull path.
+ *   Covers eq, neq, gt, gte, lt, lte, in, is (null / not-null), and or-groups.
+ * @param {RpcTableFilters} rpcFilters - Optional supplemental RPC filter nodes for the batch
+ *   pull path only. Only needed when you require `and` groups, which `SupastashFilter` doesn't
+ *   support. These are merged with the auto-converted `filters` before the RPC call.
  *
- * @note This hook does not re-run unless the `filters` object reference changes.
+ * @note This hook does not re-run unless the `filters` or `rpcFilters` object reference changes.
  *       To force re-evaluation, pass a fresh object (not just mutated data).
  */
-export function useSupastashFilters(filters) {
+export function useSupastashFilters(filters, rpcFilters) {
     useEffect(() => {
         let cancelled = false;
         async function run() {
+            if (rpcFilters) {
+                await updateRpcFilters(rpcFilters);
+            }
             if (!filters)
                 return;
             const incoming = Object.keys(filters);
@@ -82,5 +90,5 @@ export function useSupastashFilters(filters) {
         return () => {
             cancelled = true;
         };
-    }, [filters]);
+    }, [filters, rpcFilters]);
 }

package/dist/shared/store/rpcTableFilters.d.ts

@@ -0,0 +1,7 @@
+import { RpcFilterNode } from "../types/rpcFilter.types";
+/**
+ * Stores per-table RPC filter nodes used by the batch pull sync path.
+ * Keyed by table name, value is the array of RpcFilterNode to apply.
+ */
+export declare const rpcTableFilters: Map<string, RpcFilterNode[]>;
+//# sourceMappingURL=rpcTableFilters.d.ts.map

package/dist/shared/store/rpcTableFilters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpcTableFilters.d.ts","sourceRoot":"","sources":["../../../src/shared/store/rpcTableFilters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEzD;;;GAGG;AACH,eAAO,MAAM,eAAe,8BAAqC,CAAC"}

package/dist/shared/store/rpcTableFilters.js

@@ -0,0 +1,5 @@
+/**
+ * Stores per-table RPC filter nodes used by the batch pull sync path.
+ * Keyed by table name, value is the array of RpcFilterNode to apply.
+ */
+export const rpcTableFilters = new Map();

package/dist/shared/types/rpcFilter.types.d.ts

@@ -0,0 +1,23 @@
+export type RpcFilterOp =
+  | "eq"
+  | "neq"
+  | "gt"
+  | "gte"
+  | "lt"
+  | "lte"
+  | "in"
+  | "is_null"
+  | "is_not_null";
+
+export type RpcSimpleFilter = {
+  col: string;
+  op: RpcFilterOp;
+  val?: string | number;
+};
+
+export type RpcFilterNode =
+  | RpcSimpleFilter
+  | { or: RpcFilterNode[] }
+  | { and: RpcFilterNode[] };
+
+export type RpcTableFilters = Record<string, RpcFilterNode[]>;

package/dist/shared/types/supastashConfig.types.d.ts

@@ -89,12 +89,12 @@ export type SupastashConfig<T extends SupastashSQLiteClientTypes> = {
   sqliteClient: T extends "expo"
     ? ExpoSQLiteClient
     : T extends "rn-storage"
-    ? RNStorageSQLiteClient
-    : T extends "rn-nitro"
-    ? RNSqliteNitroClient
-    : T extends "tauri"
-    ? TauriSQLiteClient
-    : null;
+      ? RNStorageSQLiteClient
+      : T extends "rn-nitro"
+        ? RNSqliteNitroClient
+        : T extends "tauri"
+          ? TauriSQLiteClient
+          : null;
 
   /**
    * Runtime platform.
@@ -319,6 +319,34 @@ export type SupastashConfig<T extends SupastashSQLiteClientTypes> = {
    * Supastash docs: https://0xzekea.github.io/supastash/docs/sync-calls#%EF%B8%8F-pushrpcpath-custom-batch-sync-rpc
    */
   pushRPCPath?: string;
+  /**
+   * When true, pull sync uses a single `supastash_pull_sync` RPC call to fetch
+   * all tables in one round trip instead of per-table queries.
+   *
+   * The RPC handles pagination internally via `remaining_tables` — Supastash
+   * will keep calling until all tables are fully synced.
+   *
+   * Use `updateRpcFilters` to set per-table filters for this mode.
+   *
+   * ⚠️ Requires the `supastash_pull_sync` Postgres function to be deployed
+   * and RLS to be enabled on every table you expose.
+   *
+   * @default false
+   */
+  useBatchPullSync?: boolean;
+  /**
+   * When true, Supastash fetches column metadata for all tables in a single
+   * `get_table_schemas` RPC call at the start of each sync cycle instead of
+   * calling `get_table_schema` once per table on demand.
+   *
+   * Warms the in-memory and SQLite schema caches up front so every subsequent
+   * per-table lookup is served from cache with zero extra network calls.
+   *
+   * Requires the `get_table_schemas` Postgres function to be deployed.
+   *
+   * @default false
+   */
+  useBatchSchemaFetch?: boolean;
   /**
    * Controls how Supastash operates at runtime.
    *
@@ -443,7 +471,7 @@ export interface SupastashSQLiteExecutor {
    */
   queryOne<T = any>(
     sql: string,
-    params?: Record<string, any>
+    params?: Record<string, any>,
   ): Promise<T | null>;
   /**
    * Executes a write or mutation statement.
@@ -500,14 +528,14 @@ export interface SupastashSQLiteDatabase extends SupastashSQLiteExecutor {
    * @returns A Promise that resolves when the transaction is complete
    */
   withTransaction(
-    fn: (tx: SupastashSQLiteExecutor) => Promise<void> | void
+    fn: (tx: SupastashSQLiteExecutor) => Promise<void> | void,
   ): Promise<void>;
 }
 
 export interface SupastashSQLiteAdapter<TClient = any> {
   openDatabaseAsync(
     name: string,
-    sqliteClient: TClient
+    sqliteClient: TClient,
   ): Promise<SupastashSQLiteDatabase>;
 }
 
@@ -515,7 +543,7 @@ export interface ExpoSQLiteClient {
   openDatabaseAsync: (
     databaseName: string,
     options?: SQLiteOpenOptions | undefined,
-    directory?: string | undefined
+    directory?: string | undefined,
   ) => Promise<ExpoSQLiteDatabase>;
 }
 

package/dist/shared/utils/schema/createSyncStatus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createSyncStatus.d.ts","sourceRoot":"","sources":["../../../../src/shared/utils/schema/createSyncStatus.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wBAAsB,wBAAwB,kBAE7C;AAED,eAAO,MAAM,sBAAsB,0ZAUhC,CAAC;AAEJ,eAAO,MAAM,6BAA6B,6eAezC,CAAC;AAEF,eAAO,MAAM,wBAAwB,mFAEpC,CAAC;AAEF,eAAO,MAAM,oBAAoB,2GAGhC,CAAC;AAEF,eAAO,MAAM,2BAA2B,yHAGvC,CAAC;AAIF;;;;GAIG;AACH,wBAAsB,qBAAqB,kBAuB1C;AAED,wEAAwE;AACxE,wBAAgB,yBAAyB,SAExC"}
+{"version":3,"file":"createSyncStatus.d.ts","sourceRoot":"","sources":["../../../../src/shared/utils/schema/createSyncStatus.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wBAAsB,wBAAwB,kBAE7C;AAED,eAAO,MAAM,sBAAsB,0ZAUhC,CAAC;AAEJ,eAAO,MAAM,6BAA6B,6eAezC,CAAC;AAEF,eAAO,MAAM,wBAAwB,mFAEpC,CAAC;AAEF,eAAO,MAAM,oBAAoB,2GAGhC,CAAC;AAEF,eAAO,MAAM,2BAA2B,yHAGvC,CAAC;AAIF;;;;GAIG;AACH,wBAAsB,qBAAqB,kBAiC1C;AAED,wEAAwE;AACxE,wBAAgB,yBAAyB,SAExC"}

package/dist/shared/utils/schema/createSyncStatus.js

@@ -68,7 +68,11 @@ export async function createSyncStatusTable() {
             await db.execAsync(INDEX_SYNC_MARKS_SQL);
         }
         try {
-            await db.execAsync(ADD_PK_TO_SYNC_MARKS_SQL);
+            const columns = await db.getAllAsync(`SELECT name FROM pragma_table_info('supastash_sync_marks')`);
+            const hasColumn = columns.some((column) => column.name === "last_synced_at_pk");
+            if (!hasColumn) {
+                await db.execAsync(ADD_PK_TO_SYNC_MARKS_SQL);
+            }
         }
         catch {
             // Ignore — column already exists

package/dist/shared/utils/sync/pullFromRemote/postgrestToRpc.d.ts

@@ -0,0 +1,9 @@
+import { SupastashFilter } from "../../../types/realtimeData.types";
+import { RpcFilterNode } from "../../../types/rpcFilter.types";
+/**
+ * Converts PostgREST-style SupastashFilter[] to RpcFilterNode[].
+ * Supports simple filters and { or: [...] } groups.
+ * Returns an empty array for an empty/undefined input.
+ */
+export declare function postgrestFiltersToRpc(filters: SupastashFilter[] | undefined): RpcFilterNode[];
+//# sourceMappingURL=postgrestToRpc.d.ts.map

package/dist/shared/utils/sync/pullFromRemote/postgrestToRpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgrestToRpc.d.ts","sourceRoot":"","sources":["../../../../../src/shared/utils/sync/pullFromRemote/postgrestToRpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAe,MAAM,gCAAgC,CAAC;AA+B5E;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,EAAE,GAAG,SAAS,GACrC,aAAa,EAAE,CAgBjB"}