supastash 0.2.0 → 0.2.1

package/dist/native/utils/fetchData/eventQueues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventQueues.d.ts","sourceRoot":"","sources":["../../../../src/native/utils/fetchData/eventQueues.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAK3E,iBAAS,cAAc,CAAC,CAAC,EACvB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,EAC3B,eAAe,EAAE,MAAM,eA8CU,MAAM,QAAQ,WAAW,UAgB3D;AAED,eAAe,cAAc,CAAC"}

package/dist/native/utils/fetchData/eventQueues.js

@@ -0,0 +1,52 @@
+import { useRef } from "react";
+import useDataState from "../../../shared/utils/fetchData/dataState";
+import { deleteData } from "../../../shared/utils/fetchData/deleteData";
+import { receiveData } from "./receiveData";
+function useEventQueues(table, options, flushIntervalMs) {
+    const { dataMap } = useDataState(table);
+    const insertQueue = useRef([]);
+    const updateQueue = useRef([]);
+    const deleteQueue = useRef([]);
+    const flushTimer = useRef(null);
+    const flush = () => {
+        if (options.shouldFetch) {
+            insertQueue.current.forEach((item) => {
+                receiveData(item, table, options.shouldFetch, options.onInsertAndUpdate || options.onInsert);
+            });
+            updateQueue.current.forEach((item) => {
+                receiveData(item, table, options.shouldFetch, options.onInsertAndUpdate || options.onInsert);
+            });
+            deleteQueue.current.forEach((item) => {
+                deleteData(item, table, options.shouldFetch);
+                options.onDelete?.(item);
+            });
+            insertQueue.current = [];
+            updateQueue.current = [];
+            deleteQueue.current = [];
+        }
+    };
+    const scheduleFlush = () => {
+        if (!flushTimer.current) {
+            flushTimer.current = setTimeout(() => {
+                flush();
+                flushTimer.current = null;
+            }, flushIntervalMs);
+        }
+    };
+    const queueHandler = (eventType, data) => {
+        switch (eventType) {
+            case "INSERT":
+                insertQueue.current.push(data);
+                break;
+            case "UPDATE":
+                updateQueue.current.push(data);
+                break;
+            case "DELETE":
+                deleteQueue.current.push(data);
+                break;
+        }
+        scheduleFlush();
+    };
+    return queueHandler;
+}
+export default useEventQueues;

package/dist/native/utils/fetchData/fetchCalls.d.ts

@@ -0,0 +1,9 @@
+import { RealtimeOptions } from "../../../shared/types/realtimeData.types";
+export declare function fetchCalls<R = any>(table: string, options: RealtimeOptions<R>, initialized: React.RefObject<boolean>): {
+    triggerRefresh: () => Promise<void>;
+    trigger: () => void;
+    cancel: () => void;
+    initialFetchAndSync: () => Promise<void>;
+    isFetching: boolean;
+};
+//# sourceMappingURL=fetchCalls.d.ts.map

package/dist/native/utils/fetchData/fetchCalls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchCalls.d.ts","sourceRoot":"","sources":["../../../../src/native/utils/fetchData/fetchCalls.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,eAAe,EAEhB,MAAM,0CAA0C,CAAC;AAKlD,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAChC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,EAC3B,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC;;;;;;EA4GtC"}

package/dist/native/utils/fetchData/fetchCalls.js

