supastash 0.1.62 → 0.2.1

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

@@ -0,0 +1,109 @@
+import { SupastashFilter } from "../../../../shared/types/realtimeData.types";
+import { PublicScope, SupastashSyncStatus } from "../../../../shared/types/syncEngine.types";
+/**
+ * Clears the sync log for a specific table.
+ *
+ * Removes all stored sync checkpoints (created / updated / deleted)
+ * for the given table and filter key (if any).
+ *
+ * @param tableName - Name of the table whose sync status should be cleared.
+ * @example
+ * await clearLocalSyncLog("users");
+ */
+export declare function clearLocalSyncLog(tableName: string): Promise<void>;
+/**
+ * Clears the sync log for every local table.
+ *
+ * Drops the `supastash_sync_marks` table and recreates it.
+ * Use with caution — this wipes all sync history.
+ *
+ * @example
+ * await clearAllLocalSyncLog();
+ */
+export declare function clearAllLocalSyncLog(): Promise<void>;
+/**
+ *
+ * Returns the stored timestamps and filter info, or `null` if
+ * there is no entry for the table.
+ * @param tableName - The name of the table to get the sync log for
+ * @example
+ * const syncLog = await getSyncLog("users");
+ * console.log(syncLog);
+ * return {
+ *    table_name: "users",
+ *    last_synced_at: "2021-01-01T00:00:00.000Z",
+ *    last_deleted_at: "2021-01-01T00:00:00.000Z",
+ *    filter_key: "1234567890",
+ *    filter_json: "[...]",
+ *    updated_at: "2021-01-01T00:00:00.000Z"
+ * }
+ */
+export declare function getSyncLog(tableName: string): Promise<SupastashSyncStatus | null>;
+/**
+ * Writes or updates the sync log for a table.
+ *
+ * Stores the latest `updated_at` and `updated_at_pk`
+ * timestamps for a table + filter combination.
+ *
+ * @param table - Table name to update.
+ * @param filters - Optional realtime filters to scope the log.
+ * @param opts - Timestamp fields to set.
+ * @example
+ * await setSyncLog("users", undefined, {
+ *   lastSyncedAt: new Date().toISOString(),
+ *   lastSyncedAtPk: "00000000-0000-0000-0000-000000000000",
+ * });
+ */
+export declare function setSyncLog(table: string, filters: SupastashFilter[] | undefined, opts: {
+    lastSyncedAt?: string | null;
+    lastDeletedAt?: string | null;
+    lastSyncedAtPk?: string | null;
+    filterNamespace?: string;
+}): Promise<void>;
+/**
+ * Resets one or more timestamps in the sync log for a table.
+ *
+ * @param table - Table to reset.
+ * @param filters - Optional filters for a scoped reset.
+ * @param scope - Field(s) to reset: "all" (default),
+ *   "last_synced_at", or "last_deleted_at".
+ * @example
+ * await resetSyncLog("users", undefined, "all");
+ */
+export declare function resetSyncLog(table: string, filters: SupastashFilter[] | undefined, scope?: PublicScope): Promise<void>;
+/**
+ * Deletes the sync log entry for a table (and optional filter key).
+ *
+ * @param table - Table name.
+ * @param filters - Optional filters to target a specific row.
+ * @example
+ * await clearSyncLog("users");
+ */
+export declare function clearSyncLog(table: string, filters?: SupastashFilter[]): Promise<void>;
+/** ------------------- DEPRECATED 🗑 Local Sync & Delete Log ------------------- */
+/**
+ * @deprecated Use `setSyncLog` instead.
+ * Sets the sync timestamp for a given table.
+ */
+export declare function setLocalSyncLog(tableName: string, lastSyncedAt: string, lastCreatedAt?: string): Promise<void>;
+/**
+ * @deprecated Use `clearSyncLog` instead.
+ * Clears the delete log for a given table.
+ */
+export declare function clearLocalDeleteLog(tableName: string): Promise<void>;
+/**
+ * @deprecated Use `clearSyncLog` instead.
+ * Clears the delete status for all local tables.
+ */
+export declare function clearAllLocalDeleteLog(): Promise<void>;
+/**
+ * @deprecated Use `getSyncLog` instead.
+ * Gets the delete log for a given table.
+ */
+export declare function getLocalDeleteLog(tableName: string): Promise<void>;
+/**
+ * @deprecated Use `setSyncLog` instead.
+ * Sets the delete log for a given table.
+ */
+export declare function setLocalDeleteLog(tableName: string, lastDeletedAt: string): Promise<void>;
+//# sourceMappingURL=syncStatus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"syncStatus.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/status/syncStatus.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,6CAA6C,CAAC;AAC9E,OAAO,EACL,WAAW,EACX,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAkBnD;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,iBAExD;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,kBAKzC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,UAAU,CAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CASrC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,UAAU,CAC9B,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,iBAOF;AAED;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,eAAe,EAAE,GAAG,SAAS,EACtC,KAAK,GAAE,WAAmB,iBAO3B;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,EAAE,iBAM5E;AAED,oFAAoF;AAEpF;;;GAGG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,aAAa,CAAC,EAAE,MAAM,iBAGvB;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,iBAE1D;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,kBAE3C;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,iBAExD;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,iBAGtB"}

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

