supastash 0.2.0 → 0.2.2

package/dist/{utils → native/utils}/sync/pullFromRemote/updateLocalDb.js

@@ -1,21 +1,20 @@
-import { getSupastashConfig } from "../../../core/config";
-import { getSupastashDb } from "../../../db/dbInitializer";
-import { DEFAULT_RECEIVED_DATA_COMPLETED, RECEIVED_DATA_COMPLETED_MAP, } from "../../../store/syncStatus";
-import { isOnline } from "../../connection";
-import { generateUUIDv4 } from "../../genUUID";
-import { getTableSchema } from "../../getTableSchema";
-import log, { logError, logWarn } from "../../logs";
-import { refreshScreen } from "../../refreshScreenCalls";
-import { SyncInfoUpdater } from "../queryStatus";
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { getSupastashDb } from "../../../../shared/db/dbInitializer";
+import { DEFAULT_RECEIVED_DATA_COMPLETED, RECEIVED_DATA_COMPLETED_MAP, } from "../../../../shared/store/syncStatus";
+import { generateUUIDv4 } from "../../../../shared/utils/genUUID";
+import { getTableSchema } from "../../../../shared/utils/getTableSchema";
+import log, { logError, logWarn } from "../../../../shared/utils/logs";
+import { refreshScreen } from "../../../../shared/utils/refreshScreenCalls";
+import { deleteReceivedDataCompleted } from "../../../../shared/utils/sync/pullFromRemote/helpers";
+import { stringifyValue } from "../../../../shared/utils/sync/pullFromRemote/stringifyFields";
+import { SyncInfoUpdater } from "../../../../shared/utils/sync/queryStatus";
+import { updateLocalSyncedAt } from "../../../../shared/utils/sync/status/syncUpdate";
 import { setSupastashSyncStatus } from "../status/services";
-import { updateLocalSyncedAt } from "../status/syncUpdate";
-import { deleteReceivedDataCompleted } from "./helpers";
 import { pullData } from "./pullData";
-import { stringifyValue } from "./stringifyFields";
 let isInSync = new Map();
 const DEFAULT_DATE = "1970-01-01T00:00:00Z";
 const BATCH_SIZE = 500;
