supastash 0.1.62 → 0.2.1

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"}

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

@@ -0,0 +1,243 @@
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { getSupastashDb } from "../../../../shared/db/dbInitializer";
+import { supastashEventBus } from "../../../../shared/utils/events/eventBus";
+import log, { logWarn } from "../../../../shared/utils/logs";
+import { setQueryStatus } from "../../../../shared/utils/sync/queryStatus";
+import { updateLocalSyncedAt } from "../../../../shared/utils/sync/status/syncUpdate";
+import { upsertData } from "../pullFromRemote/updateLocalDb";
+export function classifyFailure(cfg, code) {
+    const p = cfg.syncPolicy ?? {};
+    const n = Number(code);
+    if (n === 409 || n === 412)
+        return "HTTP";
+    if (code == null)
+        return "UNKNOWN";
+    const s = String(code);
+    if (p.nonRetryableCodes?.has?.(s))
+        return "NON_RETRYABLE";
+    if (s === (p.fkCode ?? "23503"))
+        return "FK_BLOCK";
+    if (p.retryableCodes?.has?.(s))
+        return "RETRYABLE";
+    return "UNKNOWN";
+}
+async function batchUpsert(table, rows, supabase) {
+    return await supabase.from(table).upsert(rows);
+}
+async function singleUpsert(table, row, supabase) {
+    return await supabase.from(table).upsert(row).select("id").maybeSingle();
+}
+async function 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)
+        .select("*")
+        .eq("id", id)
+        .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)
+ * ────────────────────────────────────────────────────────────────────────── */
+async function markSynced(table, ids) {
+    await updateLocalSyncedAt(table, ids);
+    for (const id of ids)
+        setQueryStatus(id, table, "success");
+    supastashEventBus.emit("updateSyncStatus");
+}
+async function acceptServerAndStopRetrying(table, id) {
+    await updateLocalSyncedAt(table, [id]);
+    setQueryStatus(id, table, "success");
+}
+/* ────────────────────────────────────────────────────────────────────────── *
+ * Pre-filter: decide which local rows are worth pushing (server-wins on time)
+ * ────────────────────────────────────────────────────────────────────────── */
+function filterRowsByUpdatedAt(table, chunk, remoteHeads) {
+    const toPush = [];
+    const cfg = getSupastashConfig();
+    const defaultDate = cfg.fieldEnforcement?.autoFillDefaultISO ?? "1970-01-01T00:00:00Z";
+    for (const row of chunk) {
+        const id = row?.id;
+        const updatedAt = row?.updated_at ?? defaultDate;
+        if (!id || !updatedAt) {
+            // Skip bad input silently but mark visible status for debugging.
+            setQueryStatus(id ?? "UNKNOWN", table, "error");
+            continue;
+        }
+        const remoteUpdatedAt = remoteHeads.get(id) ?? defaultDate;
+        const localTs = new Date(updatedAt);
+        const remoteTs = new Date(remoteUpdatedAt);
+        if (remoteTs > localTs) {
+            // Server newer -> accept server; stop retrying this row
+            void acceptServerAndStopRetrying(table, id);
+            continue;
+        }
+        setQueryStatus(id, table, "pending");
+        toPush.push(row);
+    }
+    return toPush;
+}
+/* ────────────────────────────────────────────────────────────────────────── *
+ * Per-row conflict handling
+ * ────────────────────────────────────────────────────────────────────────── */
+async function handleRowFailure(cfg, table, row, err, supabase) {
+    const code = (err?.code ?? err?.status);
+    const klass = classifyFailure(cfg, code);
+    if (klass === "NON_RETRYABLE") {
+        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, supabase);
+            return "DROP";
+        }
+        else {
+            logWarn(`Row ${row.id} on ${table} hit NON_RETRYABLE conflict → accepting server`, JSON.stringify(err));
+            await deleteLocalRow(table, row.id, supabase);
+            cfg.syncPolicy?.onRowAcceptedServer?.(table, row.id);
+            return "DROP";
+        }
+    }
+    if (klass === "FK_BLOCK") {
+        // Parent missing (23503) -> KEEP for later;
+        log(`Row ${row.id} on ${table} blocked by missing parent (FK) → will retry`, JSON.stringify(err));
+        setQueryStatus(row.id, table, "error");
+        return "KEEP";
+    }
+    if (klass === "HTTP" || klass === "RETRYABLE" || klass === "UNKNOWN") {
+        log(`Row ${row.id} on ${table} transient/HTTP error → scheduling retry`, JSON.stringify(err));
+        if (klass === "HTTP") {
+            await deleteLocalRow(table, row.id, supabase);
+            return "REPLACED";
+        }
+        setQueryStatus(row.id, table, "error");
+        return "KEEP";
+    }
+    setQueryStatus(row.id, table, "error");
+    return "KEEP";
+}
+function quoteIdent(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`[Supastash] Invalid table identifier: ${name}`);
+    }
+    return `"${name.replace(/"/g, '""')}"`;
+}
+async function deleteLocalRow(table, id, supabase) {
+    await rewindAndDropLocal(table, id, supabase);
+    setQueryStatus(id, table, "success");
+    supastashEventBus.emit("updateSyncStatus");
+}
+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, 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) {
+    await upsertData({ table, record: serverRow });
+    await updateLocalSyncedAt(table, [serverRow.id]);
+    setQueryStatus(serverRow.id, table, "success");
+    supastashEventBus.emit("updateSyncStatus");
+}
+export async function fetchRemoteHeadsChunked(table, ids, supabase) {
+    const CHUNK = 1000;
+    const map = new Map();
+    for (let i = 0; i < ids.length; i += CHUNK) {
+        const slice = ids.slice(i, i + CHUNK);
+        const { data, error } = await supabase
+            .from(table)
+            .select("id,updated_at")
+            .in("id", slice);
+        if (error)
+            throw error;
+        for (const r of data ?? [])
+            map.set(r.id, r.updated_at);
+    }
+    return map;
+}