@@ -0,0 +1,161 @@
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { getSupastashDb } from "../../../../shared/db/dbInitializer";
+import { logError } from "../../../../shared/utils/logs";
+import { createSyncStatusTable } from "../../../../shared/utils/schema/createSyncStatus";
+import { clearSupastashSyncStatus, getSupastashSyncStatus, resetSupastashSyncStatus, setSupastashSyncStatus, } from "./services";
+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;
+};
+/**
+ * Clears the sync log for a specific table.
+ *
+ * Removes all stored sync checkpoints (created / updated / deleted)
+ * for the given table and filter key (if any).
+ *
+ * @param tableName - Name of the table whose sync status should be cleared.
+ * @example
+ * await clearLocalSyncLog("users");
+ */
+export async function clearLocalSyncLog(tableName) {
+    await clearSupastashSyncStatus(tableName);
+}
+/**
+ * Clears the sync log for every local table.
+ *
+ * Drops the `supastash_sync_marks` table and recreates it.
+ * Use with caution — this wipes all sync history.
+ *
+ * @example
+ * await clearAllLocalSyncLog();
+ */
+export async function clearAllLocalSyncLog() {
+    const db = await getSupastashDb();
+    const syncStatusTable = getSyncStatusTable();
+    await db.runAsync(`DROP TABLE IF EXISTS ${syncStatusTable}`);
+    await createSyncStatusTable();
+}
+/**
+ *
+ * Returns the stored timestamps and filter info, or `null` if
+ * there is no entry for the table.
+ * @param tableName - The name of the table to get the sync log for
+ * @example
+ * const syncLog = await getSyncLog("users");
+ * console.log(syncLog);
+ * return {
+ *    table_name: "users",
+ *    last_synced_at: "2021-01-01T00:00:00.000Z",
+ *    last_deleted_at: "2021-01-01T00:00:00.000Z",
+ *    filter_key: "1234567890",
+ *    filter_json: "[...]",
+ *    updated_at: "2021-01-01T00:00:00.000Z"
+ * }
+ */
+export async function getSyncLog(tableName) {
+    try {
+        const syncStatus = await getSupastashSyncStatus(tableName);
+        return syncStatus;
+    }
+    catch (error) {
+        logError(error);
+        return null;
+    }
+}
+/**
+ * Writes or updates the sync log for a table.
+ *
+ * Stores the latest `updated_at` and `updated_at_pk`
+ * timestamps for a table + filter combination.
+ *
+ * @param table - Table name to update.
+ * @param filters - Optional realtime filters to scope the log.
+ * @param opts - Timestamp fields to set.
+ * @example
+ * await setSyncLog("users", undefined, {
+ *   lastSyncedAt: new Date().toISOString(),
+ *   lastSyncedAtPk: "00000000-0000-0000-0000-000000000000",
+ * });
+ */
+export async function setSyncLog(table, filters, opts) {
+    try {
+        await setSupastashSyncStatus(table, filters, opts);
+    }
+    catch (e) {
+        logError(`[Supastash] setMarks(${table}) failed`, e);
+    }
+}
+/**
+ * Resets one or more timestamps in the sync log for a table.
+ *
+ * @param table - Table to reset.
+ * @param filters - Optional filters for a scoped reset.
+ * @param scope - Field(s) to reset: "all" (default),
+ *   "last_synced_at", or "last_deleted_at".
+ * @example
+ * await resetSyncLog("users", undefined, "all");
+ */
+export async function resetSyncLog(table, filters, scope = "all") {
+    try {
+        await resetSupastashSyncStatus(table, filters, scope);
+    }
+    catch (e) {
+        logError(`[Supastash] resetMarks(${table}, ${scope}) failed`, e);
+    }
+}
+/**
+ * Deletes the sync log entry for a table (and optional filter key).
+ *
+ * @param table - Table name.
+ * @param filters - Optional filters to target a specific row.
+ * @example
+ * await clearSyncLog("users");
+ */
+export async function clearSyncLog(table, filters) {
+    try {
+        await clearSupastashSyncStatus(table, filters);
+    }
+    catch (e) {
+        logError(`[Supastash] clearMarks(${table}) failed`, e);
+    }
+}
+/** ------------------- DEPRECATED 🗑 Local Sync & Delete Log ------------------- */
+/**
+ * @deprecated Use `setSyncLog` instead.
+ * Sets the sync timestamp for a given table.
+ */
+export async function setLocalSyncLog(tableName, lastSyncedAt, lastCreatedAt) {
+    return;
+}
+/**
+ * @deprecated Use `clearSyncLog` instead.
+ * Clears the delete log for a given table.
+ */
+export async function clearLocalDeleteLog(tableName) {
+    return;
+}
+/**
+ * @deprecated Use `clearSyncLog` instead.
+ * Clears the delete status for all local tables.
+ */
+export async function clearAllLocalDeleteLog() {
+    return;
+}
+/**
+ * @deprecated Use `getSyncLog` instead.
+ * Gets the delete log for a given table.
+ */
+export async function getLocalDeleteLog(tableName) {
+    return;
+}
+/**
+ * @deprecated Use `setSyncLog` instead.
+ * Sets the delete log for a given table.
+ */
+export async function setLocalDeleteLog(tableName, lastDeletedAt) {
+    return;
+}