@@ -0,0 +1,88 @@
+import { useEffect, useRef, useState } from "react";
+import { syncCalls } from "../../../shared/store/syncCalls";
+import { tableFilters, tableFiltersUsed, } from "../../../shared/store/tableFilters";
+import { fetchLocalData } from "../../../shared/utils/fetchData/fetchLocalData";
+import { logError } from "../../../shared/utils/logs";
+import { initialFetch } from "./initialFetch";
+export function fetchCalls(table, options, initialized) {
+    const { shouldFetch = true, limit, filter, onPushToRemote, onInsertAndUpdate, useFilterWhileSyncing = true, extraMapKeys, daylength, onlyUseFilterForRealtime, orderBy, orderDesc, sqlFilter, } = options;
+    const cancelled = useRef(false);
+    const [isFetching, setIsFetching] = useState(false);
+    useEffect(() => {
+        if (filter && useFilterWhileSyncing && !tableFiltersUsed.has(table)) {
+            tableFilters.set(table, [filter]);
+        }
+        if (onPushToRemote && !syncCalls.get(table)?.push) {
+            syncCalls.set(table, {
+                ...(syncCalls.get(table) || {}),
+                push: onPushToRemote,
+            });
+        }
+        if (onInsertAndUpdate && !syncCalls.get(table)?.pull) {
+            syncCalls.set(table, {
+                ...(syncCalls.get(table) || {}),
+                pull: onInsertAndUpdate,
+            });
+        }
+    }, [filter]);
+    const fetch = async () => {
+        let filters;
+        if (sqlFilter) {
+            filters = sqlFilter;
+        }
+        else if (tableFilters.has(table)) {
+            filters = tableFilters.get(table);
+        }
+        else if (!onlyUseFilterForRealtime) {
+            filters = filter ? [filter] : undefined;
+        }
+        if (!cancelled.current) {
+            await fetchLocalData(table, shouldFetch, limit, extraMapKeys, daylength, filters, orderBy ?? "created_at", orderDesc ?? true);
+        }
+    };
+    const trigger = () => {
+        if (!initialized.current) {
+            initialized.current = true;
+            cancelled.current = false;
+            fetch();
+        }
+    };
+    const cancel = () => {
+        cancelled.current = true;
+    };
+    const triggerRefresh = async () => {
+        await fetch();
+    };
+    const initialFetchAndSync = async () => {
+        if (!shouldFetch || cancelled.current)
+            return;
+        let filters;
+        if (sqlFilter) {
+            filters = sqlFilter;
+        }
+        else if (tableFilters.has(table)) {
+            filters = tableFilters.get(table);
+        }
+        else if (!onlyUseFilterForRealtime) {
+            filters = filter ? [filter] : undefined;
+        }
+        try {
+            setIsFetching(true);
+            await initialFetch(table, filters, onInsertAndUpdate, onPushToRemote);
+            await fetch();
+        }
+        catch (error) {
+            logError(`[Supastash] Error on initial fetch for ${table}`, error);
+        }
+        finally {
+            setIsFetching(false);
+        }
+    };
+    return {
+        triggerRefresh,
+        trigger,
+        cancel,
+        initialFetchAndSync,
+        isFetching,
+    };
+}

package/dist/native/utils/fetchData/initialFetch.d.ts

@@ -0,0 +1,3 @@
+import { SupastashFilter } from "../../../shared/types/realtimeData.types";
+export declare function initialFetch(table: string, filter?: SupastashFilter[], onReceiveData?: (payload: any) => Promise<void>, onPushToRemote?: (payload: any[]) => Promise<boolean>): Promise<void>;
+//# sourceMappingURL=initialFetch.d.ts.map

package/dist/native/utils/fetchData/initialFetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialFetch.d.ts","sourceRoot":"","sources":["../../../../src/native/utils/fetchData/initialFetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAQ3E,wBAAsB,YAAY,CAChC,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,eAAe,EAAE,EAC1B,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,EAC/C,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,iBAatD"}

package/dist/native/utils/fetchData/initialFetch.js

@@ -0,0 +1,21 @@
+import { createTable } from "../../../shared/utils/fetchData/createTable";
+import { logError } from "../../../shared/utils/logs";
+import { updateLocalDb } from "../sync/pullFromRemote/updateLocalDb";
+import { pushLocalDataToRemote } from "../sync/pushLocal/sendUnsyncedToSupabase";
+let isInSync = new Map();
+export async function initialFetch(table, filter, onReceiveData, onPushToRemote) {
+    if (isInSync.get(table))
+        return;
+    isInSync.set(table, true);
+    try {
+        await createTable(table);
+        await updateLocalDb(table, filter, onReceiveData);
+        await pushLocalDataToRemote(table, onPushToRemote);
+    }
+    catch (error) {
+        logError(`[Supastash] Error on initial fetch for ${table}`, error);
+    }
+    finally {
+        isInSync.delete(table);
+    }
+}

