supastash 0.1.44 → 0.1.46

package/README.md

@@ -227,18 +227,6 @@ await supastash
 
 ---
 
-## 🗂 Recommended Project Structure
-
-```
-src/
-  ├─ core/         # Supastash config, Supabase client
-  ├─ hooks/        # useSupatashData, useSupastashFilters etc.
-  ├─ types/        # Zod schemas, DB types
-  ├─ utils/        # Local helpers
-```
-
----
-
 ## 🔧 API Docs
 
 - [`configureSupastash()`](https://0xzekea.github.io/supastash/docs/configuration)

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

@@ -1 +1 @@
-{"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"}
+{"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;AA2B3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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

@@ -19,6 +19,7 @@ let _config = {
     syncPolicy: DEFAULT_POLICY,
     fieldEnforcement: DEFAULT_FIELDS,
     deleteConflictedRows: false,
+    pushRPCPath: undefined,
 };
 let _configured = false;
 /**

package/dist/core/schemaManager/index.d.ts

@@ -6,6 +6,12 @@ import { LocalSchemaDefinition } from "../../types/schemaManager.types";
  * Intended for offline-first apps using Supastash. Ensures consistency in structure and indexing while
  * allowing runtime control of schema migration through `deletePreviousSchema`.
  *
+ * It will also create the following indexes:
+ * - synced_at
+ * - deleted_at
+ * - created_at
+ * - updated_at
+ * if they do not exist in the schema and if columns exist in the table.
  * ---
  *
  * @param tableName - The name of the local SQLite table.

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/schemaManager/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAIxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,qBAAqB,EAC7B,oBAAoB,UAAQ,iBAoF7B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/schemaManager/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAMxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,qBAAqB,EAC7B,oBAAoB,UAAQ,iBAyF7B"}

package/dist/core/schemaManager/index.js

@@ -1,6 +1,7 @@
 import { getSupastashDb } from "../../db/dbInitializer";
 import { clearSchemaCache } from "../../utils/getTableSchema";
 import log, { logError } from "../../utils/logs";
+import { resetSupastashSyncStatus } from "../../utils/sync/status/services";
 /**
  * 🧱 defineLocalSchema
  *
@@ -8,6 +9,12 @@ import log, { logError } from "../../utils/logs";
  * Intended for offline-first apps using Supastash. Ensures consistency in structure and indexing while
  * allowing runtime control of schema migration through `deletePreviousSchema`.
  *
+ * It will also create the following indexes:
+ * - synced_at
+ * - deleted_at
+ * - created_at
+ * - updated_at
+ * if they do not exist in the schema and if columns exist in the table.
  * ---
  *
  * @param tableName - The name of the local SQLite table.
@@ -57,12 +64,10 @@ export async function defineLocalSchema(tableName, schema, deletePreviousSchema
         const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${__constraints ? `${schemaString}, ${__constraints}` : schemaString});`;
         if (deletePreviousSchema) {
             const dropSql = `DROP TABLE IF EXISTS ${tableName}`;
-            const clearSyncStatusSql = `DELETE FROM supastash_sync_status WHERE table_name = '${tableName}'`;
-            const clearDeleteStatusSql = `DELETE FROM supastash_deleted_status WHERE table_name = '${tableName}'`;
-            const clearLastCreatedStatusSql = `DELETE FROM supastash_last_created WHERE table_name = '${tableName}'`;
             const tryDropTable = async (attempt = 1) => {
                 try {
                     await db.execAsync(dropSql);
+                    await resetSupastashSyncStatus(tableName, undefined, "all");
                 }
                 catch (err) {
                     if (String(err).includes("table is locked") && attempt < 5) {
@@ -73,23 +78,67 @@ export async function defineLocalSchema(tableName, schema, deletePreviousSchema
                 }
             };
             await tryDropTable();
-            await db.execAsync(clearSyncStatusSql);
-            await db.execAsync(clearDeleteStatusSql);
-            await db.execAsync(clearLastCreatedStatusSql);
             clearSchemaCache(tableName);
             log(`[Supastash] Dropped table ${tableName}`);
         }
         await db.execAsync(sql);
+        const standardIndexes = [
+            "synced_at",
+            "deleted_at",
+            "created_at",
+            "updated_at",
+        ];
         // Generate and create index SQL
         if (__indices?.length) {
             for (const col of __indices) {
+                if (standardIndexes.includes(col)) {
+                    continue;
+                }
                 const indexName = `idx_${tableName}_${col}`;
                 const indexSql = `CREATE INDEX IF NOT EXISTS ${indexName} ON ${tableName}(${col});`;
                 await db.execAsync(indexSql);
             }
         }
+        await createStandardIndexes(db, tableName, standardIndexes);
     }
     catch (error) {
         logError(`[Supastash] Error defining schema for table ${tableName}`, error);
     }
 }
+async function createStandardIndexes(db, table, columns) {
+    const pragmaRows = await db.getAllAsync(`PRAGMA table_info(${table});`);
+    const existingCols = Array.isArray(pragmaRows)
+        ? pragmaRows.map((r) => r.name)
+        : [];
+    await db.execAsync("BEGIN");
+    try {
+        for (const col of columns) {
+            if (existingCols.includes(col)) {
+                const hasSameIndex = await hasSingleColumnIndex(db, table, col);
+                if (!hasSameIndex) {
+                    await db.execAsync(`CREATE INDEX IF NOT EXISTS idx_${table}_${col} ON ${table}(${col});`);
+                }
+            }
+        }
+        await db.execAsync("COMMIT");
+    }
+    catch (error) {
+        await db.execAsync("ROLLBACK");
+        logError(`[Supastash] Error creating standard indexes for ${table}`, error);
+    }
+}
+async function hasSingleColumnIndex(db, table, col) {
+    const idxList = await db.getAllAsync(`PRAGMA index_list(${table});`);
+    if (!Array.isArray(idxList))
+        return false;
+    for (const idx of idxList) {
+        const idxName = idx.name;
+        const info = await db.getAllAsync(`PRAGMA index_info(${idxName});`);
+        if (!Array.isArray(info))
+            continue;
+        // Single-column index exactly on `col`
+        if (info.length === 1 && info[0]?.name === col)
+            return true;
+    }
+    return false;
+}

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

@@ -38,7 +38,39 @@ export type SupastashConfig<T extends SupastashSQLiteClientTypes> = {
   syncPolicy?: SupastashSyncPolicy;
   fieldEnforcement?: FieldEnforcement;
   deleteConflictedRows?: boolean;
-  useCustomRPCForUpserts?: boolean;
+  /**
+   * The path to the RPC function to use for upserts.
+   * If not provided, Supastash will use the default upsert logic.
+   *
+   * The RPC function should be defined as follows:
+   * @example
+   * await supabase.rpc('push_rpc_path', {
+   *   target_table: 'users',
+   *   payload: [{ id: '1', name: 'John Doe' }],
+   *   columns: ['id', 'name'],
+   * });
+   *
+   * ⚠️ Important:
+   * Your RPC must verify data freshness before updating.
+   * Always ensure local.updated_at > remote.updated_at before performing an update to prevent overwriting newer server data.
+   *
+   * ⚠️ Return Structure:
+   * Your RPC must return an array of objects with the following shape:
+   *
+   * {
+   *   id: string;             // UUID of the row
+   *   action: "updated" | "inserted" | "skipped";
+   *   reason?: string | null; // Optional reason, e.g. "stale_remote", "conflict_or_unauthorized"
+   *   record_exists: boolean;        // Whether the row already exists remotely
+   * }
+   *
+   * Supastash uses this structure to reconcile local states and decide whether to retry, re-insert, or refresh each row.
+   * It's advisable to use the recommended structure from the docs: https://0xzekea.github.io/supastash/docs/sync-calls#%EF%B8%8F-pushrpcpath-custom-batch-sync-rpc
+   *
+   * @example
+   * Supastash docs: https://0xzekea.github.io/supastash/docs/sync-calls#%EF%B8%8F-pushrpcpath-custom-batch-sync-rpc
+   */
+  pushRPCPath?: string;
 };
 
 interface SupastashSQLiteDatabase {

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

@@ -1 +1 @@
-{"version":3,"file":"getAllUnsyncedData.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/getAllUnsyncedData.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAqEzD;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,CAe/B;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,CAM/B"}
+{"version":3,"file":"getAllUnsyncedData.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/getAllUnsyncedData.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAsEzD;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,CAe/B;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,CAM/B"}

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

@@ -23,7 +23,8 @@ async function getRemoteKeys(table) {
             table_name: table,
         });
         if (error) {
-            log(`[Supastash] Error getting remote keys for table ${table} on public schema: ${error.message}`);
+            log(`[Supastash] Error getting remote keys for table ${table} on public schema: ${error.message}
+        You can find more information in the Supastash docs: https://0xzekea.github.io/supastash/docs/getting-started#%EF%B8%8F-server-side-setup-for-filtered-pulls`);
             numberOfErrors.set(table, (numberOfErrors.get(table) || 0) + 1);
             return null;
         }

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

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

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

@@ -6,7 +6,7 @@ import log from "../../logs";
 import { supabaseClientErr } from "../../supabaseClientErr";
 import { setQueryStatus, SyncInfoUpdater } from "../queryStatus";
 import { enforceTimestamps } from "./normalize";
-import { batchUpsert, fetchRemoteHeadsChunked, filterRowsByUpdatedAt, handleRowFailure, markSynced, singleUpsert, } from "./uploadHelpers";
+import { backoff, batchUpsert, fetchRemoteHeadsChunked, filterRowsByUpdatedAt, handleRowFailure, markSynced, rpcUpsert, rpcUpsertSingle, singleUpsert, } from "./uploadHelpers";
 /**
  * Uploads a chunk of data to the remote database
  *
@@ -28,11 +28,21 @@ async function uploadChunk(table, chunk, onPushToRemote) {
         return;
     let errorCount = 0;
     let lastError = null;
+    let pending = [];
+    const hasRPCPath = !!config.pushRPCPath;
     const ids = chunk.map((row) => row.id);
-    // 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 toPush = filterRowsByUpdatedAt(table, chunk, remoteIds);
+    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 = [];
@@ -57,16 +67,33 @@ async function uploadChunk(table, chunk, onPushToRemote) {
     }
     if (preflightOK.length === 0)
         return;
+    pending.push(...preflightOK);
     const maxBatchAttempts = config.syncPolicy?.maxBatchAttempts ?? 5;
     let attempts = 0;
-    let pending = [...preflightOK];
     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)
@@ -76,16 +103,24 @@ async function uploadChunk(table, chunk, onPushToRemote) {
             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) {
-            const res = onPushToRemote
-                ? await (async () => {
-                    const ok = await onPushToRemote([row]);
-                    return { error: ok ? null : { code: "ROW_FAILED" } };
-                })()
-                : await singleUpsert(table, row, supabase);
+            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;
@@ -104,11 +139,7 @@ async function uploadChunk(table, chunk, onPushToRemote) {
             return;
         // Backoff before next batch round (exponential, bounded by policy)
         attempts++;
-        const schedule = config.syncPolicy?.backoffDelaysMs ?? [
-            10000, 30000, 120000, 300000, 600000,
-        ];
-        const delay = schedule[Math.min(attempts - 1, schedule.length - 1)];
-        await new Promise((r) => setTimeout(r, delay));
+        await backoff(attempts);
         pending = keep;
     }
     if (pending.length > 0) {

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

@@ -3,14 +3,39 @@ import { RowLike } from "../../../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 { batchUpsert, filterRowsByUpdatedAt, handleRowFailure, markSynced, singleUpsert, };
+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): Promise<void>;
+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/utils/sync/pushLocal/uploadHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uploadHelpers.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/uploadHelpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAS1D,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,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,CA0DvC;AAgBD,OAAO,EACL,WAAW,EACX,qBAAqB,EACrB,gBAAgB,EAChB,UAAU,EACV,YAAY,GACb,CAAC;AAEF;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,iBAUpE;AAsBD,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/utils/sync/pushLocal/uploadHelpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAO1D,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"}

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

@@ -2,10 +2,9 @@ import { getSupastashConfig } from "../../../core/config";
 import { getSupastashDb } from "../../../db/dbInitializer";
 import { supastashEventBus } from "../../../utils/events/eventBus";
 import log, { logWarn } from "../../../utils/logs";
+import { upsertData } from "../pullFromRemote/updateLocalDb";
 import { setQueryStatus } from "../queryStatus";
 import { updateLocalSyncedAt } from "../status/syncUpdate";
-const DEFAULT_REWIND_MS = 60 * 60 * 1000; // 1 hour
-const MAX_REWIND_BACKSTOP_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
 export function classifyFailure(cfg, code) {
     const p = cfg.syncPolicy ?? {};
     const n = Number(code);
@@ -28,6 +27,14 @@ async function batchUpsert(table, rows, supabase) {
 async function singleUpsert(table, row, supabase) {
     return await supabase.from(table).upsert(row).select("id").maybeSingle();
 }
+async function backoff(attempts) {
+    const config = getSupastashConfig();
+    const schedule = config.syncPolicy?.backoffDelaysMs ?? [
+        10000, 30000, 120000, 300000, 600000,
+    ];
+    const delay = schedule[Math.min(attempts - 1, schedule.length - 1)];
+    await new Promise((r) => setTimeout(r, delay));
+}
 async function fetchServerRowById(table, id, supabase) {
     const { data } = await supabase
         .from(table)
@@ -36,6 +43,72 @@ async function fetchServerRowById(table, id, supabase) {
         .maybeSingle();
     return data ?? null;
 }
+/* ────────────────────────────────────────────────────────────────────────── *
+ * RPC Upsert
+ * ────────────────────────────────────────────────────────────────────────── */
+function setPending(table, rows) {
+    for (const row of rows) {
+        setQueryStatus(row.id, table, "pending");
+    }
+}
+async function rpcUpsert({ table, rows, supabase, }) {
+    const cfg = getSupastashConfig();
+    if (!cfg.pushRPCPath) {
+        throw new Error("pushRPCPath is not configured. Please configure it in the Supastash config. You can find more information in the Supastash docs: https://0xzekea.github.io/supastash/docs/sync-calls#%EF%B8%8F-pushrpcpath-custom-batch-sync-rpc");
+    }
+    setPending(table, rows);
+    const columns = Object.keys(rows[0]);
+    const { data, error } = await supabase.rpc(cfg.pushRPCPath, {
+        target_table: table,
+        payload: rows,
+        columns,
+    });
+    const mappedRows = new Map();
+    for (const row of rows) {
+        mappedRows.set(row.id, row);
+    }
+    const skipped = [];
+    const completed = [];
+    const existsMap = new Map();
+    for (const row of data ?? []) {
+        if (row.action === "skipped") {
+            if (row.reason === "stale_remote") {
+                void acceptServerAndStopRetrying(table, row.id);
+                continue;
+            }
+            const localRow = mappedRows.get(row.id);
+            if (localRow) {
+                skipped.push(localRow);
+                existsMap.set(localRow.id, !!row.record_exists);
+            }
+        }
+        else {
+            completed.push(row);
+        }
+    }
+    return {
+        data: {
+            completed,
+            skipped,
+            existsMap,
+        },
+        error: error ?? null,
+    };
+}
+async function rpcUpsertSingle({ table, row, supabase, existsMap, }) {
+    const rowExist = existsMap.get(row.id) ?? false;
+    const { data, error } = rowExist
+        ? await supabase
+            .from(table)
+            .update(row)
+            .eq("id", row.id)
+            .select("id")
+            .maybeSingle()
+        : await supabase.from(table).insert(row).select("id").maybeSingle();
+    if (error)
+        return { data: null, error };
+    return { data, error: null };
+}
 /* ────────────────────────────────────────────────────────────────────────── *
  * Local side-effects (shared)
  * ────────────────────────────────────────────────────────────────────────── */
@@ -87,13 +160,12 @@ async function handleRowFailure(cfg, table, row, err, supabase) {
         const action = cfg.syncPolicy?.onNonRetryable ?? "accept-server";
         if (action === "delete-local" || cfg.deleteConflictedRows) {
             logWarn(`Row ${row.id} on ${table} hit NON_RETRYABLE conflict → deleting local`, JSON.stringify(err));
-            await deleteLocalRow(table, row.id);
-            cfg.syncPolicy?.onRowDroppedLocal?.(table, row.id);
+            await deleteLocalRow(table, row.id, supabase);
             return "DROP";
         }
         else {
             logWarn(`Row ${row.id} on ${table} hit NON_RETRYABLE conflict → accepting server`, JSON.stringify(err));
-            await acceptServerAndStopRetrying(table, row.id);
+            await deleteLocalRow(table, row.id, supabase);
             cfg.syncPolicy?.onRowAcceptedServer?.(table, row.id);
             return "DROP";
         }
@@ -107,16 +179,8 @@ async function handleRowFailure(cfg, table, row, err, supabase) {
     if (klass === "HTTP" || klass === "RETRYABLE" || klass === "UNKNOWN") {
         log(`Row ${row.id} on ${table} transient/HTTP error → scheduling retry`, JSON.stringify(err));
         if (klass === "HTTP") {
-            const server = await fetchServerRowById(table, row.id, supabase);
-            if (server) {
-                await replaceLocalWithServer(table, server);
-                return "REPLACED";
-            }
-            else if (cfg.deleteConflictedRows) {
-                await deleteLocalRow(table, row.id);
-                cfg.syncPolicy?.onRowDroppedLocal?.(table, row.id);
-                return "REPLACED";
-            }
+            await deleteLocalRow(table, row.id, supabase);
+            return "REPLACED";
         }
         setQueryStatus(row.id, table, "error");
         return "KEEP";
@@ -130,33 +194,33 @@ function quoteIdent(name) {
     }
     return `"${name.replace(/"/g, '""')}"`;
 }
-async function deleteLocalRow(table, id) {
-    await rewindAndDropLocal(table, id);
+async function deleteLocalRow(table, id, supabase) {
+    await rewindAndDropLocal(table, id, supabase);
     setQueryStatus(id, table, "success");
     supastashEventBus.emit("updateSyncStatus");
 }
-export { batchUpsert, filterRowsByUpdatedAt, handleRowFailure, markSynced, singleUpsert, };
+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 async function rewindAndDropLocal(table, rowId) {
-    const db = await getSupastashDb();
-    // 1) Delete local copy
-    await db.runAsync(`DELETE FROM ${quoteIdent(table)} WHERE id = ?`, [rowId]);
-    logWarn(`[Supastash] REPLACED: dropped local ${table}:${rowId}
-    `);
+export async function rewindAndDropLocal(table, rowId, supabase) {
+    const server = await fetchServerRowById(table, rowId, supabase);
+    if (server) {
+        await replaceLocalWithServer(table, server);
+    }
+    else {
+        const db = await getSupastashDb();
+        // 1) Delete local copy
+        await db.runAsync(`DELETE FROM ${quoteIdent(table)} WHERE id = ?`, [rowId]);
+        const cfg = getSupastashConfig();
+        cfg.syncPolicy?.onRowDroppedLocal?.(table, rowId);
+        logWarn(`[Supastash] REPLACED: dropped local ${table}:${rowId}
+      `);
+    }
 }
 async function replaceLocalWithServer(table, serverRow) {
-    const db = await getSupastashDb();
-    const cols = Object.keys(serverRow);
-    const placeholders = cols.map(() => "?").join(", ");
-    const updates = cols
-        .filter((c) => c !== "id")
-        .map((c) => `${c}=excluded.${c}`)
-        .join(", ");
-    await db.runAsync(`INSERT INTO ${quoteIdent(table)} (${cols.join(",")}) VALUES (${placeholders})
-     ON CONFLICT(id) DO UPDATE SET ${updates};`, cols.map((c) => serverRow[c] ?? null));
+    await upsertData(table, serverRow);
     await updateLocalSyncedAt(table, [serverRow.id]);
     setQueryStatus(serverRow.id, table, "success");
     supastashEventBus.emit("updateSyncStatus");

package/package.json

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