supastash 0.2.0 → 0.2.2

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EACL,aAAa,EACb,SAAS,EACT,aAAa,EACb,uBAAuB,EACvB,oBAAoB,EACpB,SAAS,GACV,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EACL,aAAa,EACb,UAAU,GACX,MAAM,2CAA2C,CAAC;AACnD,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EACZ,iBAAiB,EACjB,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,UAAU,GACX,MAAM,gCAAgC,CAAC;AAExC,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,eAAe,GAChB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EACV,eAAe,EACf,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,YAAY,GACb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EACL,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAChF,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,uBAAuB,GACxB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEzD,YAAY,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,eAAe,GAChB,MAAM,mCAAmC,CAAC;AAC3C,YAAY,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAChF,YAAY,EACV,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,EACvB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,sCAAsC,CAAC;AAC9C,YAAY,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAChE,YAAY,EACV,eAAe,EACf,0BAA0B,GAC3B,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -1,22 +1,12 @@
-export { configureSupastash, getSupastashConfig } from "./core/config";
-export { defineLocalSchema } from "./core/schemaManager";
-export { getSupastashDb } from "./db/dbInitializer";
-export { useSupastashData } from "./hooks/supastashData";
-//export { useSupastashLiteQuery } from "./hooks/supastashLiteQuery";
-export { useSupastashFilters } from "./hooks/supastashFilters";
-export { useSupastash } from "./hooks/supastashLogic";
-export { syncAllTables, syncTable } from "./hooks/syncEngine";
-export { useSupastashSyncStatus } from "./hooks/syncStatus";
-export { closeSyncGate, isSyncGateClosed, openSyncGate, } from "./store/syncStatus";
-export { supastashEventBus } from "./utils/events/eventBus";
-export { supastash } from "./utils/query/builder";
-export { refreshScreen } from "./utils/refreshScreenCalls";
-export { dropAllTables, dropTable, wipeAllTables, wipeOldDataForAllTables, wipeOldDataForATable, wipeTable, } from "./utils/schema/wipeTables";
-export { getSupastashRuntimeMode, reinitializeSupastash, } from "./utils/supastashMode";
-export { getAllTables } from "./utils/sync/getAllTables";
-export { fetchOlderPage } from "./utils/sync/pullFromRemote/fetchOlder";
-export { updateFilters } from "./utils/sync/pullFromRemote/updateFilter";
-export { updateLocalDb, upsertData, } from "./utils/sync/pullFromRemote/updateLocalDb";
-export { refreshAllTables, refreshTable, refreshTableWithPayload, } from "./utils/sync/refreshTables";
-export { clearSyncCalls, getAllSyncTables, getSyncCall, registerSyncCall, unregisterSyncCall, } from "./utils/sync/registration/syncCalls";
-export { clearAllLocalDeleteLog, clearAllLocalSyncLog, clearLocalDeleteLog, clearLocalSyncLog, clearSyncLog, getLocalDeleteLog, getSyncLog, resetSyncLog, setLocalDeleteLog, setLocalSyncLog, setSyncLog, } from "./utils/sync/status/syncStatus";
+export { configureSupastash, getSupastashConfig } from "./shared/core/config";
+export { useSupastashFilters } from "./shared/hooks/supastashFilters";
+export { useSupastashSyncStatus } from "./shared/hooks/syncStatus";
+export { closeSyncGate, isSyncGateClosed, openSyncGate, } from "./shared/store/syncStatus";
+export { supastashEventBus } from "./shared/utils/events/eventBus";
+export { refreshScreen } from "./shared/utils/refreshScreenCalls";
+export { getSupastashRuntimeMode, reinitializeSupastash, } from "./shared/utils/supastashMode";
+export { getAllTables } from "./shared/utils/sync/getAllTables";
+export { updateFilters } from "./shared/utils/sync/pullFromRemote/updateFilter";
+export { refreshAllTables, refreshTable, refreshTableWithPayload, } from "./shared/utils/sync/refreshTables";
+export { clearSyncCalls, getAllSyncTables, getSyncCall, registerSyncCall, unregisterSyncCall, } from "./shared/utils/sync/registration/syncCalls";
+export { supastash } from "./shared/utils/query/builder";

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