package/dist/native/utils/sync/status/filterKey.d.ts

@@ -0,0 +1,15 @@
+import { SupastashFilter } from "../../../../shared/types/realtimeData.types";
+/**
+ * Canonicalizes a set of filters
+ * @param filters - The filters to canonicalize
+ * @returns The canonicalized filters
+ */
+export declare function canonicalizeFilters(filters?: SupastashFilter[] | null): string;
+/**
+ * Computes the filter key for a given set of filters
+ * @param filters - The filters to compute the key for
+ * @param ns - The namespace to use for the key
+ * @returns The computed filter key
+ */
+export declare function computeFilterKey(filters?: SupastashFilter[] | null, ns?: string): Promise<string>;
+//# sourceMappingURL=filterKey.d.ts.map

package/dist/native/utils/sync/status/filterKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterKey.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/status/filterKey.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,6CAA6C,CAAC;AAa9E;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,CAAC,EAAE,eAAe,EAAE,GAAG,IAAI,GACjC,MAAM,CAuBR;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,CAAC,EAAE,eAAe,EAAE,GAAG,IAAI,EAClC,EAAE,SAAW,mBAQd"}

package/dist/{utils → native/utils}/sync/status/filterKey.js

@@ -1,18 +1,4 @@
 import * as ExpoCrypto from "expo-crypto";
