supastash 0.2.0 → 0.2.2

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,7 +14,9 @@ let _config = {
         pull: true,
         useFiltersFromStore: true,
     },
+    platform: "native",
     replicationMode: "client-side",
+    hasEnabledSimpleNullHandling: false,
     maxSyncLookbackDays: 365,
     perTableSyncLookbackDays: undefined,
     fullSyncTables: [],
@@ -48,6 +50,7 @@ let _configured = false;
  *   supabaseClient: supabase,
  *   sqliteClient: { openDatabaseAsync },
  *   sqliteClientType: "expo",
+ *   platform: "native",
  *   onSchemaInit: () => {
  *     defineLocalSchema("users", {
  *       id: "TEXT PRIMARY KEY",
@@ -64,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/{db → shared/db}/adapters/rn_sqlite_storage.js

@@ -1,3 +1,4 @@
+import { namedToPositional } from "../normalizer";
 export const SQLiteAdapterStorage = {
     async openDatabaseAsync(name, sqliteClient) {
         const db = await sqliteClient.openDatabase({ name });
@@ -17,6 +18,26 @@ export const SQLiteAdapterStorage = {
                 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?.();
             },
@@ -43,6 +64,26 @@ export const SQLiteAdapterStorage = {
                                 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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tauri.d.ts","sourceRoot":"","sources":["../../../../src/shared/db/adapters/tauri.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EAEtB,iBAAiB,EAClB,MAAM,mCAAmC,CAAC;AAG3C,eAAO,MAAM,kBAAkB,EAAE,sBAAsB,CAAC,iBAAiB,CAiJxE,CAAC"}

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

@@ -0,0 +1,100 @@
+import { interpolate, namedToPositional } from "../normalizer";
+export const SQLiteAdapterTauri = {
+    async openDatabaseAsync(name, sqliteClient) {
+        const db = await sqliteClient.load(`sqlite:${name}`);
+        const normalizeParams = (params) => {
+            return (params ?? []).map((v) => typeof v === "boolean" ? (v ? 1 : 0) : v);
+        };
+        return {
+            runAsync: async (sql, params) => {
+                const normalized = normalizeParams(params);
+                await db.execute(sql, normalized ?? []);
+            },
+            execAsync: async (statement) => {
+                await db.execute(statement);
+            },
+            getAllAsync: async (sql, params) => {
+                const normalized = normalizeParams(params);
+                const rows = await db.select(sql, normalized ?? []);
+                return rows ?? [];
+            },
+            getFirstAsync: async (sql, params) => {
+                const normalized = normalizeParams(params);
+                const rows = (await db.select(sql, normalized ?? []));
+                return rows?.[0] ?? null;
+            },
+            query: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                const normalized = normalizeParams(p);
+                return (await db.select(q, normalized));
+            },
+            queryOne: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                const normalized = normalizeParams(p);
+                const rows = (await db.select(q, normalized));
+                return rows?.[0] ?? null;
+            },
+            execute: async (sql, params) => {
+                const { sql: q, params: p } = params
+                    ? namedToPositional(sql, params)
+                    : { sql, params: [] };
+                return (await db.execute(q, p));
+            },
+            closeAsync: async () => {
+                if (typeof db.close === "function") {
+                    await db.close();
+                }
+            },
+            withTransaction: async (fn) => {
+                const statements = [];
+                const enqueue = (sql, params) => {
+                    statements.push(interpolate(sql, params));
+                };
+                const txExecutor = {
+                    runAsync: async (sql, params) => {
+                        enqueue(sql, params ?? []);
+                    },
+                    execAsync: async (statement) => {
+                        statements.push(statement);
+                    },
+                    getAllAsync: async (sql, params) => (await db.select(sql, params ?? [])) ?? [],
+                    getFirstAsync: async (sql, params) => (await db.select(sql, params ?? []))?.[0] ?? null,
+                    query: async (sql, params) => {
+                        const { sql: q, params: p } = params
+                            ? namedToPositional(sql, params)
+                            : { sql, params: [] };
+                        return (await db.select(q, p));
+                    },
+                    queryOne: async (sql, params) => {
+                        const { sql: q, params: p } = params
+                            ? namedToPositional(sql, params)
+                            : { sql, params: [] };
+                        return (await db.select(q, p))?.[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;
+                const batch = `BEGIN; ${statements.join("; ")}; COMMIT;`;
+                try {
+                    await db.execute(batch, []);
+                }
+                catch (err) {
+                    await db.execute("ROLLBACK;", []).catch(() => { });
+                    throw err;
+                }
+            },
+        };
+    },
+};

package/dist/shared/db/dbErrorMsg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbErrorMsg.d.ts","sourceRoot":"","sources":["../../../src/shared/db/dbErrorMsg.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,QAmCxB,CAAC"}

package/dist/{db → shared/db}/dbErrorMsg.js

@@ -25,4 +25,11 @@ export const supastashDbErrorMsg = "SQLite client not found. Please provide a SQ
     "  sqliteClient: { openDatabaseAsync }, \n" +
     "  sqliteClientType: 'rn-storage', \n" +
     "});" +
+    "\n\n" +
+    "or \n" +
+    "import Database from '@tauri-apps/plugin-sql';\n" +
+    "configureSupastash({ \n" +
+    "  sqliteClient: Database, \n" +
+    "  sqliteClientType: 'tauri', \n" +
+    "});" +
     "\n\n";

package/dist/{db → shared/db}/dbInitializer.d.ts

@@ -1,8 +1,8 @@
 import { SupastashSQLiteDatabase } from "../types/supastashConfig.types";
+export declare function closeSupastashDb(): Promise<void>;
 /**
  * Gets the supastash database
  * @returns The supastash database
  */
 export declare function getSupastashDb(): Promise<SupastashSQLiteDatabase>;
-export declare function closeSupastashDb(): Promise<void>;
 //# sourceMappingURL=dbInitializer.d.ts.map

package/dist/shared/db/dbInitializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbInitializer.d.ts","sourceRoot":"","sources":["../../../src/shared/db/dbInitializer.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,uBAAuB,EAExB,MAAM,gCAAgC,CAAC;AAMxC,wBAAsB,gBAAgB,kBAOrC;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAyEvE"}