package/dist/native/utils/fetchData/receiveData.d.ts

@@ -0,0 +1,3 @@
+import { PayloadData } from "../../../shared/types/query.types";
+export declare function receiveData(payload: PayloadData, table: string, shouldFetch?: boolean, upsertCall?: (item: any) => void | Promise<void>): Promise<void>;
+//# sourceMappingURL=receiveData.d.ts.map

package/dist/native/utils/fetchData/receiveData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receiveData.d.ts","sourceRoot":"","sources":["../../../../src/native/utils/fetchData/receiveData.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAShE,wBAAsB,WAAW,CAC/B,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,MAAM,EACb,WAAW,GAAE,OAAc,EAC3B,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,iBAuCjD"}

package/dist/native/utils/fetchData/receiveData.js

@@ -0,0 +1,39 @@
+import { getSupastashDb } from "../../../shared/db/dbInitializer";
+import { createTable } from "../../../shared/utils/fetchData/createTable";
+import log, { logError } from "../../../shared/utils/logs";
+import { refreshScreen } from "../../../shared/utils/refreshScreenCalls";
+import { checkIfTableExist } from "../../../shared/utils/tableValidator";
+import { upsertData } from "../sync/pullFromRemote/updateLocalDb";
+const DEFAULT_DATE = "1970-01-01T00:00:00Z";
+export async function receiveData(payload, table, shouldFetch = true, upsertCall) {
+    if (!shouldFetch)
+        return;
+    try {
+        const db = await getSupastashDb();
+        const exist = await checkIfTableExist(table);
+        if (!exist) {
+            await createTable(table, payload);
+        }
+        if (!payload?.id)
+            return;
+        const existingData = await db.getFirstAsync(`SELECT * FROM ${table} WHERE id = ?`, [payload.id]);
+        if (existingData &&
+            new Date(existingData.updated_at || DEFAULT_DATE).getTime() >=
+                new Date(payload.updated_at || DEFAULT_DATE).getTime()) {
+            return;
+        }
+        log(`[Supastash] Receiving data for ${table} with id ${payload.id}`);
+        log(`[Supastash] Payload:`, payload);
+        // Update the data
+        if (upsertCall) {
+            await upsertCall(payload);
+        }
+        else {
+            await upsertData({ table, record: payload });
+        }
+        refreshScreen(table);
+    }
+    catch (error) {
+        logError("[Supastash] Error receiving data:", error);
+    }
+}

package/dist/native/utils/query/index.d.ts

