supastash 0.1.30 → 0.1.32

package/README.md

@@ -235,15 +235,6 @@ src/
 
 ---
 
-## 🧪 Dev & Testing
-
-```bash
-yarn test       # Run tests
-yarn dev        # Dev mode (watch)
-```
-
----
-
 ## 🔧 API Docs
 
 - [`configureSupastash()`](https://0xzekea.github.io/supastash/docs/configuration)

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,iBA+E7B"}
+{"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"}

package/dist/core/schemaManager/index.js

@@ -38,10 +38,10 @@ export async function defineLocalSchema(tableName, schema, deletePreviousSchema
             throw new Error(`'id' of type UUID column is required for table ${tableName}`);
         }
         const db = await getSupastashDb();
-        const { __indices, ...columnSchema } = schema;
-        const indexNotInSchema = __indices?.some((i) => !columnSchema[i]);
-        if (__indices && indexNotInSchema) {
-            throw new Error(`Index ${indexNotInSchema} not found in schema. Please ensure all indices are defined in the schema.`);
+        const { __indices, __constraints, ...columnSchema } = schema;
+        const indexNotInSchema = __indices?.filter((i) => !columnSchema[i]) ?? [];
+        if (indexNotInSchema.length > 0) {
+            throw new Error(`Index columns ${indexNotInSchema.join(", ")} not found in schema. Please ensure all columns are defined in the schema.`);
         }
         // Ensure required columns
         const safeSchema = {
@@ -54,7 +54,7 @@ export async function defineLocalSchema(tableName, schema, deletePreviousSchema
         // Build column definitions
         const schemaParts = Object.entries(safeSchema).map(([key, value]) => `${key} ${value}`);
         const schemaString = schemaParts.join(", ");
-        const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${schemaString});`;
+        const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${schemaString}) ${__constraints ? ` ${__constraints}` : ""};`;
         if (deletePreviousSchema) {
             const dropSql = `DROP TABLE IF EXISTS ${tableName}`;
             const clearSyncStatusSql = `DELETE FROM supastash_sync_status WHERE table_name = '${tableName}'`;

package/dist/hooks/supastashLogic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"supastashLogic.d.ts","sourceRoot":"","sources":["../../src/hooks/supastashLogic.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAQrE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,GAAE,OAAe,GAAG,mBAAmB,CA2EvE"}
+{"version":3,"file":"supastashLogic.d.ts","sourceRoot":"","sources":["../../src/hooks/supastashLogic.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AASrE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,GAAE,OAAe,GAAG,mBAAmB,CA4EvE"}

package/dist/hooks/supastashLogic.js

@@ -4,6 +4,7 @@ import { supastashDbErrorMsg } from "../db/dbErrorMsg";
 import { useSyncEngine } from "../hooks/syncEngine";
 import { localCache } from "../store/localCache";
 import { filterTracker, tableFilters, tableFiltersUsed, } from "../store/tableFilters";
+import { createIdIndexes } from "../utils/createIndexes";
 import { logError, logWarn } from "../utils/logs";
 import { createDeletedStatusTable, createSyncStatusTable, } from "../utils/schema/createSyncStatus";
 import { supabaseClientErr } from "../utils/supabaseClientErr";
@@ -54,6 +55,7 @@ export function useSupastash(lazy = false) {
                 // Create supastash metadata tables
                 await createSyncStatusTable();
                 await createDeletedStatusTable();
+                await createIdIndexes();
                 // On schema init
                 if (config.onSchemaInit) {
                     await config.onSchemaInit();

package/dist/types/schemaManager.types.d.ts

@@ -39,6 +39,7 @@ export type LocalSchemaDefinition = {
   [key: string]: ColumnDefinition | string[];
 } & {
   __indices?: string[];
+  __constraints?: string;
 };
 
 export type DefineLocalSchema = (

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

@@ -34,6 +34,7 @@ export type SupastashConfig<T extends SupastashSQLiteClientTypes> = {
   listeners?: number;
   onSchemaInit?: () => Promise<void>;
   debugMode?: boolean;
+  useCustomRPCForUpserts?: boolean;
 };
 
 interface SupastashSQLiteDatabase {
@@ -54,7 +55,7 @@ interface SupastashSQLiteDatabase {
    * @param params - Optional parameters for the query
    * @returns A Promise resolving to an array
    */
-  getAllAsync(sql: string, params?: any[]): Promise<any[]>;
+  getAllAsync<T = any>(sql: string, params?: any[]): Promise<T[]>;
 
   /**
    * Executes a query and returns **only the first row** (or `null` if no rows).
@@ -63,7 +64,7 @@ interface SupastashSQLiteDatabase {
    * @param params - Optional parameters for the query
    * @returns A Promise resolving to the first matching row
    */
-  getFirstAsync(sql: string, params?: any[]): Promise<any | null>;
+  getFirstAsync<T = any>(sql: string, params?: any[]): Promise<T | null>;
 
   /**
    * Executes **multiple SQL statements** separated by semicolons.

package/dist/utils/createIndexes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Create a single-column index on "id" where it actually helps.
+ * - Skips virtual tables (e.g. FTS), views, system tables.
+ * - Skips when "id" doesn't exist.
+ * - Skips when "id" is already PK (including TEXT PK which has an implicit unique index).
+ * - Skips when there's already an index on "id".
+ */
+export declare function createIdIndexes(): Promise<void>;
+//# sourceMappingURL=createIndexes.d.ts.map

package/dist/utils/createIndexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createIndexes.d.ts","sourceRoot":"","sources":["../../src/utils/createIndexes.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,wBAAsB,eAAe,kBAgGpC"}

package/dist/utils/createIndexes.js

@@ -0,0 +1,81 @@
+import { getSupastashDb } from "../db/dbInitializer";
+import { logError } from "./logs";
+import { getAllTables } from "./sync/getAllTables";
+/**
+ * Create a single-column index on "id" where it actually helps.
+ * - Skips virtual tables (e.g. FTS), views, system tables.
+ * - Skips when "id" doesn't exist.
+ * - Skips when "id" is already PK (including TEXT PK which has an implicit unique index).
+ * - Skips when there's already an index on "id".
+ */
+export async function createIdIndexes() {
+    const db = await getSupastashDb();
+    const tables = await getAllTables();
+    if (!tables || !tables.length)
+        return;
+    const q = (s) => `"${s.replace(/"/g, '""')}"`;
+    for (const table of tables) {
+        if (!table)
+            continue;
+        try {
+            // 1) Check sqlite_schema for table kind + DDL
+            const schemaRow = await db.getFirstAsync(`SELECT type, sql FROM sqlite_schema WHERE name = ?1`, [table]);
+            if (!schemaRow)
+                continue; // not a real table in this db
+            if (schemaRow.type !== "table")
+                continue; // views, triggers, etc.
+            const ddl = schemaRow.sql || "";
+            // Virtual tables get skipped
+            if (/\bCREATE\s+VIRTUAL\s+TABLE\b/i.test(ddl)) {
+                continue;
+            }
+            // 2) Inspect columns; ensure "id" exists and get PK info
+            const columns = await db.getAllAsync(`PRAGMA table_info(${q(table)})`);
+            if (!columns?.length)
+                continue;
+            const idCol = columns.find((c) => c.name === "id");
+            if (!idCol)
+                continue; // no "id" column → nothing to do
+            // If "id" is part of the PK, indexing is unnecessary/redundant:
+            // - INTEGER PRIMARY KEY uses rowid (fast already).
+            // - TEXT/other PRIMARY KEYs get an implicit unique index.
+            const pkCols = columns.filter((c) => c.pk > 0);
+            const idIsPk = idCol.pk > 0;
+            if (idIsPk) {
+                // If it's the only PK column or part of composite PK, skip — already indexed enough.
+                continue;
+            }
+            // 3) Check if an index on "id" already exists
+            const indexes = await db.getAllAsync(`PRAGMA index_list(${q(table)})`);
+            let hasIdOnlyIndex = false;
+            if (indexes?.length) {
+                for (const ix of indexes) {
+                    // Ignore partial indexes for simplicity
+                    const cols = await db.getAllAsync(`PRAGMA index_info(${q(ix.name)})`);
+                    if (!cols?.length)
+                        continue;
+                    if (cols.length === 1 && cols[0].name === "id") {
+                        hasIdOnlyIndex = true;
+                        break;
+                    }
+                }
+            }
+            if (hasIdOnlyIndex)
+                continue;
+            // 4) Create the index safely
+            const idxName = `idx_${table}_id`;
+            try {
+                await db.runAsync("BEGIN");
+                await db.runAsync(`CREATE INDEX IF NOT EXISTS ${q(idxName)} ON ${q(table)}("id");`);
+                await db.runAsync("COMMIT");
+            }
+            catch (e) {
+                await db.runAsync("ROLLBACK");
+                logError(`[index-skip] ${table}: ${e.message}`);
+            }
+        }
+        catch (err) {
+            logError(`[index-check-failed] ${table}: ${err.message}`);
+        }
+    }
+}

package/dist/utils/query/helpers/localDb/insertMany.d.ts

@@ -0,0 +1,10 @@
+import { SyncMode } from "../../../../types/query.types";
+interface InsertOptions<R = any> {
+    table: string;
+    syncMode?: SyncMode;
+    nowISO?: string;
+    returnInsertedRows?: boolean;
+}
+export declare function insertMany<R = any>(payload: R[], opts: InsertOptions<R>): Promise<R[] | void>;
+export {};
+//# sourceMappingURL=insertMany.d.ts.map

package/dist/utils/query/helpers/localDb/insertMany.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertMany.d.ts","sourceRoot":"","sources":["../../../../../src/utils/query/helpers/localDb/insertMany.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAIzD,UAAU,aAAa,CAAC,CAAC,GAAG,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAMD,wBAAsB,UAAU,CAAC,CAAC,GAAG,GAAG,EACtC,OAAO,EAAE,CAAC,EAAE,EACZ,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,CA4GrB"}

package/dist/utils/query/helpers/localDb/insertMany.js

@@ -0,0 +1,127 @@
+import { getSupastashDb } from "../../../../db/dbInitializer";
+import { getSafeValue } from "../../../serializer";
+import { parseStringifiedFields as parseRow } from "../../../sync/pushLocal/parseFields";
+const MAX_PARAMS = 999;
+const CHECK_BATCH = 900;
+const YIELD_EVERY = 500;
+export async function insertMany(payload, opts) {
+    const db = await getSupastashDb();
+    const { table, syncMode, returnInsertedRows } = opts;
+    const timeStamp = opts.nowISO ?? new Date().toISOString();
+    assertTableName(table);
+    if (!Array.isArray(payload) || payload.length === 0)
+        return [];
+    const idSet = new Set();
+    // 1) Validate & gather ids
+    const ids = payload.map((item, i) => {
+        if (!item || !item.id) {
+            throw new Error(`Payload[${i}] must include a valid 'id' field for inserts.`);
+        }
+        const id = String(item.id);
+        if (idSet.has(id)) {
+            throw new Error(`Duplicate id: ${id} in payload[${i}]`);
+        }
+        idSet.add(id);
+        return id;
+    });
+    // 2) Check existing ids in DB (batched; fail-fast)
+    for (let i = 0; i < ids.length; i += CHECK_BATCH) {
+        const part = ids.slice(i, i + CHECK_BATCH);
+        const ph = makePlaceholders(part.length);
+        const existing = await db.getAllAsync(`SELECT id FROM ${quoteIdent(table)} WHERE id IN (${ph})`, part);
+        if (existing.length) {
+            const taken = existing.map((r) => String(r.id));
+            throw new Error(`Record(s) already exist in table ${table}: ${taken.join(", ")}`);
+        }
+    }
+    // 3) Do inserts in a single transaction
+    const insertedIds = [];
+    const run = async () => {
+        for (let i = 0; i < payload.length; i++) {
+            const item = payload[i];
+            const newPayload = {
+                ...item,
+                created_at: hasOwn(item, "created_at") ? item.created_at : timeStamp,
+                updated_at: hasOwn(item, "updated_at") ? item.updated_at : timeStamp,
+                synced_at: hasOwn(item, "synced_at")
+                    ? item.synced_at
+                    : syncMode && (syncMode === "localOnly" || syncMode === "remoteFirst")
+                        ? timeStamp
+                        : null,
+            };
+            const colArray = Object.keys(newPayload);
+            if (colArray.length === 0)
+                continue;
+            // Validate/quote column names
+            const colsSql = colArray.map(quoteIdent).join(", ");
+            const placeholders = makePlaceholders(colArray.length);
+            const values = colArray.map((c) => normalizeValue(getSafeValue(newPayload[c])));
+            await db.runAsync(`INSERT INTO ${quoteIdent(table)} (${colsSql}) VALUES (${placeholders})`, values);
+            insertedIds.push(String(item.id));
+            if ((i + 1) % YIELD_EVERY === 0)
+                await microYield();
+        }
+    };
+    await db.runAsync("BEGIN");
+    try {
+        await run();
+        await db.runAsync("COMMIT");
+    }
+    catch (e) {
+        await db.runAsync("ROLLBACK");
+        throw e;
+    }
+    // 4) Optionally fetch inserted rows (batched) and return in input order
+    if (!returnInsertedRows)
+        return;
+    if (insertedIds.length === 0)
+        return [];
+    const rows = [];
+    for (let i = 0; i < insertedIds.length; i += CHECK_BATCH) {
+        const part = insertedIds.slice(i, i + CHECK_BATCH);
+        const ph = makePlaceholders(part.length);
+        const chunkRows = await db.getAllAsync(`SELECT * FROM ${quoteIdent(table)} WHERE id IN (${ph})`, part);
+        rows.push(...chunkRows);
+    }
+    const map = new Map(rows.map((r) => [String(r.id), parseRow ? parseRow(r) : r]));
+    return insertedIds.map((id) => map.get(id)).filter(Boolean);
+}
+/* ---------- helpers ---------- */
+function makePlaceholders(n) {
+    if (n <= 0)
+        throw new Error("No placeholders to make");
+    if (n > MAX_PARAMS)
+        throw new Error(`Requested ${n} placeholders; max is ${MAX_PARAMS}`);
+    return Array(n).fill("?").join(",");
+}
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function assertTableName(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`Unsafe table name: ${name}`);
+    }
+}
+function quoteIdent(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`Unsafe identifier: ${name}`);
+    }
+    return `"${name}"`;
+}
+function normalizeValue(v) {
+    return v === undefined ? null : v;
+}
+function defaultSafe(value) {
+    if (value === null || value === undefined)
+        return value ?? null;
+    if (value instanceof Date)
+        return value.toISOString();
+    if (Array.isArray(value))
+        return JSON.stringify(value);
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return value;
+}
+function microYield() {
+    return new Promise((res) => setTimeout(res, 0));
+}

package/dist/utils/query/helpers/localDb/upsertMany.d.ts

@@ -0,0 +1,13 @@
+import { SyncMode } from "../../../../types/query.types";
+interface UpsertOptions<R = any> {
+    table: string;
+    onConflictKeys?: string[];
+    syncMode?: SyncMode;
+    nowISO?: string;
+    preserveTimestamp?: boolean;
+    returnRows?: boolean;
+    yieldEvery?: number;
+}
+export declare function upsertMany<R = any>(items: R[], opts: UpsertOptions<R>): Promise<R[] | void>;
+export {};
+//# sourceMappingURL=upsertMany.d.ts.map

package/dist/utils/query/helpers/localDb/upsertMany.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upsertMany.d.ts","sourceRoot":"","sources":["../../../../../src/utils/query/helpers/localDb/upsertMany.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAMzD,UAAU,aAAa,CAAC,CAAC,GAAG,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAID,wBAAsB,UAAU,CAAC,CAAC,GAAG,GAAG,EACtC,KAAK,EAAE,CAAC,EAAE,EACV,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,CAuKrB"}

package/dist/utils/query/helpers/localDb/upsertMany.js

@@ -0,0 +1,178 @@
+import { getSupastashDb } from "../../../../db/dbInitializer";
+import { generateUUIDv4 } from "../../../genUUID";
+import { parseStringifiedFields as parseRow } from "../../../sync/pushLocal/parseFields";
+const DEFAULT_DATE = "1970-01-01T00:00:00.000Z";
+const CHECK_BATCH = 900; // param headroom under 999
+export async function upsertMany(items, opts) {
+    const db = await getSupastashDb();
+    const { table, syncMode, nowISO, preserveTimestamp = false, yieldEvery = 500, } = opts;
+    const returnRows = opts.returnRows !== false;
+    const onConflictKeys = opts.onConflictKeys && opts.onConflictKeys.length
+        ? opts.onConflictKeys
+        : ["id"];
+    assertTableName(table);
+    onConflictKeys.forEach(assertIdent);
+    if (!Array.isArray(items) || items.length === 0)
+        return [];
+    const timeStamp = nowISO ?? new Date().toISOString();
+    let existingIdSet = null;
+    if (onConflictKeys.length === 1 && onConflictKeys[0] === "id") {
+        const ids = items
+            .map((row, i) => {
+            const id = row?.id ?? null;
+            // allow missing; we’ll generate before insert
+            return id == null ? null : String(id);
+        })
+            .filter(Boolean);
+        existingIdSet = new Set(await selectIdsInBatches(db, table, ids));
+    }
+    const upserted = [];
+    const run = async () => {
+        for (let i = 0; i < items.length; i++) {
+            const input = items[i] ?? {};
+            const row = { ...input };
+            // Ensure id if it's part of conflict keys
+            if (onConflictKeys.includes("id") && (row.id == null || row.id === "")) {
+                row.id = generateUUIDv4();
+            }
+            // synced_at default
+            if (!hasOwn(row, "synced_at")) {
+                row.synced_at =
+                    syncMode && (syncMode === "localOnly" || syncMode === "remoteFirst")
+                        ? timeStamp
+                        : null;
+            }
+            // Decide: update or insert?
+            const { clause, values: keyValues } = buildWhere(onConflictKeys, row);
+            const canCheckConflict = clause !== null;
+            let exists = false;
+            if (onConflictKeys.length === 1 &&
+                onConflictKeys[0] === "id" &&
+                existingIdSet) {
+                exists = existingIdSet.has(String(row.id));
+            }
+            else if (canCheckConflict) {
+                const existing = await db.getAllAsync(`SELECT 1 FROM ${quote(table)} WHERE ${clause} LIMIT 2`, keyValues);
+                if (existing.length > 1) {
+                    throw new Error(`Multiple rows matched onConflictKeys in '${table}' — expected uniqueness on ${onConflictKeys.join(", ")}`);
+                }
+                exists = existing.length === 1;
+            }
+            if (exists) {
+                // UPDATE path
+                if (!preserveTimestamp || input.updated_at === undefined) {
+                    row.updated_at =
+                        input.updated_at !== undefined ? input.updated_at : timeStamp;
+                }
+                // Build SET list (exclude conflict keys; also skip undefined to avoid nulling unintentionally)
+                const updateCols = Object.keys(row).filter((c) => !onConflictKeys.includes(c) && row[c] !== undefined);
+                if (updateCols.length > 0) {
+                    const setSql = updateCols.map((c) => `${quote(c)} = ?`).join(", ");
+                    const setVals = updateCols.map((c) => toDbValue(row[c]));
+                    if (!canCheckConflict) {
+                        throw new Error(`Missing onConflictKeys in payload; cannot UPDATE in '${table}'. Keys: ${onConflictKeys.join(", ")}`);
+                    }
+                    await db.runAsync(`UPDATE ${quote(table)} SET ${setSql} WHERE ${clause}`, [...setVals, ...keyValues]);
+                    if (returnRows) {
+                        const updated = await db.getFirstAsync(`SELECT * FROM ${quote(table)} WHERE ${clause} LIMIT 1`, keyValues);
+                        if (returnRows)
+                            upserted.push(parseRow(updated));
+                    }
+                }
+            }
+            else {
+                // INSERT path
+                if (!hasOwn(row, "created_at"))
+                    row.created_at = timeStamp;
+                if (!hasOwn(row, "updated_at"))
+                    row.updated_at = timeStamp;
+                if (!hasOwn(row, "id"))
+                    row.id = generateUUIDv4();
+                const insertCols = Object.keys(row).filter((c) => row[c] !== undefined);
+                const placeholders = insertCols.map(() => "?").join(", ");
+                const insertVals = insertCols.map((c) => toDbValue(row[c]));
+                await db.runAsync(`INSERT INTO ${quote(table)} (${insertCols
+                    .map(quote)
+                    .join(", ")}) VALUES (${placeholders})`, insertVals);
+                if (returnRows) {
+                    const inserted = await db.getFirstAsync(`SELECT * FROM ${quote(table)} WHERE ${clause} LIMIT 1`, keyValues);
+                    upserted.push(parseRow(inserted));
+                }
+                if (existingIdSet &&
+                    onConflictKeys.length === 1 &&
+                    onConflictKeys[0] === "id") {
+                    existingIdSet.add(String(row.id));
+                }
+            }
+            if (yieldEvery > 0 && (i + 1) % yieldEvery === 0) {
+                await microYield();
+            }
+        }
+    };
+    await db.runAsync("BEGIN");
+    try {
+        await run();
+        await db.runAsync("COMMIT");
+    }
+    catch (e) {
+        await db.runAsync("ROLLBACK");
+        throw e;
+    }
+    return returnRows ? upserted : undefined;
+}
+/* ================= helpers ================= */
+function buildWhere(keys, row) {
+    if (!keys.length)
+        return { clause: null, values: [] };
+    const missing = keys.filter((k) => row[k] === undefined || row[k] === null);
+    if (missing.length)
+        return { clause: null, values: [] };
+    const parts = keys.map((k) => `${quote(k)} = ?`);
+    const vals = keys.map((k) => toDbValue(row[k]));
+    return { clause: parts.join(" AND "), values: vals };
+}
+function toDbValue(v) {
+    if (v === undefined)
+        return null;
+    if (v === null)
+        return null;
+    if (v instanceof Date)
+        return v.toISOString();
+    if (Array.isArray(v))
+        return JSON.stringify(v);
+    if (typeof v === "object")
+        return JSON.stringify(v);
+    return v;
+}
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function assertTableName(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`Unsafe table name: ${name}`);
+    }
+}
+function assertIdent(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`Unsafe identifier: ${name}`);
+    }
+}
+function quote(name) {
+    return `"${name}"`;
+}
+async function selectIdsInBatches(db, table, ids) {
+    const out = [];
+    for (let i = 0; i < ids.length; i += CHECK_BATCH) {
+        const part = ids.slice(i, i + CHECK_BATCH);
+        if (part.length === 0)
+            continue;
+        const ph = Array(part.length).fill("?").join(",");
+        const rows = await db.getAllAsync(`SELECT id FROM ${quote(table)} WHERE id IN (${ph})`, part);
+        for (const r of rows)
+            out.push(String(r.id));
+    }
+    return out;
+}
+function microYield() {
+    return new Promise((res) => setTimeout(res, 0));
+}

package/dist/utils/query/localDbQuery/insert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../../../src/utils/query/localDbQuery/insert.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,iBAAiB,EACjB,aAAa,EACb,QAAQ,EACT,MAAM,4BAA4B,CAAC;AAMpC;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EACtD,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,EAAE,GAAG,IAAI,EACnB,QAAQ,CAAC,EAAE,QAAQ,EACnB,QAAQ,CAAC,EAAE,CAAC,GACX,OAAO,CAAC,CAAC,SAAS,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CA6EnE"}
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../../../src/utils/query/localDbQuery/insert.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,QAAQ,EACT,MAAM,4BAA4B,CAAC;AAKpC;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EACtD,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,EAAE,GAAG,IAAI,EACnB,QAAQ,CAAC,EAAE,QAAQ,EACnB,QAAQ,CAAC,EAAE,CAAC,GACX,OAAO,CAAC,CAAC,SAAS,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CA8BnE"}

package/dist/utils/query/localDbQuery/insert.js

@@ -1,8 +1,6 @@
-import { getSupastashDb } from "../../../db/dbInitializer";
 import { logError } from "../../logs";
-import { getSafeValue } from "../../serializer";
-import { parseStringifiedFields } from "../../sync/pushLocal/parseFields";
 import { assertTableExists } from "../../tableValidator";
+import { insertMany } from "../helpers/localDb/insertMany";
 /**
  * Inserts data locally, sets synced_at to null pending update to remote server
  *
@@ -15,43 +13,16 @@ export async function insertData(table, payload, syncMode, isSingle) {
         throw new Error("Table name was not provided for an insert call");
     if (!payload)
         throw new Error(`Payload data was not provided for an insert call on ${table}`);
-    const timeStamp = new Date().toISOString();
-    const inserted = [];
     try {
         await assertTableExists(table);
-        const db = await getSupastashDb();
-        for (const item of payload) {
-            if (!item.id) {
-                throw new Error(`Payload must include a valid 'id' field for inserts.`);
-            }
-            const newPayload = {
-                ...item,
-                created_at: item.created_at ?? timeStamp,
-                updated_at: item.updated_at ?? timeStamp,
-                synced_at: Object.prototype.hasOwnProperty.call(item, "synced_at")
-                    ? item.synced_at
-                    : syncMode && (syncMode === "localOnly" || syncMode === "remoteFirst")
-                        ? timeStamp
-                        : null,
-            };
-            const colArray = Object.keys(newPayload);
-            const cols = colArray.join(", ");
-            const placeholders = colArray.map(() => "?").join(", ");
-            const values = colArray.map((c) => getSafeValue(newPayload[c]));
-            // Check if record already exist
-            const exists = await db.getFirstAsync(`SELECT 1 FROM ${table} WHERE id = ? LIMIT 1`, [newPayload.id]);
-            if (exists)
-                throw new Error(`Record with id ${newPayload.id} already exists in table ${table}`);
-            // Insert data
-            await db.runAsync(`INSERT INTO ${table} (${cols}) VALUES (${placeholders})`, values);
-            const insertedRow = await db.getFirstAsync(`SELECT * FROM ${table} WHERE id = ?`, [newPayload.id]);
-            if (insertedRow) {
-                inserted.push(parseStringifiedFields(insertedRow));
-            }
-        }
+        const inserted = await insertMany(payload, {
+            table,
+            syncMode,
+            returnInsertedRows: true,
+        });
         return {
             error: null,
-            data: isSingle ? inserted[0] : inserted,
+            data: isSingle ? inserted?.[0] : inserted,
         };
     }
     catch (error) {

package/dist/utils/query/localDbQuery/upsert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/utils/query/localDbQuery/upsert.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,iBAAiB,EACjB,aAAa,EACb,QAAQ,EACT,MAAM,4BAA4B,CAAC;AASpC;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EACtD,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,EACvB,QAAQ,CAAC,EAAE,QAAQ,EACnB,QAAQ,CAAC,EAAE,CAAC,EACZ,cAAc,GAAE,MAAM,EAAW,EACjC,iBAAiB,CAAC,EAAE,OAAO,GAC1B,OAAO,CAAC,CAAC,SAAS,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CA4HnE"}
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/utils/query/localDbQuery/upsert.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,QAAQ,EACT,MAAM,4BAA4B,CAAC;AAOpC;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EACtD,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,EACvB,QAAQ,CAAC,EAAE,QAAQ,EACnB,QAAQ,CAAC,EAAE,CAAC,EACZ,cAAc,GAAE,MAAM,EAAW,EACjC,iBAAiB,CAAC,EAAE,OAAO,GAC1B,OAAO,CAAC,CAAC,SAAS,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CA8BnE"}

package/dist/utils/query/localDbQuery/upsert.js

@@ -1,10 +1,6 @@
-import { getSupastashConfig } from "../../../core/config";
-import { getSupastashDb } from "../../../db/dbInitializer";
-import { generateUUIDv4 } from "../../../utils/genUUID";
-import { logError, logWarn } from "../../logs";
-import { getSafeValue } from "../../serializer";
-import { parseStringifiedFields } from "../../sync/pushLocal/parseFields";
+import { logError } from "../../logs";
 import { assertTableExists } from "../../tableValidator";
+import { upsertMany } from "../helpers/localDb/upsertMany";
 const warned = new Set();
 /**
  * Performs upsert-like logic on local DB:
@@ -16,78 +12,18 @@ export async function upsertData(table, payload, syncMode, isSingle, onConflictK
     if (!payload || !table)
         throw new Error("Table and payload are required for upsert.");
     await assertTableExists(table);
-    const timeStamp = new Date().toISOString();
     const items = Array.isArray(payload) ? payload : [payload];
-    const upserted = [];
     try {
-        const db = await getSupastashDb();
-        for (const item of items) {
-            const newPayload = {
-                ...item,
-                synced_at: Object.prototype.hasOwnProperty.call(item, "synced_at")
-                    ? item.synced_at
-                    : syncMode && (syncMode === "localOnly" || syncMode === "remoteFirst")
-                        ? timeStamp
-                        : null,
-            };
-            const colArray = Object.keys(newPayload);
-            const includesConflictKeys = onConflictKeys.every((key) => colArray.includes(key));
-            if (!includesConflictKeys) {
-                throw new Error(`onConflictKeys must include at least one key from the payload. Payload: ${JSON.stringify(newPayload)}`);
-            }
-            const whereClause = onConflictKeys
-                .map((key) => `${key} = ?`)
-                .join(" AND ");
-            const conflictValues = onConflictKeys.map((key) => getSafeValue(newPayload[key]));
-            const existingData = await db.getAllAsync(`SELECT * FROM ${table} WHERE ${whereClause}`, [...conflictValues]);
-            if (existingData.length > 0) {
-                if (existingData.length > 1) {
-                    throw new Error(`Multiple rows matched onConflictKeys in '${table}' — expected unique constraint. Payload: ${JSON.stringify(newPayload)}`);
-                }
-                if (!preserveTimestamp || item.updated_at === undefined) {
-                    if (!warned.has(table) &&
-                        !getSupastashConfig().debugMode &&
-                        __DEV__) {
-                        warned.add(table);
-                        logWarn(`[Supastash] updated_at not provided for upsert call on ${table} – defaulting to ${timeStamp}`);
-                    }
-                    const userUpdatedAt = item.updated_at;
-                    newPayload.updated_at =
-                        userUpdatedAt !== undefined ? userUpdatedAt : timeStamp;
-                }
-                const updateColsArray = Object.keys(newPayload);
-                const updateCols = updateColsArray
-                    .filter((col) => !onConflictKeys.includes(col))
-                    .map((col) => `${col} = ?`)
-                    .join(", ");
-                const updateValues = updateColsArray
-                    .filter((col) => !onConflictKeys.includes(col))
-                    .map((c) => getSafeValue(newPayload[c]));
-                const updateSql = `UPDATE ${table} SET ${updateCols} WHERE ${whereClause}`;
-                await db.runAsync(updateSql, [...updateValues, ...conflictValues]);
-                upserted.push(parseStringifiedFields(newPayload));
-            }
-            else {
-                const insertPayload = {
-                    ...newPayload,
-                    id: newPayload.id ?? generateUUIDv4(),
-                    created_at: newPayload.created_at ?? timeStamp,
-                    updated_at: newPayload.updated_at ?? timeStamp,
-                };
-                const newColsArray = Object.keys(insertPayload);
-                const insertCols = newColsArray.join(", ");
-                const insertPlaceholders = newColsArray.map(() => "?").join(", ");
-                const insertValues = newColsArray.map((c) => getSafeValue(insertPayload[c]));
-                const insertSql = `INSERT INTO ${table} (${insertCols}) VALUES (${insertPlaceholders})`;
-                await db.runAsync(insertSql, insertValues);
-                const inserted = await db.getFirstAsync(`SELECT * FROM ${table} WHERE ${whereClause} LIMIT 1`, [...conflictValues]);
-                if (inserted)
-                    upserted.push(parseStringifiedFields(inserted));
-            }
-        }
+        const upserted = await upsertMany(items, {
+            table,
+            syncMode,
+            returnRows: true,
+            onConflictKeys,
+            preserveTimestamp,
+        });
         return {
             error: null,
-            data: isSingle ? upserted[0] : upserted,
+            data: isSingle ? upserted?.[0] : upserted,
         };
     }
     catch (error) {

package/dist/utils/query/remoteQuery/supabaseQuery.js

@@ -137,7 +137,7 @@ export async function querySupabase(state, isBatched = false) {
         type !== "remoteFirst") {
         if (method === "insert" && newPayload) {
             for (const item of upsertOrInsertPayload) {
-                await updateLocalSyncedAt(table, item.id);
+                await updateLocalSyncedAt(table, [item.id]);
             }
         }
         if (method === "upsert" && newPayload) {

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

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

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

@@ -10,6 +10,7 @@ import { pullDeletedData } from "./pullDeletedData";
 import { stringifyValue } from "./stringifyFields";
 let isInSync = new Map();
 const DEFAULT_DATE = "1970-01-01T00:00:00Z";
+const BATCH_SIZE = 500;
 /**
  * Updates the local database with the remote changes
  * @param table - The table to update
@@ -27,24 +28,39 @@ export async function updateLocalDb(table, filters, onReceiveData) {
         const refreshNeeded = !!deletedData?.records.length || !!data?.length;
         // Delete records that are no longer in the remote data
         if (deletedData && deletedData.records.length > 0) {
-            for (const record of deletedData.records) {
-                await db.runAsync(`DELETE FROM ${table} WHERE id = ?`, [record.id]);
-            }
+            const ids = deletedData.records.map((record) => record.id).join(",");
+            const placeholders = ids
+                .split(",")
+                .map(() => "?")
+                .join(",");
+            await db.runAsync(`DELETE FROM ${table} WHERE id IN (${placeholders})`, deletedData.records.map((record) => record.id));
         }
         // Update local database with remote changes
         if (data && data.length > 0) {
-            for (const record of data) {
-                if (deletedData?.deletedDataMap.has(record.id))
-                    continue;
-                const { doesExist, newer } = await checkIfRecordExistsAndIsNewer(table, record);
-                if (newer) {
-                    if (onReceiveData) {
-                        await onReceiveData(record);
+            const run = async () => {
+                for (let i = 0; i < data.length; i++) {
+                    const record = data[i];
+                    if (deletedData?.deletedDataMap.has(record.id))
+                        continue;
+                    const { doesExist, newer } = await checkIfRecordExistsAndIsNewer(table, record);
+                    if (newer) {
+                        if (onReceiveData) {
+                            await onReceiveData(record);
+                        }
+                        else {
+                            await upsertData(table, record, doesExist);
+                        }
                     }
-                    else {
-                        await upsertData(table, record, doesExist);
+                    if ((i + 1) % BATCH_SIZE === 0) {
+                        await new Promise((res) => setTimeout(res, 0));
                     }
                 }
+            };
+            try {
+                await run();
+            }
+            catch (error) {
+                throw error;
             }
         }
         if (refreshNeeded)
@@ -104,7 +120,7 @@ export async function upsertData(table, record, doesExist) {
             // Insert new record
             await db.runAsync(`INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`, values);
         }
-        await updateLocalSyncedAt(table, record.id);
+        await updateLocalSyncedAt(table, [record.id]);
     }
     catch (error) {
         logError(`[Supastash] Error upserting data for ${table}`, error);

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":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AA8KzD;;;;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,iBAYtD"}
+{"version":3,"file":"uploadChunk.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/uploadChunk.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAgLzD;;;;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,iBAYtD"}

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

@@ -9,9 +9,7 @@ const RANDOM_OLD_DATE = new Date("2000-01-01").toISOString();
 const CHUNK_SIZE = 500;
 const DEFAULT_DATE = "1970-01-01T00:00:00Z";
 async function updateSyncStatus(table, rows) {
-    for (const row of rows) {
-        await updateLocalSyncedAt(table, row.id);
-    }
+    await updateLocalSyncedAt(table, rows.map((row) => row.id));
 }
 function errorHandler(error, table, toUpsert, attempts) {
     for (const row of toUpsert) {

package/dist/utils/syncStatus.d.ts

@@ -27,10 +27,11 @@ export declare function getLocalSyncLog(tableName: string): Promise<{
  * Sets the sync log for a given table
  * @param tableName - The name of the table to set the sync log for
  * @param lastSyncedAt - The last synced at timestamp
+ * @param lastCreatedAt - The last created at timestamp
  * @example
  * setLocalSyncLog("users", new Date().toISOString());
  */
-export declare function setLocalSyncLog(tableName: string, lastSyncedAt: string): Promise<void>;
+export declare function setLocalSyncLog(tableName: string, lastSyncedAt: string, lastCreatedAt?: string): Promise<void>;
 /**
  * Clears the delete log for a given table
  * @param tableName - The name of the table to clear the delete log for

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

@@ -1 +1 @@
-{"version":3,"file":"syncStatus.d.ts","sourceRoot":"","sources":["../../src/utils/syncStatus.ts"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,iBAQxD;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,kBAKzC;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAChE,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,IAAI,CAAC,CAUR;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,iBAM5E;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,iBAM1D;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,kBAI3C;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,IAAI,CAAC,CAUR;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,iBAOtB"}
+{"version":3,"file":"syncStatus.d.ts","sourceRoot":"","sources":["../../src/utils/syncStatus.ts"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,iBAQxD;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,kBAKzC;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAChE,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,IAAI,CAAC,CAUR;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,aAAa,CAAC,EAAE,MAAM,iBAkBvB;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,iBAM1D;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,kBAI3C;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,IAAI,CAAC,CAUR;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,iBAOtB"}

package/dist/utils/syncStatus.js

@@ -1,4 +1,5 @@
 import { getSupastashDb } from "../db/dbInitializer";
+import { logWarn } from "./logs";
 import { createDeletedStatusTable, createSyncStatusTable, } from "./schema/createSyncStatus";
 const SYNC_STATUS_TABLE = "supastash_sync_status";
 const DELETED_STATUS_TABLE = "supastash_deleted_status";
@@ -49,12 +50,21 @@ export async function getLocalSyncLog(tableName) {
  * Sets the sync log for a given table
  * @param tableName - The name of the table to set the sync log for
  * @param lastSyncedAt - The last synced at timestamp
+ * @param lastCreatedAt - The last created at timestamp
  * @example
  * setLocalSyncLog("users", new Date().toISOString());
  */
-export async function setLocalSyncLog(tableName, lastSyncedAt) {
+export async function setLocalSyncLog(tableName, lastSyncedAt, lastCreatedAt) {
     const db = await getSupastashDb();
-    await db.runAsync(`INSERT OR REPLACE INTO ${SYNC_STATUS_TABLE} (table_name, last_synced_at) VALUES (?, ?)`, [tableName, lastSyncedAt]);
+    if (lastSyncedAt) {
+        await db.runAsync(`INSERT OR REPLACE INTO ${SYNC_STATUS_TABLE} (table_name, last_synced_at) VALUES (?, ?)`, [tableName, lastSyncedAt]);
+    }
+    else {
+        logWarn(`No last synced at timestamp for table ${tableName}`);
+    }
+    if (lastCreatedAt) {
+        await db.runAsync(`INSERT OR REPLACE INTO ${LAST_CREATED_TABLE} (table_name, last_created_at) VALUES (?, ?)`, [tableName, lastCreatedAt]);
+    }
 }
 /**
  * Clears the delete log for a given table

package/dist/utils/syncUpdate.d.ts

@@ -3,5 +3,5 @@
  * @param tableName - The name of the table to update
  * @param id - The id of the row to update
  */
-export declare function updateLocalSyncedAt(tableName: string, id: string): Promise<void>;
+export declare function updateLocalSyncedAt(tableName: string, ids: string[]): Promise<void>;
 //# sourceMappingURL=syncUpdate.d.ts.map

package/dist/utils/syncUpdate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syncUpdate.d.ts","sourceRoot":"","sources":["../../src/utils/syncUpdate.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,iBAYtE"}
+{"version":3,"file":"syncUpdate.d.ts","sourceRoot":"","sources":["../../src/utils/syncUpdate.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,iBAczE"}

package/dist/utils/syncUpdate.js

@@ -5,14 +5,12 @@ import { logError } from "./logs";
  * @param tableName - The name of the table to update
  * @param id - The id of the row to update
  */
-export async function updateLocalSyncedAt(tableName, id) {
+export async function updateLocalSyncedAt(tableName, ids) {
     try {
         const db = await getSupastashDb();
         const timeStamp = new Date().toISOString();
-        await db.runAsync(`UPDATE ${tableName} SET synced_at = ? WHERE id = ?`, [
-            timeStamp,
-            id,
-        ]);
+        const placeholders = ids.map(() => "?").join(", ");
+        await db.runAsync(`UPDATE ${tableName} SET synced_at = ? WHERE id IN (${placeholders})`, [timeStamp, ...ids]);
     }
     catch (error) {
         logError(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supastash",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -18,15 +18,20 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "test": "vitest --config vitest.config.ts",
-    "test:watch": "vitest --watch --config vitest.config.ts"
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "test": "jest"
   },
   "devDependencies": {
     "@testing-library/react-native": "^13.2.0",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.15.21",
     "@types/react-native-sqlite-storage": ">=6.0.0 <7.0.0",
-    "typescript": "^5.8.3",
+    "better-sqlite3": "^11.10.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.2",
     "vite": "^6.3.5",
     "vitest": "^3.1.4"
   },