package/dist/shared/constants/syncDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncDefaults.d.ts","sourceRoot":"","sources":["../../../src/shared/constants/syncDefaults.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,gCAAgC,CAAC;AAExC,eAAO,MAAM,cAAc,EAAE,mBAU5B,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,gBAO5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,MAAM,CAAC"}

package/dist/{core → shared/core}/config/index.d.ts

@@ -19,6 +19,7 @@ import { SupastashConfig, SupastashSQLiteClientTypes } from "../../types/supasta
  *   supabaseClient: supabase,
  *   sqliteClient: { openDatabaseAsync },
  *   sqliteClientType: "expo",
+ *   platform: "native",
  *   onSchemaInit: () => {
  *     defineLocalSchema("users", {
  *       id: "TEXT PRIMARY KEY",
@@ -35,6 +36,7 @@ import { SupastashConfig, SupastashSQLiteClientTypes } from "../../types/supasta
  * @param config.supabaseClient - Supabase client instance (**required**)
  * @param config.sqliteClient - SQLite client adapter (**required**)
  * @param config.sqliteClientType - SQLite engine: `"expo" | "rn-storage" | "rn-nitro"` (**required**)
+ * @param config.platform - Runtime platform: `"native" | "desktop"` (default: `"native"`)
  * @param config.onSchemaInit - Optional callback to define local table schemas
  * @param config.debugMode - Enables debug logging (default: `false`)
  * @param config.listeners - Max number of active Realtime subscriptions (default: `250`)

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/shared/core/config/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC3B,MAAM,mCAAmC,CAAC;AAmC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,0BAA0B,EACrE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG;IAAE,gBAAgB,EAAE,CAAC,CAAA;CAAE,QAwCrD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,SAAS,0BAA0B,KACjC,eAAe,CAAC,CAAC,CAAC,CAEtB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,SAAS,0BAA0B,EACpC,MAAM,EAAE;IACR,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG;QAC9B,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;KAC3B,CAAC;CACH,QAEA"}

package/dist/{core → shared/core}/config/index.js

@@ -14,8 +14,14 @@ let _config = {
         pull: true,
         useFiltersFromStore: true,
     },
+    platform: "native",
+    replicationMode: "client-side",
+    hasEnabledSimpleNullHandling: false,
+    maxSyncLookbackDays: 365,
+    perTableSyncLookbackDays: undefined,
+    fullSyncTables: [],
     listeners: 250,
-    supabaseBatchSize: 100,
+    supabaseBatchSize: 800,
     debugMode: true,
     syncPolicy: DEFAULT_POLICY,
     fieldEnforcement: DEFAULT_FIELDS,
@@ -44,6 +50,7 @@ let _configured = false;
  *   supabaseClient: supabase,
  *   sqliteClient: { openDatabaseAsync },
  *   sqliteClientType: "expo",
+ *   platform: "native",
  *   onSchemaInit: () => {
  *     defineLocalSchema("users", {
  *       id: "TEXT PRIMARY KEY",
@@ -60,6 +67,7 @@ let _configured = false;
  * @param config.supabaseClient - Supabase client instance (**required**)
  * @param config.sqliteClient - SQLite client adapter (**required**)
  * @param config.sqliteClientType - SQLite engine: `"expo" | "rn-storage" | "rn-nitro"` (**required**)
+ * @param config.platform - Runtime platform: `"native" | "desktop"` (default: `"native"`)
  * @param config.onSchemaInit - Optional callback to define local table schemas
  * @param config.debugMode - Enables debug logging (default: `false`)
  * @param config.listeners - Max number of active Realtime subscriptions (default: `250`)

package/dist/shared/core/platform/appState.d.ts

@@ -0,0 +1,12 @@
+export type AppStateStatus = "active" | "background";
+type Callback = (state: AppStateStatus) => void;
+export interface AppStateAdapter {
+    subscribe(cb: Callback): () => void;
+}
+export declare class AppStateService {
+    private adapter;
+    constructor(adapter: AppStateAdapter);
+    onActive(cb: () => void): () => void;
+}
+export {};
+//# sourceMappingURL=appState.d.ts.map

package/dist/shared/core/platform/appState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appState.d.ts","sourceRoot":"","sources":["../../../../src/shared/core/platform/appState.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,YAAY,CAAC;AAErD,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;AAEhD,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,EAAE,QAAQ,GAAG,MAAM,IAAI,CAAC;CACrC;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAkB;gBAErB,OAAO,EAAE,eAAe;IAIpC,QAAQ,CAAC,EAAE,EAAE,MAAM,IAAI,SAVQ,IAAI;CAepC"}

package/dist/shared/core/platform/appState.js

@@ -0,0 +1,11 @@
+export class AppStateService {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    onActive(cb) {
+        return this.adapter.subscribe((state) => {
+            if (state === "active")
+                cb();
+        });
+    }
+}

package/dist/shared/db/adapters/expo_sqlite.d.ts

@@ -0,0 +1,3 @@
+import { ExpoSQLiteClient, SupastashSQLiteAdapter } from "../../types/supastashConfig.types";
+export declare const SQLiteAdapterExpo: SupastashSQLiteAdapter<ExpoSQLiteClient>;
+//# sourceMappingURL=expo_sqlite.d.ts.map

package/dist/shared/db/adapters/expo_sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expo_sqlite.d.ts","sourceRoot":"","sources":["../../../../src/shared/db/adapters/expo_sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EAGvB,MAAM,mCAAmC,CAAC;AAG3C,eAAO,MAAM,iBAAiB,EAAE,sBAAsB,CAAC,gBAAgB,CA6GtE,CAAC"}

package/dist/shared/db/adapters/expo_sqlite.js

@@ -0,0 +1,72 @@
+import { namedToPositional } from "../normalizer";
+export const SQLiteAdapterExpo = {
+    async openDatabaseAsync(name, sqliteClient) {
+        const db = await sqliteClient.openDatabaseAsync(name);
+        return {
+            runAsync: async (sql, params) => {
+                await db.runAsync(sql, params ?? []);
+            },
+            execAsync: async (statement) => {
+                await db.execAsync(statement);
+            },
+            getAllAsync: async (sql, params) => {
+                const result = await db.getAllAsync(sql, params ?? []);
+                return result ?? [];
+            },
+            getFirstAsync: async (sql, params) => {
+                const result = await db.getFirstAsync(sql, params ?? []);
+                return result ?? null;
+            },
+            query: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                return await db.getAllAsync(q, p);
+            },
+            queryOne: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                return await db.getFirstAsync(q, p);
+            },
+            execute: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                return await db.runAsync(q, p);
+            },
+            closeAsync: async () => {
+                await db.closeAsync?.();
+            },
+            withTransaction: async (fn) => {
+                return await db.withTransactionAsync(async () => {
+                    const txExecutor = {
+                        runAsync: async (sql, params) => await db.runAsync(sql, params ?? []),
+                        execAsync: async (statement) => await db.execAsync(statement),
+                        getAllAsync: async (sql, params) => await db.getAllAsync(sql, params ?? []),
+                        getFirstAsync: async (sql, params) => await db.getFirstAsync(sql, params ?? []),
+                        query: async (sql, params) => {
+                            const { sql: q, params: p } = params
+                                ? namedToPositional(sql, params)
+                                : { sql, params: [] };
+                            return await db.getAllAsync(q, p);
+                        },
+                        queryOne: async (sql, params) => {
+                            const { sql: q, params: p } = params
+                                ? namedToPositional(sql, params)
+                                : { sql, params: [] };
+                            return await db.getFirstAsync(q, p);
+                        },
+                        execute: async (sql, params) => {
+                            const { sql: q, params: p } = params
+                                ? namedToPositional(sql, params)
+                                : { sql, params: [] };
+                            return await db.runAsync(q, p);
+                        },
+                    };
+                    return await fn(txExecutor);
+                });
+            },
+        };
+    },
+};

package/dist/shared/db/adapters/rn_nitro.d.ts

@@ -0,0 +1,3 @@
+import { RNSqliteNitroClient, SupastashSQLiteAdapter } from "../../types/supastashConfig.types";
+export declare const SQLiteAdapterNitro: SupastashSQLiteAdapter<RNSqliteNitroClient>;
+//# sourceMappingURL=rn_nitro.d.ts.map

package/dist/shared/db/adapters/rn_nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rn_nitro.d.ts","sourceRoot":"","sources":["../../../../src/shared/db/adapters/rn_nitro.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EAGvB,MAAM,mCAAmC,CAAC;AAI3C,eAAO,MAAM,kBAAkB,EAAE,sBAAsB,CAAC,mBAAmB,CAyJ1E,CAAC"}

package/dist/shared/db/adapters/rn_nitro.js

@@ -0,0 +1,111 @@
+import { getSupastashConfig } from "../../core/config";
+import { isDebugMode } from "../../utils/logs";
+import { namedToPositional } from "../normalizer";
+export const SQLiteAdapterNitro = {
+    async openDatabaseAsync(name, sqliteClient) {
+        //Enable simple null handling for Nitro SQLite
+        const config = getSupastashConfig();
+        if (!config.hasEnabledSimpleNullHandling && isDebugMode()) {
+            console.warn("[Supastash] Nitro SQLite detected. Call `enableSimpleNullHandling()` at the top of your app to ensure correct null behavior (see: https://libraries.io/npm/@vertexmd%2Freact-native-nitro-sqlite#simplified-null-handling). If already enabled, set `hasEnabledSimpleNullHandling: true` in Supastash config to silence this warning.");
+        }
+        const db = await sqliteClient.open({ name, location: "default" });
+        return {
+            runAsync: async (sql, params) => {
+                await db.executeAsync(sql, params ?? []);
+            },
+            execAsync: async (statement) => {
+                await db.executeAsync(statement);
+            },
+            getAllAsync: async (sql, params) => {
+                const result = await db.executeAsync(sql, params ?? []);
+                const mainResult = result.rows?._array ?? [];
+                return mainResult;
+            },
+            getFirstAsync: async (sql, params) => {
+                const result = await db.executeAsync(sql, params ?? []);
+                return result.rows?._array?.[0] ?? null;
+            },
+            query: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                const result = await db.executeAsync(q, p ?? []);
+                const mainResult = result.rows?._array ?? [];
+                return mainResult;
+            },
+            queryOne: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                const result = await db.executeAsync(q, p ?? []);
+                return result.rows?._array?.[0] ?? null;
+            },
+            execute: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                return await db.executeAsync(q, p ?? []);
+            },
+            closeAsync: async () => {
+                await db.close?.();
+            },
+            withTransaction: async (fn) => {
+                const statements = [];
+                const enqueue = (sql, params) => {
+                    statements.push({ sql, params });
+                };
+                const txExecutor = {
+                    runAsync: async (sql, params) => {
+                        enqueue(sql, params ?? []);
+                    },
+                    execAsync: async (statement) => {
+                        enqueue(statement, []);
+                    },
+                    getAllAsync: async (sql, params) => {
+                        const result = await db.executeAsync(sql, params ?? []);
+                        return result.rows?._array ?? [];
+                    },
+                    getFirstAsync: async (sql, params) => {
+                        const result = await db.executeAsync(sql, params ?? []);
+                        return result.rows?._array?.[0] ?? null;
+                    },
+                    query: async (sql, params) => {
+                        const { sql: q, params: p } = params
+                            ? namedToPositional(sql, params)
+                            : { sql, params: [] };
+                        const result = await db.executeAsync(q, p ?? []);
+                        return result.rows?._array ?? [];
+                    },
+                    queryOne: async (sql, params) => {
+                        const { sql: q, params: p } = params
+                            ? namedToPositional(sql, params)
+                            : { sql, params: [] };
+                        const result = await db.executeAsync(q, p ?? []);
+                        return result.rows?._array?.[0] ?? null;
+                    },
+                    execute: async (sql, params) => {
+                        const { sql: q, params: p } = params
+                            ? namedToPositional(sql, params)
+                            : { sql, params: [] };
+                        enqueue(q, p ?? []);
+                        return {};
+                    },
+                };
+                await fn(txExecutor);
+                if (statements.length === 0)
+                    return;
+                await db.executeAsync("BEGIN");
+                try {
+                    for (const { sql, params } of statements) {
+                        await db.executeAsync(sql, params);
+                    }
+                    await db.executeAsync("COMMIT");
+                }
+                catch (err) {
+                    await db.executeAsync("ROLLBACK").catch(() => { });
+                    throw err;
+                }
+            },
+        };
+    },
+};