@@ -0,0 +1,73 @@
+import { CrudMethods, PayloadData, SupastashQuery } from "../../../shared/types/query.types";
+import SupastashCrudBuilder from "../../../shared/utils/query/builder/crud";
+/**
+ * Builder for the supastash query
+ * @param T - The method to call
+ * @param U - Whether to return a single row or multiple rows
+ */
+export declare class SupastashQueryBuilder<T extends CrudMethods, U extends boolean, R> {
+    private readonly query;
+    /**
+     * Constructor for the supastash query builder
+     * @param query - The query to build
+     */
+    constructor(query: SupastashQuery<T, U, R>);
+    /**
+     * Sets the table to query.
+     *
+     * @param table - The table to query.
+     * @returns crud options.
+     */
+    from(table: string): SupastashCrudBuilder<T, U, R>;
+    /**
+     * Executes multiple Supastash operations inside a single SQLite transaction.
+     *
+     * ⚠️ Do NOT call this inside `db.withTransaction(...)`
+     *  or another `supastash.withTransaction(...)`.
+     * Nested transactions are not supported and will throw.
+     *
+     * All queries executed using the provided `tx` builder
+     * will share the same SQLite transaction and `txId`.
+     *
+     * If any operation inside the callback throws,
+     * the entire transaction is rolled back automatically.
+     *
+     * Example:
+     *
+     * await supastash.withTransaction(async (tx) => {
+     *   await tx.from("orders").insert(order).run();
+     *   await tx.from("ledger").insert(ledgerEntry).run();
+     * });
+     *
+     *
+     * In this example, both inserts succeed or both fail.
+     */
+    withTransaction(fn: (tx: SupastashTransactionalBuilder<T, U, R>) => Promise<void> | void): Promise<void>;
+}
+type SupastashTransactionalBuilder<T extends CrudMethods, U extends boolean, R> = Omit<SupastashQueryBuilder<T, U, R>, "withTransaction">;
+export type SupastashTransactionClient = SupastashTransactionalBuilder<CrudMethods, boolean, PayloadData>;
+export type SupastashClient = SupastashTransactionalBuilder<CrudMethods, boolean, PayloadData>;
+/**
+ * Supastash query builder for local-first CRUD operations.
+ *
+ * This builder allows you to construct and execute queries against a local SQLite store
+ * with optional synchronization to Supabase.
+ *
+ * Notes:
+ * - SELECT operations return local data by default unless `sync mode` is set to "remoteOnly".
+ * - `.run()` (alias of `.execute()`) is **required** to finalize and perform the query.
+ * - Use `.run({ viewRemoteResult: true })` to view the remote result from Supabase.
+ * - All operations except DELETE return local data automatically — no need to chain `.select()`.
+ *
+ * @returns A chainable Supastash query instance.
+ *
+ * @example
+ * const result = await supastash
+ *   .from("users")
+ *   .update<T>({ name: "John Doe" })
+ *   .eq("id", "1")
+ *   .run(); // Required to execute the query
+ */
+export declare const supastash: SupastashQueryBuilder<CrudMethods, boolean, any>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/native/utils/query/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/native/utils/query/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,WAAW,EAEX,WAAW,EACX,cAAc,EAEf,MAAM,mCAAmC,CAAC;AAE3C,OAAO,oBAAoB,MAAM,0CAA0C,CAAC;AAI5E;;;;GAIG;AACH,qBAAa,qBAAqB,CAChC,CAAC,SAAS,WAAW,EACrB,CAAC,SAAS,OAAO,EACjB,CAAC;IAED,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0B;IAEhD;;;OAGG;gBACS,KAAK,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAI1C;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM;IAOlB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,eAAe,CACb,EAAE,EAAE,CAAC,EAAE,EAAE,6BAA6B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;CAgD3E;AAED,KAAK,6BAA6B,CAChC,CAAC,SAAS,WAAW,EACrB,CAAC,SAAS,OAAO,EACjB,CAAC,IACC,IAAI,CAAC,qBAAqB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC;AAE5D,MAAM,MAAM,0BAA0B,GAAG,6BAA6B,CACpE,WAAW,EACX,OAAO,EACP,WAAW,CACZ,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,6BAA6B,CACzD,WAAW,EACX,OAAO,EACP,WAAW,CACZ,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS,kDAyBiC,CAAC"}

package/dist/native/utils/query/index.js