-const DELETE_CHUNK = 999;
+const CHUNK_SIZE = 999;
 /**
  * Updates the local database with the remote changes
  * @param table - The table to update
@@ -26,8 +25,6 @@ export async function updateLocalDb(table, filters, onReceiveData) {
     const cfg = getSupastashConfig();
     if (cfg.supastashMode === "ghost")
         return;
-    if (!(await isOnline()))
-        return;
     isInSync.set(table, true);
     const batchId = generateUUIDv4();
     try {
@@ -61,8 +58,8 @@ export async function updateLocalDb(table, filters, onReceiveData) {
             await db.withTransaction(async (tx) => {
                 if (deletedIds && deletedIds.length > 0) {
                     const ids = deletedIds;
-                    for (let i = 0; i < ids.length; i += DELETE_CHUNK) {
-                        const slice = ids.slice(i, i + DELETE_CHUNK);
+                    for (let i = 0; i < ids.length; i += CHUNK_SIZE) {
+                        const slice = ids.slice(i, i + CHUNK_SIZE);
                         const placeholders = slice.map(() => "?").join(", ");
                         await tx.runAsync(`DELETE FROM ${table} WHERE id IN (${placeholders})`, slice);
                     }
@@ -71,8 +68,8 @@ export async function updateLocalDb(table, filters, onReceiveData) {
                 let localStamp = new Map();
                 if (data?.length) {
                     const ids = data.map((r) => r.id).filter(Boolean);
-                    for (let i = 0; i < ids.length; i += DELETE_CHUNK) {
-                        const slice = ids.slice(i, i + DELETE_CHUNK);
+                    for (let i = 0; i < ids.length; i += CHUNK_SIZE) {
+                        const slice = ids.slice(i, i + CHUNK_SIZE);
                         const placeholders = slice.map(() => "?").join(", ");
                         const rows = await db.getAllAsync(`SELECT id, updated_at FROM ${table} WHERE id IN (${placeholders})`, slice);
                         for (const row of rows ?? []) {
@@ -82,33 +79,11 @@ export async function updateLocalDb(table, filters, onReceiveData) {
                 }
                 // Update local database with remote changes
                 if (data?.length) {
-                    for (let i = 0; i < data.length; i++) {
-                        const record = data[i];
-                        if (!record?.id)
-                            continue;
-                        if (deletedIdSet.has(record.id))
-                            continue;
-                        const localUpdated = localStamp.get(record.id) ?? DEFAULT_DATE;
-                        const remoteUpdated = record.updated_at ?? DEFAULT_DATE;
-                        if (new Date(localUpdated) >= new Date(remoteUpdated)) {
-                            // local is newer or same — skip
-                            continue;
-                        }
-                        if (onReceiveData) {
-                            await onReceiveData(record);
-                        }
-                        else {
-                            await upsertData({
-                                tx,
-                                table,
-                                record,
-                                doesExist: localStamp.has(record.id),
-                            });
-                        }
-                        if ((i + 1) % BATCH_SIZE === 0) {
-                            await new Promise((res) => setTimeout(res, 0));
-                        }
-                    }
+                    await upsertChunkData({
+                        tx,
+                        table,
+                        records: data,
+                    });
                 }
             });
             if (timestamps) {
@@ -161,7 +136,7 @@ export async function upsertData({ tx, table, record, doesExist, }) {
             ...record,
             synced_at: new Date().toISOString(),
         };
-        if (__DEV__ && getSupastashConfig().debugMode) {
+        if (getSupastashConfig().debugMode) {
             const unknownKeys = Object.keys(record).filter((key) => !columns.includes(key));
             if (unknownKeys.length > 0 && !warned.get(table)) {
                 warned.set(table, true);
@@ -190,6 +165,104 @@ export async function upsertData({ tx, table, record, doesExist, }) {
         logError(`[Supastash] Error upserting data for ${table}`, error);
     }
 }
+/**
+    •	Bulk upserts records into a local SQLite table using a batched, conflict-aware strategy.
+    •
+    •	This function:
+    •		•	Fetches existing id and updated_at values in bulk to avoid per-row queries
+    •		•	Filters incoming records to only include new or more recent entries
+    •		•	Performs batched INSERT ... ON CONFLICT(id) DO UPDATE operations
+    •	while respecting SQLite parameter limits
+    •		•	Updates synced_at for successfully written records
+    •
+    •	Designed for high-performance sync scenarios in offline-first apps.
+    •
+    •	Key guarantees:
+    •		•	Avoids N+1 query patterns (no per-row existence checks)
+    •		•	Minimizes disk I/O pressure via batching
+    •		•	Safe for large datasets when used with chunking
+    •
+    •	Notes:
+    •		•	Assumes id is the primary or unique key
+    •		•	Requires updated_at for conflict resolution (falls back if missing)
+    •		•	Respects SQLite parameter limit (~999 variables per query)
+    •
+    •	@param tx Optional transaction instance. If not provided, a connection is used directly.
+    •	@param table Target table name
+    •	@param records Array of records to upsert
+*/
+export async function upsertChunkData({ tx, table, records, }) {
+    if (!records?.length)
+        return;
+    const cfg = getSupastashConfig();
+    if (cfg.supastashMode === "ghost")
+        return;
+    const db = tx ?? (await getSupastashDb());
+    const columns = await getTableSchema(table);
+    const syncedAt = new Date().toISOString();
+    if (cfg.debugMode) {
+        const unknownKeys = Object.keys(records[0]).filter((key) => !columns.includes(key));
+        if (unknownKeys.length > 0 && !warned.get(table)) {
+            warned.set(table, true);
+            logWarn(`⚠️ [Supastash] '${table}' payload contains keys not in local schema: ${unknownKeys.join(", ")}. ` + `They will be ignored locally.`);
+        }
+    }
+    // Step 1: Fetch existing id + updated_at for all incoming ids in bulk
+    const incomingIds = records.map((r) => r.id).filter(Boolean);
+    const localStamp = new Map();
+    for (let i = 0; i < incomingIds.length; i += CHUNK_SIZE) {
+        const slice = incomingIds.slice(i, i + CHUNK_SIZE);
+        const placeholders = slice.map(() => "?").join(", ");
+        const rows = await db.getAllAsync(`SELECT id, updated_at FROM ${table} WHERE id IN (${placeholders})`, slice);
+        for (const row of rows ?? []) {
+            localStamp.set(row.id, row.updated_at ?? null);
+        }
+    }
+    // Step 2: Keep only records that are new or have a newer remote updated_at
+    const toUpsert = records.filter((record) => {
+        if (!record?.id)
+            return false;
+        const localUpdated = localStamp.get(record.id) ?? DEFAULT_DATE;
+        const remoteUpdated = record.updated_at ?? DEFAULT_DATE;
+        return new Date(remoteUpdated) > new Date(localUpdated);
+    });
+    if (!toUpsert.length)
+        return;
+    // Step 3: Build INSERT … ON CONFLICT(id) DO UPDATE in param-limit-safe chunks
+    const colList = columns.join(", ");
+    const updateSet = columns
+        .filter((key) => key !== "id")
+        .map((key) => `${key} = excluded.${key}`)
+        .join(", ");
+    const paramsPerRow = columns.length;
+    const rowsPerChunk = Math.max(1, Math.floor(999 / paramsPerRow));
+    const successfulIds = [];
+    for (let i = 0; i < toUpsert.length; i += rowsPerChunk) {
+        const chunk = toUpsert.slice(i, i + rowsPerChunk);
+        const rowPlaceholders = chunk
+            .map(() => `(${columns.map(() => "?").join(", ")})`)
+            .join(", ");
+        const values = [];
+        for (const record of chunk) {
+            const recordToSave = { ...record, synced_at: syncedAt };
+            for (const col of columns) {
+                values.push(stringifyValue(recordToSave[col]));
+            }
+        }
+        try {
+            await db.runAsync(`INSERT INTO ${table} (${colList}) VALUES ${rowPlaceholders} ON CONFLICT(id) DO UPDATE SET ${updateSet}`, values);
+            for (const record of chunk) {
+                successfulIds.push(record.id);
+            }
+        }
+        catch (error) {
+            logError(`[Supastash] Error upserting chunk for ${table}`, error);
+        }
+    }
+    if (successfulIds.length) {
+        await updateLocalSyncedAt(table, successfulIds);
+    }
+}
 async function checkIfRecordExistsAndIsNewer(table, item) {
     if (!item?.id)
         return { doesExist: false, newer: false };

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

@@ -0,0 +1,5 @@
+/**
+ * Pushes the local data to the remote database
+ */
+export declare function pushLocalData(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,101 @@
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { syncCalls } from "../../../../shared/store/syncCalls";
+import log from "../../../../shared/utils/logs";
+import { getAllTables } from "../../../../shared/utils/sync/getAllTables";
+import { runLimitedConcurrency } from "../../../../shared/utils/sync/pullFromRemote/runLimitedConcurrency";
+import { SyncInfoUpdater } from "../../../../shared/utils/sync/queryStatus";
+import { pushLocalDataToRemote } from "./sendUnsyncedToSupabase";
+let emptyPassCount = 0;
+let lastEmptyPassAt = 0;
+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) {
+            log("[Supastash] No tables found");
+            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;
+            }
+            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?.message ?? 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);
+            }
+        });
+        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) {
+        log(`[Supastash] Error pushing local data to remote database: ${error}`);
+    }
+    finally {
+        SyncInfoUpdater.reset({ type: "push" });
+    }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Sends unsynced data to the remote database for a given table.
+ * Returns true if it pushed anything (creates/updates OR deletes), else false.
+ */
+export declare function pushLocalDataToRemote(table: string, onPushToRemote?: (payload: any[]) => Promise<boolean>, noSync?: string[]): Promise<boolean | undefined>;
+//# sourceMappingURL=sendUnsyncedToSupabase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sendUnsyncedToSupabase.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/pushLocal/sendUnsyncedToSupabase.ts"],"names":[],"mappings":"AAYA;;;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,gCA+ClB"}

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