package/dist/shared/db/adapters/rn_sqlite_storage.d.ts

@@ -0,0 +1,3 @@
+import { RNStorageSQLiteClient, SupastashSQLiteAdapter } from "../../types/supastashConfig.types";
+export declare const SQLiteAdapterStorage: SupastashSQLiteAdapter<RNStorageSQLiteClient>;
+//# sourceMappingURL=rn_sqlite_storage.d.ts.map

package/dist/shared/db/adapters/rn_sqlite_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rn_sqlite_storage.d.ts","sourceRoot":"","sources":["../../../../src/shared/db/adapters/rn_sqlite_storage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EAGvB,MAAM,mCAAmC,CAAC;AAG3C,eAAO,MAAM,oBAAoB,EAAE,sBAAsB,CAAC,qBAAqB,CAgJ5E,CAAC"}

package/dist/shared/db/adapters/rn_sqlite_storage.js

@@ -0,0 +1,93 @@
+import { namedToPositional } from "../normalizer";
+export const SQLiteAdapterStorage = {
+    async openDatabaseAsync(name, sqliteClient) {
+        const db = await sqliteClient.openDatabase({ name });
+        return {
+            runAsync: async (sql, params) => {
+                await db.executeSql(sql, params ?? []);
+            },
+            execAsync: async (statement) => {
+                await db.executeSql(statement);
+            },
+            getAllAsync: async (sql, params) => {
+                const result = await db.executeSql(sql, params ?? []);
+                const mainResult = result.map((r, index) => r.rows.item(index));
+                return mainResult ?? [];
+            },
+            getFirstAsync: async (sql, params) => {
+                const result = await db.executeSql(sql, params ?? []);
+                return result[0].rows.item(0) ?? null;
+            },
+            query: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                const result = await db.executeSql(q, p ?? []);
+                return result.map((r, index) => r.rows.item(index));
+            },
+            queryOne: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                const result = await db.executeSql(q, p ?? []);
+                return result[0].rows.item(0) ?? null;
+            },
+            execute: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                await db.executeSql(q, p ?? []);
+            },
+            closeAsync: async () => {
+                await db.close?.();
+            },
+            withTransaction: async (fn) => {
+                await db.transaction(async (tx) => {
+                    const txExecutor = {
+                        runAsync: async (sql, params) => {
+                            await tx.executeSql(sql, params ?? []);
+                        },
+                        execAsync: async (statement) => {
+                            await tx.executeSql(statement);
+                        },
+                        getAllAsync: async (sql, params) => {
+                            const [, resultSet] = await tx.executeSql(sql, params ?? []);
+                            const rows = [];
+                            for (let i = 0; i < resultSet.rows.length; i++) {
+                                rows.push(resultSet.rows.item(i));
+                            }
+                            return rows;
+                        },
+                        getFirstAsync: async (sql, params) => {
+                            const [, resultSet] = await tx.executeSql(sql, params ?? []);
+                            if (resultSet.rows.length === 0)
+                                return null;
+                            return resultSet.rows.item(0);
+                        },
+                        query: async (sql, params) => {
+                            const { sql: q, params: p } = params
+                                ? namedToPositional(sql, params)
+                                : { sql, params: [] };
+                            const result = await db.executeSql(q, p ?? []);
+                            return result.map((r, index) => r.rows.item(index));
+                        },
+                        queryOne: async (sql, params) => {
+                            const { sql: q, params: p } = params
+                                ? namedToPositional(sql, params)
+                                : { sql, params: [] };
+                            const result = await db.executeSql(q, p ?? []);
+                            return result[0].rows.item(0) ?? null;
+                        },
+                        execute: async (sql, params) => {
+                            const { sql: q, params: p } = params
+                                ? namedToPositional(sql, params)
+                                : { sql, params: [] };
+                            await db.executeSql(q, p ?? []);
+                        },
+                    };
+                    return await fn(txExecutor);
+                });
+            },
+        };
+    },
+};

package/dist/shared/db/adapters/tauri.d.ts

@@ -0,0 +1,3 @@
+import { SupastashSQLiteAdapter, TauriSQLiteClient } from "../../types/supastashConfig.types";
+export declare const SQLiteAdapterTauri: SupastashSQLiteAdapter<TauriSQLiteClient>;
+//# sourceMappingURL=tauri.d.ts.map