@@ -0,0 +1,40 @@
+import { LocalSchemaDefinition } from "../../../shared/types/schemaManager.types";
+/**
+ * 🧱 defineLocalSchema
+ *
+ * Defines a local SQLite table schema programmatically, with support for foreign keys and indices.
+ * Intended for offline-first apps using Supastash. Ensures consistency in structure and indexing while
+ * allowing runtime control of schema migration through `deletePreviousSchema`.
+ *
+ * It will also create the following indexes:
+ * - synced_at
+ * - deleted_at
+ * - created_at
+ * - updated_at
+ * if they do not exist in the schema and if columns exist in the table.
+ * ---
+ *
+ * @param tableName - The name of the local SQLite table.
+ * @param schema - The column definitions (e.g. `{ id: "TEXT NOT NULL", name: "TEXT" }`) and optional metadata:
+ *   - `__indices`: Column names to be indexed.
+ * @param deletePreviousSchema - If `true`, drops the existing table and related Supastash metadata before re-creating.
+ *   ⚠️ WARNING: If left `true` in production, the table will be dropped and re-created **on every load**.
+ *
+ * ---
+ *
+ * @example
+ * defineLocalSchema("users", {
+ *   id: "TEXT PRIMARY KEY",
+ *   name: "TEXT NOT NULL",
+ *   email: "TEXT",
+ *   user_id: "TEXT NOT NULL",
+ *   __indices: ["email"]
+ * }, true);
+ *
+ * @remarks
+ * - Automatically injects `created_at`, `updated_at`, `deleted_at`, and `synced_at` columns.
+ * - Requires an `id` column to exist.
+ * - Validates all foreign keys and index columns exist in the schema before applying.
+ */
+export declare function defineLocalSchema(tableName: string, schema: LocalSchemaDefinition, deletePreviousSchema?: boolean): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/native/core/schemaManager/index.js