@@ -0,0 +1,139 @@
+import { txStore } from "../../../shared/store/tx";
+import { generateUUIDv4 } from "../../../shared/utils/genUUID";
+import SupastashCrudBuilder from "../../../shared/utils/query/builder/crud";
+import { queueRemoteCall } from "../../../shared/utils/query/helpers/queueRemote";
+import { getSupastashDb } from "../../db/dbInitializer";
+/**
+ * Builder for the supastash query
+ * @param T - The method to call
+ * @param U - Whether to return a single row or multiple rows
+ */
+export class SupastashQueryBuilder {
+    /**
+     * Constructor for the supastash query builder
+     * @param query - The query to build
+     */
+    constructor(query) {
+        this.query = query;
+    }
+    /**
+     * Sets the table to query.
+     *
+     * @param table - The table to query.
+     * @returns crud options.
+     */
+    from(table) {
+        const id = generateUUIDv4();
+        getSupastashDb();
+        const newQuery = { ...this.query, table, id };
+        return new SupastashCrudBuilder(newQuery);
+    }
+    /**
+     * Executes multiple Supastash operations inside a single SQLite transaction.
+     *
+     * ⚠️ Do NOT call this inside `db.withTransaction(...)`
+     *  or another `supastash.withTransaction(...)`.
+     * Nested transactions are not supported and will throw.
+     *
+     * All queries executed using the provided `tx` builder
+     * will share the same SQLite transaction and `txId`.
+     *
+     * If any operation inside the callback throws,
+     * the entire transaction is rolled back automatically.
+     *
+     * Example:
+     *
+     * await supastash.withTransaction(async (tx) => {
+     *   await tx.from("orders").insert(order).run();
+     *   await tx.from("ledger").insert(ledgerEntry).run();
+     * });
+     *
+     *
+     * In this example, both inserts succeed or both fail.
+     */
+    withTransaction(fn) {
+        const query = async () => {
+            // Create a new transaction id
+            const newTxId = generateUUIDv4();
+            try {
+                const db = await getSupastashDb();
+                // Add the transaction to the store
+                txStore[newTxId] = [];
+                // Execute the local calls
+                await db.withTransaction(async (tx) => {
+                    const txQuery = {
+                        ...this.query,
+                        txId: newTxId,
+                        tx,
+                        throwOnError: true, // Throw the error to roll back the transaction
+                    };
+                    const txBuilder = new SupastashQueryBuilder(txQuery);
+                    return fn(txBuilder);
+                });
+                // Execute the remote calls
+                const remoteCalls = txStore[newTxId] ?? [];
+                if (remoteCalls.length > 0) {
+                    const newStates = remoteCalls.map((call) => {
+                        return {
+                            ...call,
+                            txId: null,
+                            tx: null,
+                            withTx: false,
+                            type: "remoteOnly",
+                        };
+                    });
+                    for (const state of newStates) {
+                        queueRemoteCall(state);
+                    }
+                }
+            }
+            finally {
+                // Delete the transaction from the store
+                delete txStore[newTxId];
+            }
+        };
+        return query();
+    }
+}
+/**
+ * Supastash query builder for local-first CRUD operations.
+ *
+ * This builder allows you to construct and execute queries against a local SQLite store
+ * with optional synchronization to Supabase.
+ *
+ * Notes:
+ * - SELECT operations return local data by default unless `sync mode` is set to "remoteOnly".
+ * - `.run()` (alias of `.execute()`) is **required** to finalize and perform the query.
+ * - Use `.run({ viewRemoteResult: true })` to view the remote result from Supabase.
+ * - All operations except DELETE return local data automatically — no need to chain `.select()`.
+ *
+ * @returns A chainable Supastash query instance.
+ *
+ * @example
+ * const result = await supastash
+ *   .from("users")
+ *   .update<T>({ name: "John Doe" })
+ *   .eq("id", "1")
+ *   .run(); // Required to execute the query
+ */
+export const supastash = new SupastashQueryBuilder({
+    id: generateUUIDv4(),
+    table: "",
+    method: "none",
+    payload: null,
+    filters: [],
+    limit: null,
+    select: null,
+    isSingle: false,
+    type: "localFirst",
+    runSelected: false,
+    viewRemoteResult: false,
+    onConflictKeys: ["id"],
+    preserveTimestamp: false,
+    throwOnError: false,
+    fetchPolicy: null,
+    // With tx
+    txId: null,
+    tx: null,
+    withTx: false,
+});