@@ -0,0 +1,57 @@
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { refreshScreen } from "../../../../shared/utils/refreshScreenCalls";
+import { deleteData } from "../../../../shared/utils/sync/pushLocal/deleteChunks";
+import { getAllDeletedData, getAllUnsyncedData, } from "../../../../shared/utils/sync/pushLocal/getAllUnsyncedData";
+import { SyncInfoUpdater } from "../../../../shared/utils/sync/queryStatus";
+import { uploadData } from "./uploadChunk";
+let isInSync = new Map();
+/**
+ * Sends unsynced data to the remote database for a given table.
+ * Returns true if it pushed anything (creates/updates OR deletes), else false.
+ */
+export async function pushLocalDataToRemote(table, onPushToRemote, noSync) {
+    if (isInSync.get(table))
+        return;
+    const cfg = getSupastashConfig();
+    if (cfg.supastashMode === "ghost")
+        return false;
+    isInSync.set(table, true);
+    try {
+        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) {
+            noSync?.push?.(table);
+            return false;
+        }
+        let didWork = false;
+        if (hasData) {
+            await uploadData(table, data, onPushToRemote);
+            didWork = true;
+        }
+        if (hasDeletes) {
+            await deleteData(table, deletedData);
+            didWork = true;
+        }
+        if (didWork)
+            refreshScreen(table);
+        return didWork;
+    }
+    catch (error) {
+        throw error;
+    }
+    finally {
+        isInSync.delete(table);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { PayloadData } from "../../../../shared/types/query.types";
+/**
+ * Uploads a chunk of data to the remote database
+ * @param table - The table to upload to
+ * @param unsyncedRecords - The unsynced records to upload
+ */
+export declare function uploadData(table: string, unsyncedRecords: PayloadData[], onPushToRemote?: (payload: any[]) => Promise<boolean>): Promise<void>;
+//# sourceMappingURL=uploadChunk.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,173 @@
+import { DEFAULT_CHUNK_SIZE } from "../../../../shared/constants/syncDefaults";
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { isOnline } from "../../../../shared/utils/connection";
+import { normalizeForSupabase } from "../../../../shared/utils/getSafeValues";
+import log from "../../../../shared/utils/logs";
+import { supabaseClientErr } from "../../../../shared/utils/supabaseClientErr";
+import { enforceTimestamps } from "../../../../shared/utils/sync/pushLocal/normalize";
+import { setQueryStatus, SyncInfoUpdater, } from "../../../../shared/utils/sync/queryStatus";
+import { backoff, batchUpsert, fetchRemoteHeadsChunked, filterRowsByUpdatedAt, handleRowFailure, markSynced, rpcUpsert, rpcUpsertSingle, singleUpsert, } from "./uploadHelpers";
+/**
+ * Uploads a chunk of data to the remote database
+ *
+ * It will check if the data in the remote database is more recent than the data in the local database.
+ * If it is, it will skip it.
+ * If it is not, it will upsert it.
+ *
+ * @param table - The table to upload to
+ * @param chunk - The chunk of data to upload
+ */
+async function uploadChunk(table, chunk, onPushToRemote) {
+    const config = getSupastashConfig();
+    const supabase = config.supabaseClient;
+    if (!supabase) {
+        throw new Error(supabaseClientErr);
+    }
+    const online = await isOnline();
+    if (!online)
+        return;
+    let errorCount = 0;
+    let lastError = null;
+    let pending = [];
+    const hasRPCPath = !!config.pushRPCPath;
+    const ids = chunk.map((row) => row.id);
+    const toPush = [];
+    // If we have a RPC path, we can push the whole chunk. Server validates freshness.
+    if (hasRPCPath) {
+        toPush.push(...chunk);
+    }
+    else {
+        // Fetch remote data for the current chunk
+        const remoteIds = await fetchRemoteHeadsChunked(table, ids, supabase);
+        // Loop through the initial chunk and check if the id is in the remote data
+        const filtered = filterRowsByUpdatedAt(table, chunk, remoteIds);
+        toPush.push(...filtered);
+    }
+    if (toPush.length === 0)
+        return;
+    const preflightOK = [];
+    if (config.syncPolicy?.ensureParents) {
+        for (const r of toPush) {
+            try {
+                const status = await config.syncPolicy.ensureParents(table, r);
+                if (status === "blocked") {
+                    setQueryStatus(r.id, table, "error");
+                    continue;
+                }
+                preflightOK.push(r);
+            }
+            catch (e) {
+                setQueryStatus(r.id, table, "error");
+                log(`[Supastash] ensureParents failed for ${table}:${r.id}`, e);
+            }
+        }
+    }
+    else {
+        preflightOK.push(...toPush);
+    }
+    if (preflightOK.length === 0)
+        return;
+    pending.push(...preflightOK);
+    const maxBatchAttempts = config.syncPolicy?.maxBatchAttempts ?? 5;
+    let attempts = 0;
+    while (attempts < maxBatchAttempts && pending.length > 0) {
+        let batchOk = false;
+        // RPC return values
+        let completed = [];
+        let existsMap = new Map();
+        if (onPushToRemote) {
+            const ok = await onPushToRemote(pending);
+            if (ok)
+                batchOk = true;
+        }
+        else if (hasRPCPath) {
+            const res = await rpcUpsert({ table, rows: pending, supabase });
+            completed = res.data.completed;
+            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;
+            }
+        }
+        else {
+            const { error } = await batchUpsert(table, pending, supabase);
+            if (!error)
+                batchOk = true;
+        }
+        if (batchOk) {
+            await markSynced(table, pending.map((r) => r.id));
+            return;
+        }
+        if (completed.length > 0) {
+            await markSynced(table, completed.map((r) => r.id));
+        }
+        //Batch failed -> isolate per-row offenders
+        const keep = [];
+        const syncedNow = [];
+        for (const row of pending) {
+            let res = null;
+            if (onPushToRemote) {
+                const ok = await onPushToRemote([row]);
+                res = { error: ok ? null : { code: "ROW_FAILED" } };
+            }
+            else if (hasRPCPath) {
+                res = await rpcUpsertSingle({ table, row, supabase, existsMap });
+            }
+            else {
+                res = await singleUpsert(table, row, supabase);
+            }
+            if (!res.error) {
+                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;
+            }
+            keep.push(row); // retry later
+        }
+        if (syncedNow.length)
+            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 (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");
+}
+/**
+ * Uploads a chunk of data to the remote database
+ * @param table - The table to upload to
+ * @param unsyncedRecords - The unsynced records to upload
+ */
+export async function uploadData(table, unsyncedRecords, onPushToRemote) {
+    const cfg = getSupastashConfig();
+    const supabase = cfg.supabaseClient;
+    if (!supabase)
+        throw new Error("[Supastash] Supabase client not configured");
+    const cleaned = unsyncedRecords.map(({ synced_at, deleted_at, arrived_at, ...rest }) => enforceTimestamps(normalizeForSupabase(rest)));
+    for (let i = 0; i < cleaned.length; i += DEFAULT_CHUNK_SIZE) {
+        const chunk = cleaned.slice(i, i + DEFAULT_CHUNK_SIZE);
+        await uploadChunk(table, chunk, onPushToRemote);
+    }
+}

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

@@ -0,0 +1,41 @@
+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" | "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 backoff(attempts: number): Promise<void>;
+declare function rpcUpsert({ table, rows, supabase, }: {
+    table: string;
+    rows: RowLike[];
+    supabase: any;
+}): Promise<{
+    data: {
+        completed: RowLike[];
+        skipped: RowLike[];
+        existsMap: Map<string, boolean>;
+    };
+    error: any;
+}>;
+declare function rpcUpsertSingle({ table, row, supabase, existsMap, }: {
+    table: string;
+    row: RowLike;
+    supabase: any;
+    existsMap: Map<string, boolean>;
+}): Promise<{
+    data: null;
+    error: any;
+} | {
+    data: any;
+    error: null;
+}>;
+declare function markSynced(table: string, ids: string[]): Promise<void>;
+declare function filterRowsByUpdatedAt(table: string, chunk: RowLike[], remoteHeads: Map<string, string>): RowLike[];
+declare function handleRowFailure(cfg: SupastashConfig<any>, table: string, row: RowLike, err: any, supabase: any): Promise<"DROP" | "KEEP" | "REPLACED">;
+export { backoff, batchUpsert, filterRowsByUpdatedAt, handleRowFailure, markSynced, rpcUpsert, rpcUpsertSingle, singleUpsert, };
+/**
+ * Deletes local row and rewinds table watermark so normal pull will fetch server copy.
+ * No server read needed.
+ */
+export declare function rewindAndDropLocal(table: string, rowId: string, supabase: any): Promise<void>;
+export declare function fetchRemoteHeadsChunked(table: string, ids: string[], supabase: any): Promise<Map<string, string>>;
+//# sourceMappingURL=uploadHelpers.d.ts.map

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

@@ -0,0 +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,mEAWvB;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,CAkDvC;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"}