@@ -0,0 +1,141 @@
+import { getSupastashDb } from "../../../shared/db/dbInitializer";
+import { clearSchemaCache } from "../../../shared/utils/getTableSchema";
+import log, { logError } from "../../../shared/utils/logs";
+import { resetSupastashSyncStatus } from "../../utils/sync/status/services";
+/**
+ * 🧱 defineLocalSchema
+ *
+ * Defines a local SQLite table schema programmatically, with support for foreign keys and indices.
+ * Intended for offline-first apps using Supastash. Ensures consistency in structure and indexing while
+ * allowing runtime control of schema migration through `deletePreviousSchema`.
+ *
+ * It will also create the following indexes:
+ * - synced_at
+ * - deleted_at
+ * - created_at
+ * - updated_at
+ * if they do not exist in the schema and if columns exist in the table.
+ * ---
+ *
+ * @param tableName - The name of the local SQLite table.
+ * @param schema - The column definitions (e.g. `{ id: "TEXT NOT NULL", name: "TEXT" }`) and optional metadata:
+ *   - `__indices`: Column names to be indexed.
+ * @param deletePreviousSchema - If `true`, drops the existing table and related Supastash metadata before re-creating.
+ *   ⚠️ WARNING: If left `true` in production, the table will be dropped and re-created **on every load**.
+ *
+ * ---
+ *
+ * @example
+ * defineLocalSchema("users", {
+ *   id: "TEXT PRIMARY KEY",
+ *   name: "TEXT NOT NULL",
+ *   email: "TEXT",
+ *   user_id: "TEXT NOT NULL",
+ *   __indices: ["email"]
+ * }, true);
+ *
+ * @remarks
+ * - Automatically injects `created_at`, `updated_at`, `deleted_at`, and `synced_at` columns.
+ * - Requires an `id` column to exist.
+ * - Validates all foreign keys and index columns exist in the schema before applying.
+ */
+export async function defineLocalSchema(tableName, schema, deletePreviousSchema = false) {
+    try {
+        if (!schema.id) {
+            throw new Error(`'id' of type UUID column is required for table ${tableName}`);
+        }
+        const db = await getSupastashDb();
+        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 = {
+            ...columnSchema,
+            created_at: columnSchema.created_at ?? "TEXT NOT NULL",
+            updated_at: columnSchema.updated_at ?? "TEXT NOT NULL",
+            synced_at: "TEXT DEFAULT NULL",
+            deleted_at: columnSchema.deleted_at ?? "TEXT DEFAULT NULL",
+        };
+        // 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} (${__constraints ? `${schemaString}, ${__constraints}` : schemaString});`;
+        if (deletePreviousSchema) {
+            const dropSql = `DROP TABLE IF EXISTS ${tableName}`;
+            const tryDropTable = async (attempt = 1) => {
+                try {
+                    await db.execAsync(dropSql);
+                    await resetSupastashSyncStatus(tableName, undefined, "all");
+                }
+                catch (err) {
+                    if (String(err).includes("table is locked") && attempt < 5) {
+                        await new Promise((res) => setTimeout(res, attempt * 100));
+                        return tryDropTable(attempt + 1);
+                    }
+                    throw err;
+                }
+            };
+            await tryDropTable();
+            clearSchemaCache(tableName);
+            log(`[Supastash] Dropped table ${tableName}`);
+        }
+        await db.execAsync(sql);
+        const standardIndexes = [
+            "synced_at",
+            "deleted_at",
+            "created_at",
+            "updated_at",
+        ];
+        // Generate and create index SQL
+        if (__indices?.length) {
+            for (const col of __indices) {
+                if (standardIndexes.includes(col)) {
+                    continue;
+                }
+                const indexName = `idx_${tableName}_${col}`;
+                const indexSql = `CREATE INDEX IF NOT EXISTS ${indexName} ON ${tableName}(${col});`;
+                await db.execAsync(indexSql);
+            }
+        }
+        await createStandardIndexes(db, tableName, standardIndexes);
+    }
+    catch (error) {
+        logError(`[Supastash] Error defining schema for table ${tableName}`, error);
+    }
+}
+async function createStandardIndexes(db, table, columns) {
+    const pragmaRows = await db.getAllAsync(`PRAGMA table_info(${table});`);
+    const existingCols = Array.isArray(pragmaRows)
+        ? pragmaRows.map((r) => r.name)
+        : [];
+    try {
+        for (const col of columns) {
+            if (existingCols.includes(col)) {
+                const hasSameIndex = await hasSingleColumnIndex(db, table, col);
+                if (!hasSameIndex) {
+                    await db.execAsync(`CREATE INDEX IF NOT EXISTS idx_${table}_${col} ON ${table}(${col});`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        logError(`[Supastash] Error creating standard indexes for ${table}`, error);
+    }
+}
+async function hasSingleColumnIndex(db, table, col) {
+    const idxList = await db.getAllAsync(`PRAGMA index_list(${table});`);
+    if (!Array.isArray(idxList))
+        return false;
+    for (const idx of idxList) {
+        const idxName = idx.name;
+        const info = await db.getAllAsync(`PRAGMA index_info(${idxName});`);
+        if (!Array.isArray(info))
+            continue;
+        // Single-column index exactly on `col`
+        if (info.length === 1 && info[0]?.name === col)
+            return true;
+    }
+    return false;
+}

package/dist/native/hooks/supastashData.d.ts

@@ -0,0 +1,67 @@
+import { RealtimeOptions, SupastashDataResult } from "../../shared/types/realtimeData.types";
+/**
+ * @description
+ * React hook to sync and subscribe to local-first data from a Supabase table using Supastash.
+ *
+ * Use `useSupastashData` when you want:
+ * - Offline-first reads from local SQLite.
+ * - Optional realtime syncing via Supabase `postgres_changes`.
+ * - Batching, lazy loading, and event-driven updates.
+ *
+ * @example
+ * ```tsx
+ * const { data, dataMap, trigger, cancel } = useSupastashData("users", {
+ *   shouldFetch: !!session?.user,
+ *   lazy: true,
+ *   limit: 100,
+ *   orderBy: "created_at",
+ *   orderDesc: true,
+ *   sqlFilter: [
+ *     { column: "user_id", operator: "eq", value: 1 },
+ *     { column: "is_active", operator: "eq", value: true },
+ *   ],
+ *   onInsert: (user) => console.log("New user:", user),
+ * });
+ *
+ * useEffect(() => {
+ *   trigger(); // Manually start sync
+ * }, []);
+ * ```
+ *
+ * @param table - Name of the table (must match local SQLite schema).
+ * @param options - Configuration object.
+ *
+ * ## Fetch Options
+ * @param options.shouldFetch - If false, disables initial fetch. Defaults to `true`.
+ * @param options.lazy - If true, skips auto-fetch. Call `trigger()` manually.
+ * @param options.limit - Max records to load. Defaults to `200`.
+ * @param options.orderBy - Column to sort by. Defaults to `"created_at"`.
+ * @param options.orderDesc - If true, sorts descending. Defaults to `true`.
+ * @param options.sqlFilter - Optional SQL-level filters (`WHERE` clause).
+ * @param options.useFilterWhileSyncing - Applies filter during sync. Defaults to `true`.
+ * @param options.extraMapKey - Additional field to group `dataMap` by.
+ * @param options.clearCacheOnMount - Clears in-memory cache on mount. Defaults to `false`.
+ *
+ * ## Realtime Options
+ * @param options.realtime - Enables Supabase `postgres_changes` subscription. Defaults to `true`.
+ * @param options.filter - Realtime filter (column/operator/value).
+ * @param options.flushIntervalMs - Flush interval (in ms) for UI updates. Defaults to `100`.
+ *
+ * ## Event Callbacks
+ * @param options.onInsert - Called on `INSERT` event.
+ * @param options.onUpdate - Called on `UPDATE` event.
+ * @param options.onDelete - Called on `DELETE` event.
+ * @param options.onInsertAndUpdate - Called on both `INSERT` and `UPDATE`.
+ * @param options.onPushToRemote - Called after pushing a local change to Supabase.
+ *
+ * @returns {
+ *   data: Array of records,
+ *   dataMap: Map of records by ID,
+ *   groupedBy: Optional maps grouped by field,
+ *   trigger: Manually trigger sync,
+ *   cancel: Cancel pending fetch or
+ *   isFetching: Whether the data is being fetched
+ * }
+ */
+export declare function useSupastashData<R = any>(table: string, options?: RealtimeOptions): SupastashDataResult<R>;
+//# sourceMappingURL=supastashData.d.ts.map

package/dist/native/hooks/supastashData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supastashData.d.ts","sourceRoot":"","sources":["../../../src/native/hooks/supastashData.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EACf,mBAAmB,EAEpB,MAAM,uCAAuC,CAAC;AAW/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,GAAG,EACtC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAAoB,GAC5B,mBAAmB,CAAC,CAAC,CAAC,CAwGxB"}

package/dist/{hooks/supastashData/index.js → native/hooks/supastashData.js}

@@ -1,13 +1,13 @@
 import { useEffect, useMemo, useRef } from "react";
 import { AppState } from "react-native";
-import { localCache } from "../../store/localCache";
-import { supastashEventBus } from "../../utils/events/eventBus";
-import useRealtimeData from "../../utils/fetchData/realTimeCall";
-import { ReusedHelpers } from "../../utils/reusedHelpers";
-import { isTrulyNullish } from "../../utils/serializer";
-import useDataState from "./dataState";
-import useEventQueues from "./eventQueues";
-import { fetchCalls } from "./fetchCalls";
+import { localCache } from "../../shared/store/localCache";
+import { supastashEventBus } from "../../shared/utils/events/eventBus";
+import useDataState from "../../shared/utils/fetchData/dataState";
+import useRealtimeData from "../../shared/utils/fetchData/realTimeCall";
+import { ReusedHelpers } from "../../shared/utils/reusedHelpers";
+import { isTrulyNullish } from "../../shared/utils/serializer";
+import useEventQueues from "../utils/fetchData/eventQueues";
+import { fetchCalls } from "../utils/fetchData/fetchCalls";
 const tableSubscriptions = new Map();
 /**
  * @description
@@ -77,6 +77,7 @@ export function useSupastashData(table, options = {}) {
     const { filter, lazy = false, flushIntervalMs = 100, shouldFetch = true, realtime = true, clearCacheOnMount = false, } = options;
     const hasTriggeredRef = useRef(false);
     const unsub = useRef(null);
+    const appStateRef = useRef(null);
     const { dataMap, data, groupedBy, } = useDataState(table);
     const queueHandler = useEventQueues(table, options, flushIntervalMs);
     const { triggerRefresh, trigger, cancel, initialFetchAndSync, isFetching } = fetchCalls(table, options, hasTriggeredRef);
@@ -102,7 +103,7 @@ export function useSupastashData(table, options = {}) {
             if (!isAnyNullish) {
                 initialFetchAndSync();
             }
-            unsub.current = AppState.addEventListener("change", (state) => {
+            appStateRef.current = AppState.addEventListener("change", (state) => {
                 if (state === "active") {
                     if (!isAnyNullish) {
                         void initialFetchAndSync();
@@ -118,11 +119,12 @@ export function useSupastashData(table, options = {}) {
         return () => {
             supastashEventBus.off?.(`refresh:${table}`, triggerRefresh);
             supastashEventBus.off?.(`refresh:all`, triggerRefresh);
-            unsub.current?.remove();
+            unsub.current?.();
             tableSubscriptions.delete(subKey);
             if (clearCacheOnMount) {
                 localCache.delete(table);
             }
+            appStateRef.current?.remove();
         };
     }, [lazy, shouldFetch, subKey, isAnyNullish]);
     // TEMP

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

@@ -0,0 +1,19 @@
+import { SupastashHookReturn } from "../../shared/types/supastashConfig.types";
+/**
+ * React hook to initialize and manage Supastash.
+ *
+ * Responsibilities:
+ * - Initializes the Supastash client.
+ * - Sets up the SQLite database.
+ * - Creates internal sync status tables.
+ * - Invokes the user-defined schema initializer (if provided).
+ * - Starts the sync engine once the DB is ready.
+ *
+ * @returns {{
+ *   dbReady: boolean,
+ *   startSync: () => void,
+ *   stopSync: () => void
+ * }} Object containing the DB readiness state and sync control functions.
+ */
+export declare function useSupastash(lazy?: boolean): SupastashHookReturn;
+//# sourceMappingURL=supastashLogic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"supastashLogic.d.ts","sourceRoot":"","sources":["../../../src/native/hooks/supastashLogic.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAO/E;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,GAAE,OAAe,GAAG,mBAAmB,CAmFvE"}

package/dist/native/hooks/supastashLogic.js

@@ -0,0 +1,101 @@
+import { useEffect, useRef, useState } from "react";
+import { getSupastashConfig } from "../../shared/core/config";
+import { supastashDbErrorMsg } from "../../shared/db/dbErrorMsg";
+import { localCache } from "../../shared/store/localCache";
+import { filterTracker, tableFilters, tableFiltersUsed, } from "../../shared/store/tableFilters";
+import { supastashEventBus } from "../../shared/utils/events/eventBus";
+import { logError, logWarn } from "../../shared/utils/logs";
+import { createSyncStatusTable } from "../../shared/utils/schema/createSyncStatus";
+import { supabaseClientErr } from "../../shared/utils/supabaseClientErr";
+import { useSyncEngine } from "./syncEngine";
+/**
+ * React hook to initialize and manage Supastash.
+ *
+ * Responsibilities:
+ * - Initializes the Supastash client.
+ * - Sets up the SQLite database.
+ * - Creates internal sync status tables.
+ * - Invokes the user-defined schema initializer (if provided).
+ * - Starts the sync engine once the DB is ready.
+ *
+ * @returns {{
+ *   dbReady: boolean,
+ *   startSync: () => void,
+ *   stopSync: () => void
+ * }} Object containing the DB readiness state and sync control functions.
+ */
+export function useSupastash(lazy = false) {
+    const [dbReady, setDbReady] = useState(false);
+    const initialized = useRef(false);
+    const config = getSupastashConfig();
+    const { startSync, stopSync } = useSyncEngine();
+    if (!config.sqliteClient || !config.sqliteClientType) {
+        logError(`
+      [Supastash] ${supastashDbErrorMsg}`);
+        return {
+            dbReady: false,
+            startSync: () => { },
+            stopSync: () => { },
+        };
+    }
+    if (!config.supabaseClient) {
+        logError(`[Supastash] Add a supabase client to config ${supabaseClientErr}`);
+        return {
+            dbReady: false,
+            startSync: () => { },
+            stopSync: () => { },
+        };
+    }
+    useEffect(() => {
+        if (initialized.current)
+            return;
+        initialized.current = true;
+        async function init() {
+            try {
+                // Create supastash metadata tables
+                await createSyncStatusTable();
+                // On schema init
+                if (config.onSchemaInit) {
+                    await config.onSchemaInit();
+                }
+                // If init fails, db will not be ready
+                setDbReady(true);
+            }
+            catch (error) {
+                logError(`[Supastash] Error initializing: ${error}`);
+                setDbReady(false);
+            }
+        }
+        init();
+        return () => {
+            initialized.current = false;
+            filterTracker.clear();
+            tableFilters.clear();
+            tableFiltersUsed.clear();
+            localCache.clear();
+        };
+    }, []);
+    useEffect(() => {
+        if (lazy)
+            return;
+        const start = () => {
+            if (dbReady) {
+                try {
+                    startSync();
+                }
+                catch (error) {
+                    logWarn(`[Supastash] Error starting sync: ${error}`);
+                }
+            }
+        };
+        start();
+        supastashEventBus.on("stopSupastashSync", stopSync);
+        supastashEventBus.on("startSupastashSync", start);
+        return () => {
+            stopSync();
+            supastashEventBus.off("stopSupastashSync", stopSync);
+            supastashEventBus.off("startSupastashSync", start);
+        };
+    }, [dbReady]);
+    return { dbReady, stopSync, startSync };
+}

package/dist/native/hooks/syncEngine.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Push then (optionally) pull.
+ * - Single flight across entire app via module-scoped flags.
+ * - Both directions gated on connectivity.
+ * - "force" ignores pull cadence timing.
+ */
+export declare function syncAll(force?: boolean): Promise<void>;
+/**
+ * Hook to start/stop the periodic sync engine.
+ * - Staggers push & pull timers.
+ * - Debounced foreground trigger.
+ * - Shares module-level single-flight guards with syncAll().
+ */
+export declare function useSyncEngine(): {
+    startSync: () => void;
+    stopSync: () => void;
+};
+/**
+ * Manually sync a single table (pull then push for that table).
+ * - Uses table-specific handlers from syncCalls if provided.
+ * - Respects configured filters when enabled.
+ */
+export declare function syncTable(table: string): Promise<void>;
+/**
+ * Force a global sync pass now (push then pull if due).
+ */
+export declare function syncAllTables(): Promise<void>;
+//# sourceMappingURL=syncEngine.d.ts.map

package/dist/native/hooks/syncEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncEngine.d.ts","sourceRoot":"","sources":["../../../src/native/hooks/syncEngine.ts"],"names":[],"mappings":"AA6BA;;;;;GAKG;AACH,wBAAsB,OAAO,CAAC,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAqCnE;AAuDD;;;;;GAKG;AACH,wBAAgB,aAAa;;;EA+D5B;AAMD;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgC5D;AAED;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAEnD"}

package/dist/{hooks/syncEngine/index.js → native/hooks/syncEngine.js}

@@ -1,15 +1,15 @@
 import { useEffect, useRef } from "react";
 import { AppState } from "react-native";
-import { getSupastashConfig } from "../../core/config";
-import { syncCalls } from "../../store/syncCalls";
-import { isSyncGateClosed } from "../../store/syncStatus";
-import { tableFilters } from "../../store/tableFilters";
-import { isOnline } from "../../utils/connection";
-import log from "../../utils/logs";
-import { updateLocalDb } from "../../utils/sync/pullFromRemote/updateLocalDb";
-import { pushLocalDataToRemote } from "../../utils/sync/pushLocal/sendUnsyncedToSupabase";
-import { pullFromRemote as doPullFromRemote } from "./pullFromRemote";
-import { pushLocalData as doPushLocalData } from "./pushLocal";
+import { getSupastashConfig } from "../../shared/core/config";
+import { syncCalls } from "../../shared/store/syncCalls";
+import { isSyncGateClosed } from "../../shared/store/syncStatus";
+import { tableFilters } from "../../shared/store/tableFilters";
+import { isOnline } from "../../shared/utils/connection";
+import log from "../../shared/utils/logs";
+import { pullFromRemote as doPullFromRemote } from "../utils/sync/pullFromRemote";
+import { updateLocalDb } from "../utils/sync/pullFromRemote/updateLocalDb";
+import { pushLocalData as doPushLocalData } from "../utils/sync/pushLocal";
+import { pushLocalDataToRemote } from "../utils/sync/pushLocal/sendUnsyncedToSupabase";
 // -----------------------------
 // Module-scoped state & tunables
 // -----------------------------
@@ -161,13 +161,13 @@ export function useSyncEngine() {
         }, pullEvery + 500);
         // Foreground trigger
         appStateSubRef.current = AppState.addEventListener("change", (state) => {
-            if (state !== "active")
-                return;
-            const now = Date.now();
-            if (now - lastForeground.current < MIN_FOREGROUND_GAP)
-                return;
-            lastForeground.current = now;
-            void syncAll(true);
+            if (state === "active") {
+                const now = Date.now();
+                if (now - lastForeground.current < MIN_FOREGROUND_GAP)
+                    return;
+                lastForeground.current = now;
+                void syncAll(true);
+            }
         });
     }
     function stopSync() {
@@ -179,7 +179,7 @@ export function useSyncEngine() {
             clearInterval(intervalRefPull.current);
             intervalRefPull.current = null;
         }
-        appStateSubRef.current?.remove?.();
+        appStateSubRef.current?.remove();
         appStateSubRef.current = null;
     }
     // Auto-cleanup if the hook lives in a component lifecycle

package/dist/native/index.d.ts

@@ -0,0 +1,28 @@
+export { configureSupastash, getSupastashConfig } from "../shared/core/config";
+export { getSupastashDb } from "../shared/db/dbInitializer";
+export { useSupastashFilters } from "../shared/hooks/supastashFilters";
+export { useSupastashSyncStatus } from "../shared/hooks/syncStatus";
+export { closeSyncGate, isSyncGateClosed, openSyncGate, } from "../shared/store/syncStatus";
+export { supastashEventBus } from "../shared/utils/events/eventBus";
+export { supastash } from "../shared/utils/query/builder";
+export { refreshScreen } from "../shared/utils/refreshScreenCalls";
+export { getSupastashRuntimeMode, reinitializeSupastash, } from "../shared/utils/supastashMode";
+export { getAllTables } from "../shared/utils/sync/getAllTables";
+export { updateFilters } from "../shared/utils/sync/pullFromRemote/updateFilter";
+export { refreshAllTables, refreshTable, refreshTableWithPayload, } from "../shared/utils/sync/refreshTables";
+export { clearSyncCalls, getAllSyncTables, getSyncCall, registerSyncCall, unregisterSyncCall, } from "../shared/utils/sync/registration/syncCalls";
+export { defineLocalSchema } from "./core/schemaManager";
+export { useSupastashData } from "./hooks/supastashData";
+export { useSupastash } from "./hooks/supastashLogic";
+export { syncAllTables, syncTable } from "./hooks/syncEngine";
+export { dropAllTables, dropTable, wipeAllTables, wipeOldDataForAllTables, wipeOldDataForATable, wipeTable, } from "./utils/schema/wipeTables";
+export { fetchOlderPage } from "./utils/sync/pullFromRemote/fetchOlder";
+export { updateLocalDb, upsertChunkData, upsertData, } from "./utils/sync/pullFromRemote/updateLocalDb";
+export { clearAllLocalDeleteLog, clearAllLocalSyncLog, clearLocalDeleteLog, clearLocalSyncLog, clearSyncLog, getLocalDeleteLog, getSyncLog, resetSyncLog, setLocalDeleteLog, setLocalSyncLog, setSyncLog, } from "./utils/sync/status/syncStatus";
+export type { CrudMethods } from "../shared/types/query.types";
+export type { RealtimeOptions, SupastashDataResult, SupastashFilter, } from "../shared/types/realtimeData.types";
+export type { LocalSchemaDefinition } from "../shared/types/schemaManager.types";
+export type { ExpoSQLiteClient, RNSqliteNitroClient, RNStorageSQLiteClient, SupastashConfig, SupastashHookReturn, SupastashSQLiteClientTypes, SupastashSQLiteDatabase, SupastashSQLiteExecutor, TauriSQLiteClient, } from "../shared/types/supastashConfig.types";
+export type { SupastashClient, SupastashTransactionClient, } from "../shared/utils/query/builder";
+export type { SyncInfo } from "../shared/types/syncEngine.types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/native/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,YAAY,GACb,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AACnE,OAAO,EACL,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,kDAAkD,CAAC;AACjF,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,uBAAuB,GACxB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EACL,aAAa,EACb,SAAS,EACT,aAAa,EACb,uBAAuB,EACvB,oBAAoB,EACpB,SAAS,GACV,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,EACL,aAAa,EACb,eAAe,EACf,UAAU,GACX,MAAM,2CAA2C,CAAC;AACnD,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EACZ,iBAAiB,EACjB,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,UAAU,GACX,MAAM,gCAAgC,CAAC;AAExC,YAAY,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,eAAe,GAChB,MAAM,oCAAoC,CAAC;AAC5C,YAAY,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AACjF,YAAY,EACV,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,EACvB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,uCAAuC,CAAC;AAC/C,YAAY,EACV,eAAe,EACf,0BAA0B,GAC3B,MAAM,+BAA+B,CAAC;AAEvC,YAAY,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/native/index.js

@@ -0,0 +1,21 @@
+export { configureSupastash, getSupastashConfig } from "../shared/core/config";
+export { getSupastashDb } from "../shared/db/dbInitializer";
+export { useSupastashFilters } from "../shared/hooks/supastashFilters";
+export { useSupastashSyncStatus } from "../shared/hooks/syncStatus";
+export { closeSyncGate, isSyncGateClosed, openSyncGate, } from "../shared/store/syncStatus";
+export { supastashEventBus } from "../shared/utils/events/eventBus";
+export { supastash } from "../shared/utils/query/builder";
+export { refreshScreen } from "../shared/utils/refreshScreenCalls";
+export { getSupastashRuntimeMode, reinitializeSupastash, } from "../shared/utils/supastashMode";
+export { getAllTables } from "../shared/utils/sync/getAllTables";
+export { updateFilters } from "../shared/utils/sync/pullFromRemote/updateFilter";
+export { refreshAllTables, refreshTable, refreshTableWithPayload, } from "../shared/utils/sync/refreshTables";
+export { clearSyncCalls, getAllSyncTables, getSyncCall, registerSyncCall, unregisterSyncCall, } from "../shared/utils/sync/registration/syncCalls";
+export { defineLocalSchema } from "./core/schemaManager";
+export { useSupastashData } from "./hooks/supastashData";
+export { useSupastash } from "./hooks/supastashLogic";
+export { syncAllTables, syncTable } from "./hooks/syncEngine";
+export { dropAllTables, dropTable, wipeAllTables, wipeOldDataForAllTables, wipeOldDataForATable, wipeTable, } from "./utils/schema/wipeTables";
+export { fetchOlderPage } from "./utils/sync/pullFromRemote/fetchOlder";
+export { updateLocalDb, upsertChunkData, upsertData, } from "./utils/sync/pullFromRemote/updateLocalDb";
+export { clearAllLocalDeleteLog, clearAllLocalSyncLog, clearLocalDeleteLog, clearLocalSyncLog, clearSyncLog, getLocalDeleteLog, getSyncLog, resetSyncLog, setLocalDeleteLog, setLocalSyncLog, setSyncLog, } from "./utils/sync/status/syncStatus";

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

@@ -0,0 +1,5 @@
+import { PayloadData } from "../../../shared/types/query.types";
+import { RealtimeOptions } from "../../../shared/types/realtimeData.types";
+declare function useEventQueues<R>(table: string, options: RealtimeOptions<R>, flushIntervalMs: number): (eventType: string, data: PayloadData) => void;
+export default useEventQueues;
+//# sourceMappingURL=eventQueues.d.ts.map