package/dist/native/utils/schema/wipeTables.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Wipes a specific table from the local SQLite database and removes its sync metadata.
+ *
+ * ⚠️ WARNING: This is a destructive operation. It should only be used in development mode,
+ * as it will permanently delete all local data for the specified table.
+ *
+ * @param tableName - Name of the table to drop.
+ *
+ * @example
+ * configureSupastash({
+ *   ...
+ *   onSchemaInit: async () => {
+ *     await wipeTable("users"); // dev-only: clears the "users" table on app start
+ *   }
+ * });
+ */
+export declare function wipeTable(tableName: string): Promise<void>;
+/**
+ * Drops a specific table from the local SQLite database and removes its sync metadata.
+ *
+ * ⚠️ WARNING: This is a destructive operation. It should only be used in development mode,
+ * as it will permanently delete all local data for the specified table.
+ *
+ * @param tableName - Name of the table to drop.
+ *
+ * @example
+ * configureSupastash({
+ *   ...
+ *   onSchemaInit: async () => {
+ *     await dropTable("users"); // dev-only: drops the "users" table on app start
+ *   }
+ * });
+ */
+export declare function dropTable(tableName: string): Promise<void>;
+/**
+ * Drops all tables from the local SQLite database and removes their sync metadata.
+ *
+ * ⚠️ WARNING: This is a destructive operation. It should only be used in development mode,
+ * as it will permanently delete all local data for all tables.
+ *
+ * @example
+ */
+export declare function dropAllTables(): Promise<void>;
+/**
+ * Wipes all local tables managed by Supastash and clears associated sync metadata.
+ *
+ * ⚠️ WARNING: This will irreversibly delete all local tables and their data.
+ * Intended only for development or reset scenarios.
+ *
+ * @example
+ * configureSupastash({
+ *   ...
+ *   onSchemaInit: async () => {
+ *     await wipeAllTables(); // dev-only: clears all local tables on app start
+ *   }
+ * });
+ */
+export declare function wipeAllTables(): Promise<void>;
+/**
+ * Wipes old rows from a specified table based on the `created_at` timestamp.
+ *
+ * This is useful for maintaining a lean local cache by removing stale data
+ * during Supastash initialization or periodic syncs.
+ *
+ * @param tableName - Name of the table to clean up (must have a `created_at` column).
+ * @param daysFromNow - Number of days to retain; older rows will be deleted.
+ *
+ * @example
+ * ```ts
+ * // Typically used during Supastash schema setup:
+ * configureSupastash({
+ *   ...,
+ *   onSchemaInit: async () => {
+ *     await wipeOldDataForATable("users", 30);
+ *     // Removes all rows in "users" created more than 30 days ago
+ *   }
+ * });
+ * ```
+ */
+export declare function wipeOldDataForATable(tableName: string, daysFromNow: number): Promise<void>;
+/**
+ * Deletes old records (based on `created_at`) from all tables, excluding those specified.
+ *
+ * Only records older than the given number of days will be removed.
+ *
+ * @param daysFromNow - Cutoff age in days; records older than this will be deleted.
+ * @param excludeTables - Optional array of table names to skip during cleanup.
+ *
+ * @example
+ * configureSupastash({
+ *   ...
+ *   onSchemaInit: async () => {
+ *     await wipeOldDataForAllTables(30, ["app_settings"]); // skips wiping "app_settings"
+ *   }
+ * });
+ */
+export declare function wipeOldDataForAllTables(daysFromNow: number, excludeTables?: string[]): Promise<void>;
+//# sourceMappingURL=wipeTables.d.ts.map

package/dist/native/utils/schema/wipeTables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wipeTables.d.ts","sourceRoot":"","sources":["../../../../src/native/utils/schema/wipeTables.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,SAAS,CAAC,SAAS,EAAE,MAAM,iBAWhD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,SAAS,CAAC,SAAS,EAAE,MAAM,iBAWhD;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,kBAalC;AAED;;;;;;;;;;;;;GAaG;AAEH,wBAAsB,aAAa,kBAalC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,iBAyBpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,uBAAuB,CAC3C,WAAW,EAAE,MAAM,EACnB,aAAa,GAAE,MAAM,EAAO,iBAiB7B"}