-// let sha256: (s: string) => Promise<string>;
-// try {
-//   const crypto = require("react-native-quick-crypto");
-//   if (crypto.createHash) {
-//     sha256 = async (msg) =>
-//       crypto.createHash("sha256").update(msg).digest("hex");
-//   } else {
-//     throw new Error("createHash not available");
-//   }
-// } catch {
-//   const ExpoCrypto = require("expo-crypto");
-//   sha256 = (msg) =>
-//     ExpoCrypto.digestStringAsync(ExpoCrypto.CryptoDigestAlgorithm.SHA256, msg);
-// }
 /**
  * Normalizes a value
  * @param v - The value to normalize
@@ -31,7 +17,9 @@ function normVal(v) {
  * @returns The canonicalized filters
  */
 export function canonicalizeFilters(filters) {
-    const list = (filters ?? []).map((f) => ({
+    const list = (filters ?? [])
+        .filter((f) => !!f && typeof f === "object" && "column" in f && "operator" in f)
+        .map((f) => ({
         column: String(f.column),
         operator: f.operator,
         value: normVal(f.value),
@@ -41,7 +29,8 @@ export function canonicalizeFilters(filters) {
             return a.column < b.column ? -1 : 1;
         if (a.operator !== b.operator)
             return a.operator < b.operator ? -1 : 1;
-        const av = JSON.stringify(a.value), bv = JSON.stringify(b.value);
+        const av = JSON.stringify(a.value);
+        const bv = JSON.stringify(b.value);
         return av < bv ? -1 : av > bv ? 1 : 0;
     });
     return JSON.stringify(list);

package/dist/native/utils/sync/status/repo.d.ts

@@ -0,0 +1,10 @@
+import { SupastashFilter } from "../../../../shared/types/realtimeData.types";
+import { SupastashSQLiteDatabase } from "../../../../shared/types/supastashConfig.types";
+import { SupastashSyncStatus } from "../../../../shared/types/syncEngine.types";
+export declare function ensureSyncMarksTable(): Promise<void>;
+export declare function selectMarks(db: SupastashSQLiteDatabase, table: string, filterKey: string): Promise<SupastashSyncStatus | null>;
+export declare function selectSyncStatus(db: SupastashSQLiteDatabase, table: string, tableFilters?: SupastashFilter[]): Promise<SupastashSyncStatus>;
+export declare function upsertMarks(db: SupastashSQLiteDatabase, row: Partial<SupastashSyncStatus>): Promise<any>;
+export declare function resetColumn(db: SupastashSQLiteDatabase, table: string, filterKey: string, col: "last_synced_at" | "last_deleted_at", value: string, filterJson: string): Promise<any>;
+export declare function deleteMarks(db: SupastashSQLiteDatabase, table: string, filterKey?: string): Promise<any>;
+//# sourceMappingURL=repo.d.ts.map

package/dist/native/utils/sync/status/repo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/status/repo.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,6CAA6C,CAAC;AAC9E,OAAO,EAAE,uBAAuB,EAAE,MAAM,gDAAgD,CAAC;AACzF,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAuDhF,wBAAsB,oBAAoB,kBAEzC;AAED,wBAAsB,WAAW,CAC/B,EAAE,EAAE,uBAAuB,EAC3B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,uCAOlB;AAED,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,uBAAuB,EAC3B,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,eAAe,EAAE,GAC/B,OAAO,CAAC,mBAAmB,CAAC,CAoB9B;AAED,wBAAsB,WAAW,CAC/B,EAAE,EAAE,uBAAuB,EAC3B,GAAG,EAAE,OAAO,CAAC,mBAAmB,CAAC,gBA8BlC;AAED,wBAAsB,WAAW,CAC/B,EAAE,EAAE,uBAAuB,EAC3B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,gBAAgB,GAAG,iBAAiB,EACzC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,gBAYnB;AAED,wBAAsB,WAAW,CAC/B,EAAE,EAAE,uBAAuB,EAC3B,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,MAAM,gBASnB"}

package/dist/native/utils/sync/status/repo.js

@@ -0,0 +1,97 @@
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { logWarn } from "../../../../shared/utils/logs";
+import { createSyncStatusTable } from "../../../../shared/utils/schema/createSyncStatus";
+import { computeFilterKey } from "./filterKey";
+const OLD_DATE = "2000-01-01T00:00:00Z";
+const SYNC_STATUS_TABLE = "supastash_sync_marks";
+const SERVER_SYNC_STATUS_TABLE = "supastash_server_sync_marks";
+const getSyncStatusTable = () => {
+    const cfg = getSupastashConfig();
+    return cfg.replicationMode === "server-side"
+        ? SERVER_SYNC_STATUS_TABLE
+        : SYNC_STATUS_TABLE;
+};
+const cleanDate = ({ date, table, column, }) => {
+    const original = date || OLD_DATE;
+    const d = new Date(original);
+    if (Number.isNaN(d?.getTime?.())) {
+        logWarn(`[Supastash] Invalid date string found on the ${column} column for ${table}: ${original}`);
+        return original;
+    }
+    return original;
+};
+const cleanSyncStatus = (syncStatus) => {
+    const cfg = getSupastashConfig();
+    const lastSyncedAtColumn = cfg.replicationMode === "server-side" ? "arrived_at" : "updated_at";
+    return {
+        ...syncStatus,
+        last_synced_at: cleanDate({
+            date: syncStatus.last_synced_at,
+            table: syncStatus.table_name,
+            column: lastSyncedAtColumn,
+        }),
+        last_deleted_at: cleanDate({
+            date: syncStatus.last_deleted_at || OLD_DATE,
+            table: syncStatus.table_name,
+            column: "deleted_at",
+        }),
+    };
+};
+export async function ensureSyncMarksTable() {
+    await createSyncStatusTable();
+}
+export async function selectMarks(db, table, filterKey) {
+    const syncStatusTable = getSyncStatusTable();
+    return db.getFirstAsync(`SELECT * FROM ${syncStatusTable} WHERE table_name=? AND filter_key=?`, [table, filterKey]);
+}
+export async function selectSyncStatus(db, table, tableFilters) {
+    const filterKey = await computeFilterKey(tableFilters ?? []);
+    const syncStatusTable = getSyncStatusTable();
+    const result = await db.getFirstAsync(`SELECT * FROM ${syncStatusTable} WHERE table_name=? AND filter_key=?`, [table, filterKey]);
+    if (result) {
+        return cleanSyncStatus(result);
+    }
+    return {
+        table_name: table,
+        filter_key: filterKey,
+        filter_json: "{}",
+        last_synced_at: OLD_DATE,
+        last_synced_at_pk: null,
+        last_deleted_at: OLD_DATE,
+    };
+}
+export async function upsertMarks(db, row) {
+    const { table_name, filter_key, filter_json = null, last_synced_at = null, last_deleted_at = null, last_synced_at_pk = null, } = row;
+    const syncStatusTable = getSyncStatusTable();
+    return db.runAsync(`INSERT INTO ${syncStatusTable}
+       (table_name, filter_key, filter_json, last_synced_at, last_deleted_at, updated_at, last_synced_at_pk)
+       VALUES (?,?,?,?,?,datetime('now'),?)
+       ON CONFLICT(table_name, filter_key) DO UPDATE SET
+         filter_json     = excluded.filter_json,
+         last_synced_at  = COALESCE(excluded.last_synced_at,  ${syncStatusTable}.last_synced_at),
+         last_deleted_at = COALESCE(excluded.last_deleted_at, ${syncStatusTable}.last_deleted_at),
+         updated_at      = datetime('now'),
+         last_synced_at_pk = COALESCE(excluded.last_synced_at_pk, ${syncStatusTable}.last_synced_at_pk)`, [
+        table_name,
+        filter_key,
+        filter_json,
+        last_synced_at,
+        last_deleted_at,
+        last_synced_at_pk,
+    ]);
+}
+export async function resetColumn(db, table, filterKey, col, value, filterJson) {
+    const syncStatusTable = getSyncStatusTable();
+    return db.runAsync(`INSERT INTO ${syncStatusTable} (table_name, filter_key, filter_json, ${col}, updated_at)
+       VALUES (?,?,?,?,datetime('now'))
+       ON CONFLICT(table_name, filter_key) DO UPDATE SET
+         filter_json = excluded.filter_json,
+         ${col}      = excluded.${col},
+         updated_at  = datetime('now')`, [table, filterKey, filterJson, value]);
+}
+export async function deleteMarks(db, table, filterKey) {
+    const syncStatusTable = getSyncStatusTable();
+    return filterKey
+        ? db.runAsync(`DELETE FROM ${syncStatusTable} WHERE table_name=? AND filter_key=?`, [table, filterKey])
+        : db.runAsync(`DELETE FROM ${syncStatusTable} WHERE table_name=?`, [table]);
+}

package/dist/native/utils/sync/status/services.d.ts

@@ -0,0 +1,31 @@
+import { SupastashFilter } from "../../../../shared/types/realtimeData.types";
+import { PublicScope, SupastashSyncStatus } from "../../../../shared/types/syncEngine.types";
+/**
+ * Gets the supastash sync status for a given table and filters
+ * @param table - The name of the table to get the sync status for
+ * @param filters - The filters to apply to the sync status
+ * @returns The supastash sync status
+ */
+export declare function getSupastashSyncStatus(table: string, filters?: SupastashFilter[]): Promise<SupastashSyncStatus | null>;
+export declare function setSupastashSyncStatus(table: string, filters: SupastashFilter[] | undefined, opts: {
+    lastSyncedAt?: string | null;
+    lastDeletedAt?: string | null;
+    lastSyncedAtPk?: string | null;
+    filterNamespace?: string;
+}): Promise<void>;
+/**
+ * Resets the supastash sync status for a given table and filters
+ * @param table - The name of the table to reset the sync status for
+ * @param filters - The filters to apply to the sync status
+ * @param scope - The scope to reset the sync status for
+ * @returns The supastash sync status
+ */
+export declare function resetSupastashSyncStatus(table: string, filters: SupastashFilter[] | undefined, scope?: PublicScope): Promise<void>;
+/**
+ * Clears the supastash sync status for a given table and filters
+ * @param table - The name of the table to clear the sync status for
+ * @param filters - The filters to apply to the sync status
+ * @returns The supastash sync status
+ */
+export declare function clearSupastashSyncStatus(table: string, filters?: SupastashFilter[]): Promise<void>;
+//# sourceMappingURL=services.d.ts.map

package/dist/native/utils/sync/status/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/status/services.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,6CAA6C,CAAC;AAC9E,OAAO,EACL,WAAW,EACX,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAmBnD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,EAAE,GAC1B,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAWrC;AAED,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,eAAe,EAAE,GAAG,SAAS,EACtC,IAAI,EAAE;IACJ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,iBAyCF;AAED;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,eAAe,EAAE,GAAG,SAAS,EACtC,KAAK,GAAE,WAAmB,iBAmB3B;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,EAAE,iBAY5B"}

package/dist/native/utils/sync/status/services.js

@@ -0,0 +1,107 @@
+import { getSupastashDb } from "../../../../shared/db/dbInitializer";
+import { tableFilters } from "../../../../shared/store/tableFilters";
+import { logError, logWarn } from "../../../../shared/utils/logs";
+import { canonicalizeFilters, computeFilterKey } from "./filterKey";
+import { deleteMarks, ensureSyncMarksTable, resetColumn, selectMarks, upsertMarks, } from "./repo";
+const maxIso = (a, b) => {
+    if (!a)
+        return b ?? null;
+    if (!b)
+        return a ?? null;
+    return Date.parse(b) > Date.parse(a) ? b : a;
+};
+const OLD_DATE = "2000-01-01T00:00:00Z";
+/**
+ * Gets the supastash sync status for a given table and filters
+ * @param table - The name of the table to get the sync status for
+ * @param filters - The filters to apply to the sync status
+ * @returns The supastash sync status
+ */
+export async function getSupastashSyncStatus(table, filters) {
+    try {
+        const filterToUse = filters ?? tableFilters.get(table) ?? [];
+        const db = await getSupastashDb();
+        await ensureSyncMarksTable();
+        const fk = await computeFilterKey(filterToUse);
+        return await selectMarks(db, table, fk);
+    }
+    catch (e) {
+        logError(`[Supastash] getMarks(${table}) failed`, e);
+        return null;
+    }
+}
+export async function setSupastashSyncStatus(table, filters, opts) {
+    try {
+        const db = await getSupastashDb();
+        await ensureSyncMarksTable();
+        const filterToUse = filters ?? tableFilters.get(table) ?? [];
+        const ns = opts.filterNamespace ?? "global";
+        const fk = await computeFilterKey(filterToUse, ns);
+        const filterJson = canonicalizeFilters(filterToUse);
+        const existing = await selectMarks(db, table, fk);
+        const nextLastSynced = opts.lastSyncedAt !== undefined
+            ? maxIso(opts.lastSyncedAt, existing?.last_synced_at ?? null)
+            : existing?.last_synced_at ?? null;
+        const nextLastDeleted = opts.lastDeletedAt !== undefined
+            ? maxIso(opts.lastDeletedAt, existing?.last_deleted_at ?? null)
+            : existing?.last_deleted_at ?? null;
+        await upsertMarks(db, {
+            table_name: table,
+            filter_key: fk,
+            filter_json: filterJson,
+            last_synced_at_pk: opts.lastSyncedAtPk ?? undefined,
+            last_synced_at: nextLastSynced ?? undefined,
+            last_deleted_at: nextLastDeleted ?? undefined,
+        });
+        if (!opts.lastSyncedAt && !opts.lastDeletedAt) {
+            logWarn(`[Supastash] setSupastashSyncStatus(${table}): no fields provided`);
+        }
+    }
+    catch (e) {
+        logError(`[Supastash] setSupastashSyncStatus(${table}) failed`, e);
+    }
+}
+/**
+ * Resets the supastash sync status for a given table and filters
+ * @param table - The name of the table to reset the sync status for
+ * @param filters - The filters to apply to the sync status
+ * @param scope - The scope to reset the sync status for
+ * @returns The supastash sync status
+ */
+export async function resetSupastashSyncStatus(table, filters, scope = "all") {
+    try {
+        const db = await getSupastashDb();
+        await ensureSyncMarksTable();
+        const filterToUse = filters ?? tableFilters.get(table) ?? [];
+        const fk = await computeFilterKey(filterToUse);
+        const filterJson = canonicalizeFilters(filterToUse);
+        if (scope === "all") {
+            await resetColumn(db, table, fk, "last_synced_at", OLD_DATE, filterJson);
+            await resetColumn(db, table, fk, "last_deleted_at", OLD_DATE, filterJson);
+        }
+        else {
+            await resetColumn(db, table, fk, scope, OLD_DATE, filterJson);
+        }
+    }
+    catch (e) {
+        logError(`[Supastash] resetMarks(${table}, ${scope}) failed`, e);
+    }
+}
+/**
+ * Clears the supastash sync status for a given table and filters
+ * @param table - The name of the table to clear the sync status for
+ * @param filters - The filters to apply to the sync status
+ * @returns The supastash sync status
+ */
+export async function clearSupastashSyncStatus(table, filters) {
+    try {
+        const filterToUse = filters ?? tableFilters.get(table) ?? [];
+        const db = await getSupastashDb();
+        await ensureSyncMarksTable();
+        const fk = filterToUse ? await computeFilterKey(filterToUse) : undefined;
+        await deleteMarks(db, table, fk);
+    }
+    catch (e) {
+        logError(`[Supastash] clearMarks(${table}) failed`, e);
+    }
+}