supastash 0.1.0

package/README.md

@@ -0,0 +1,250 @@
+# Supastash
+
+**Offline-First Sync Engine for Supabase + React Native.**
+
+Supastash makes it effortless to build offline-capable mobile apps using **SQLite for local-first storage** and **Supabase for cloud sync**. Designed for React Native, Supastash handles syncing, conflict resolution, realtime updates, and local querying so you can focus on features, not infrastructure.
+
+---
+
+### 📚 Documentation
+
+[Documentation (Coming Soon)](https://...)
+
+---
+
+## 🚀 Features
+
+- 🔁 **Two-way sync** with Supabase
+- 💾 **Local-first querying** with React Native SQLite
+- ⚡ **Realtime updates** using Supabase channels
+- 🔌 **Pluggable SQLite adapters** (`expo-sqlite`, `react-native-nitro-sqlite`, `react-native-sqlite-storage`)
+- ✅ **Built-in deduplication**, conflict resolution, and background retries
+- 🧠 Designed to support **event batching**, **job staging**, and fine-grained sync control
+
+---
+
+## 📦 Installation
+
+```bash
+npm install supastash
+# or
+yarn add supastash
+```
+
+### 📎 Peer Dependencies (You MUST install these)
+
+```bash
+npm install @supabase/supabase-js
+             @react-native-community/netinfo
+             react
+             react-native
+
+# Choose one SQLite adapter:
+npm install expo-sqlite
+# or
+npm install react-native-nitro-sqlite
+# or
+npm install react-native-sqlite-storage
+```
+
+> `sqliteClientType` must match your adapter: "expo", "rn-nitro", or "rn-storage"
+
+---
+
+## ⚙️ Setup
+
+```ts
+// lib/supastash.ts
+import { configureSupastash, defineLocalSchema } from "supastash";
+import { supabase } from "./supabase";
+import { openDatabaseAsync } from "expo-sqlite";
+
+configureSupastash({
+  supabaseClient: supabase,
+  dbName: "supastash_db",
+  sqliteClient: { openDatabaseAsync },
+  sqliteClientType: "expo",
+  onSchemaInit: () => {
+    defineLocalSchema(
+      "users",
+      {
+        id: "TEXT PRIMARY KEY",
+        name: "TEXT",
+        email: "TEXT",
+        created_at: "TIMESTAMP DEFAULT CURRENT_TIMESTAMP",
+        updated_at: "TIMESTAMP DEFAULT CURRENT_TIMESTAMP",
+      },
+      true
+    );
+  },
+  debugMode: true,
+  syncEngine: {
+    push: true,
+    pull: false, // ⚠️ Pull sync is disabled by default.
+  },
+});
+```
+
+Then initialize early:
+
+```ts
+// _layout.tsx or App.tsx
+import "@/lib/supastash";
+
+export default function RootLayout() {
+  return <Stack />;
+}
+```
+
+---
+
+## 🚨 Key Notes
+
+- Supabase tables **must** include:
+
+  - `id`, `created_at`, `updated_at`, `deleted_at`
+  - Use `updated_at` for conflict resolution
+  - Avoid null primary keys
+  - Apply `deleted_at IS NULL` filter in queries
+
+- To enable schema reflection, create this Supabase RPC:
+
+```sql
+create or replace function get_column_names(table_name text)
+returns table(column_name text)
+security definer
+as $$
+  select column_name
+  from information_schema.columns
+  where table_schema = 'public'
+    and table_name = table_name;
+$$ language sql;
+
+grant execute on function get_column_names(text) to anon, authenticated;
+```
+
+---
+
+## 🧪 Basic Usage
+
+### `useSupatashData` hook
+
+```ts
+import { useSupatashData } from "supastash";
+
+type Order = {
+  id: string;
+  user_id: string;
+  deleted_at: string | null;
+  updated_at: string;
+  created_at: string;
+};
+
+const { data: orders, dataMap: ordersMap } = useSupatashData<Order>("orders");
+
+// Filtered
+const { userId } = useAuth();
+const { data: userOrders } = useSupatashData<Order>("orders", {
+  filter: { column: "user_id", operator: "eq", value: userId },
+  shouldFetch: !!userId,
+});
+```
+
+### `useSupatash`
+
+```ts
+import { useSupatash } from "supastash";
+
+const { dbReady } = useSupatash();
+if (!dbReady) return null;
+return <Stack />;
+```
+
+---
+
+## 📘 API Overview
+
+### `configureSupastash(config)`
+
+Initialize sync system.
+
+### `useSupatashData(table, options)`
+
+Access data with local cache, syncing, filtering, etc.
+
+Returns:
+
+```ts
+{
+  data: R[];
+  dataMap: Map<string, R>;
+  trigger: () => void;
+  cancel: () => void;
+}
+```
+
+### `refreshTable(table: string)` / `refreshAllTables()`
+
+Force-refresh any or all table data.
+
+---
+
+## 🔄 Sync Internals
+
+- Safe writes with `created_at`, `updated_at`, `deleted_at`
+- Retries with **exponential backoff**
+- Batched inserts, updates, deletes
+- Real-time changes are applied directly to local cache
+
+---
+
+## 📁 Project Structure
+
+```
+src/
+  ├─ core/         # Supabase + sync logic
+  ├─ hooks/        # Main React hooks
+  ├─ types/        # Type definitions
+  ├─ utils/        # Helper utilities
+```
+
+---
+
+## 🔧 Testing
+
+```bash
+yarn test
+```
+
+Uses `vitest` for unit testing.
+
+---
+
+## 🧱 Roadmap
+
+- [ ] Per-table sync intervals
+- [ ] Smart job resumption
+- [ ] Sync versioning
+- [ ] Live change audit logs
+
+---
+
+## 🤝 Contributing
+
+```bash
+yarn dev
+```
+
+Open a PR with tests and typed signatures. PRs welcome.
+
+---
+
+## 📜 License
+
+MIT License © Ezekiel Akpan
+
+---
+
+## 💬 Questions?
+
+Open an issue or reach out on [X @0xZekeA](https://x.com/0xZekeA)

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

@@ -0,0 +1,90 @@
+import { SupastashConfig, SupastashSQLiteClientTypes } from "../../types/supastashConfig.types";
+/**
+ * Initializes the Supastash client.
+ *
+ * This must be called **once** during app startup (e.g., in `_layout.tsx` or `App.tsx`)
+ * before using any Supastash hooks or features.
+ *
+ * ⚠️ Pull sync is **disabled by default** to avoid unfiltered data fetches.
+ * Enable it only if you've configured **Row Level Security (RLS)** on your Supabase tables.
+ * The `useSupatashData` hook always performs filtered pull queries when `filter` is provided in the `options`, making it safe to use even when pull is disabled globally.
+ *
+ * @example
+ * import { supabase } from "./supabase";
+ * import { openDatabaseAsync } from "expo-sqlite";
+ * import { configureSupastash, defineLocalSchema } from "supastash";
+ *
+ * configureSupastash({
+ *   dbName: "supastash_db",
+ *   supabaseClient: supabase,
+ *   sqliteClient: { openDatabaseAsync },
+ *   sqliteClientType: "expo",
+ *   onSchemaInit: () => {
+ *     defineLocalSchema("users", {
+ *       id: "TEXT PRIMARY KEY",
+ *       name: "TEXT",
+ *       email: "TEXT",
+ *       created_at: "TIMESTAMP DEFAULT CURRENT_TIMESTAMP",
+ *       updated_at: "TIMESTAMP DEFAULT CURRENT_TIMESTAMP",
+ *     });
+ *   },
+ * });
+ *
+ * @param config - Configuration options for Supastash
+ * @param config.dbName - SQLite database name (default: `"supastash_db"`)
+ * @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.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`)
+ * @param config.excludeTables - Tables to exclude from sync (default: `{ pull: [], push: [] }`)
+ * @param config.pollingInterval - Polling interval for sync (default: `{ pull: 30000, push: 30000 }`)
+ * @param config.syncEngine - Control pull/push sync behavior (`push: true`, `pull: false` by default, `useFiltersFromStore: true` by default)
+ */
+export declare function configureSupastash<T extends SupastashSQLiteClientTypes>(config: SupastashConfig<T> & {
+    sqliteClientType: T;
+}): void;
+/**
+ * Returns the current Supastash configuration.
+ *
+ * Throws an error if `configureSupastash` has not been called.
+ *
+ * @returns {SupastashConfig<T>} The active Supastash configuration
+ *
+ * @throws Will throw if Supastash is not configured or if essential values like
+ * `supabaseClient` or `sqliteClient` are missing.
+ *
+ * @example
+ * const config = getSupastashConfig();
+ * const dbName = config.dbName;
+ */
+export declare function getSupastashConfig<T extends SupastashSQLiteClientTypes>(): SupastashConfig<T>;
+/**
+ * Wrapper for `configureSupastash` that takes a strongly typed object containing
+ * the Supastash config, including optional schema initialization.
+ *
+ * Useful for abstracting config logic into a central setup file.
+ *
+ * @param config.dbOptions - The Supastash configuration object
+ * @param config.dbOptions.onSchemaInit - Optional callback to define the local schema
+ *
+ * @example
+ * defineSupastashConfig({
+ *   dbOptions: {
+ *     dbName: "supastash_db",
+ *     supabaseClient,
+ *     sqliteClient,
+ *     sqliteClientType: "expo",
+ *     onSchemaInit: () => {
+ *       defineLocalSchema("orders", { id: "TEXT PRIMARY KEY", status: "TEXT" });
+ *     },
+ *   },
+ * });
+ */
+export declare function defineSupastashConfig<T extends SupastashSQLiteClientTypes>(config: {
+    dbOptions: SupastashConfig<T> & {
+        onSchemaInit?: () => void;
+    };
+}): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC3B,MAAM,mCAAmC,CAAC;AAuB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,0BAA0B,EACrE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG;IAAE,gBAAgB,EAAE,CAAC,CAAA;CAAE,QAOrD;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/config/index.js

@@ -0,0 +1,111 @@
+let _config = {
+    dbName: "supastash_db",
+    supabaseClient: null,
+    sqliteClient: null,
+    sqliteClientType: null,
+    excludeTables: { pull: [], push: [] },
+    pollingInterval: {
+        pull: 30000,
+        push: 30000,
+    },
+    syncEngine: {
+        push: true,
+        pull: false,
+        useFiltersFromStore: true,
+    },
+    listeners: 250,
+    debugMode: false,
+};
+let _configured = false;
+/**
+ * Initializes the Supastash client.
+ *
+ * This must be called **once** during app startup (e.g., in `_layout.tsx` or `App.tsx`)
+ * before using any Supastash hooks or features.
+ *
+ * ⚠️ Pull sync is **disabled by default** to avoid unfiltered data fetches.
+ * Enable it only if you've configured **Row Level Security (RLS)** on your Supabase tables.
+ * The `useSupatashData` hook always performs filtered pull queries when `filter` is provided in the `options`, making it safe to use even when pull is disabled globally.
+ *
+ * @example
+ * import { supabase } from "./supabase";
+ * import { openDatabaseAsync } from "expo-sqlite";
+ * import { configureSupastash, defineLocalSchema } from "supastash";
+ *
+ * configureSupastash({
+ *   dbName: "supastash_db",
+ *   supabaseClient: supabase,
+ *   sqliteClient: { openDatabaseAsync },
+ *   sqliteClientType: "expo",
+ *   onSchemaInit: () => {
+ *     defineLocalSchema("users", {
+ *       id: "TEXT PRIMARY KEY",
+ *       name: "TEXT",
+ *       email: "TEXT",
+ *       created_at: "TIMESTAMP DEFAULT CURRENT_TIMESTAMP",
+ *       updated_at: "TIMESTAMP DEFAULT CURRENT_TIMESTAMP",
+ *     });
+ *   },
+ * });
+ *
+ * @param config - Configuration options for Supastash
+ * @param config.dbName - SQLite database name (default: `"supastash_db"`)
+ * @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.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`)
+ * @param config.excludeTables - Tables to exclude from sync (default: `{ pull: [], push: [] }`)
+ * @param config.pollingInterval - Polling interval for sync (default: `{ pull: 30000, push: 30000 }`)
+ * @param config.syncEngine - Control pull/push sync behavior (`push: true`, `pull: false` by default, `useFiltersFromStore: true` by default)
+ */
+export function configureSupastash(config) {
+    _config = {
+        ..._config,
+        ...config,
+    };
+    _configured = true;
+}
+/**
+ * Returns the current Supastash configuration.
+ *
+ * Throws an error if `configureSupastash` has not been called.
+ *
+ * @returns {SupastashConfig<T>} The active Supastash configuration
+ *
+ * @throws Will throw if Supastash is not configured or if essential values like
+ * `supabaseClient` or `sqliteClient` are missing.
+ *
+ * @example
+ * const config = getSupastashConfig();
+ * const dbName = config.dbName;
+ */
+export function getSupastashConfig() {
+    return _config;
+}
+/**
+ * Wrapper for `configureSupastash` that takes a strongly typed object containing
+ * the Supastash config, including optional schema initialization.
+ *
+ * Useful for abstracting config logic into a central setup file.
+ *
+ * @param config.dbOptions - The Supastash configuration object
+ * @param config.dbOptions.onSchemaInit - Optional callback to define the local schema
+ *
+ * @example
+ * defineSupastashConfig({
+ *   dbOptions: {
+ *     dbName: "supastash_db",
+ *     supabaseClient,
+ *     sqliteClient,
+ *     sqliteClientType: "expo",
+ *     onSchemaInit: () => {
+ *       defineLocalSchema("orders", { id: "TEXT PRIMARY KEY", status: "TEXT" });
+ *     },
+ *   },
+ * });
+ */
+export function defineSupastashConfig(config) {
+    configureSupastash(config.dbOptions);
+}

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

@@ -0,0 +1,19 @@
+import { LocalSchemaDefinition } from "../../types/schemaManager.types";
+/**
+ * Defines the schema for a local table manually
+ *
+ * @example
+ * defineLocalSchema("users", {
+ *   id: "TEXT NOT NULL",
+ *   name: "TEXT NOT NULL",
+ *   email: "TEXT NOT NULL",
+ * }, true // deletes previous schema if true. Must be true if schema already exists
+ * // ⚠️ Living option as true will continually delete table on load.
+ * );
+ *
+ * @param tableName - The name of the table
+ * @param schema - The schema for the table
+ * @param deletePreviousSchema - Whether to delete the previous schema. Default(false)
+ */
+export declare function defineLocalSchema(tableName: string, schema: LocalSchemaDefinition, deletePreviousSchema?: boolean): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/core/schemaManager/index.js

@@ -0,0 +1,53 @@
+import { getSupastashDb } from "../../db/dbInitializer";
+import { clearSchemaCache } from "../../utils/getTableSchema";
+import log from "../../utils/logs";
+/**
+ * Defines the schema for a local table manually
+ *
+ * @example
+ * defineLocalSchema("users", {
+ *   id: "TEXT NOT NULL",
+ *   name: "TEXT NOT NULL",
+ *   email: "TEXT NOT NULL",
+ * }, true // deletes previous schema if true. Must be true if schema already exists
+ * // ⚠️ Living option as true will continually delete table on load.
+ * );
+ *
+ * @param tableName - The name of the table
+ * @param schema - The schema for the table
+ * @param deletePreviousSchema - Whether to delete the previous schema. Default(false)
+ */
+export async function defineLocalSchema(tableName, schema, deletePreviousSchema = false) {
+    if (!schema.id) {
+        throw new Error(`'id' of type UUID column is required for table ${tableName}`);
+    }
+    try {
+        const db = await getSupastashDb();
+        // Include the columns that must be in the schema
+        const safeSchema = {
+            ...schema,
+            created_at: "TEXT NOT NULL",
+            updated_at: "TEXT NOT NULL",
+            synced_at: "TEXT DEFAULT NULL",
+            deleted_at: "TEXT DEFAULT NULL",
+        };
+        const schemaString = Object.entries(safeSchema)
+            .map(([key, value]) => `${key} ${value}`)
+            .join(", ");
+        const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${schemaString});`;
+        if (deletePreviousSchema) {
+            const dropSql = `DROP TABLE IF EXISTS ${tableName}`;
+            const clearSyncStatusSql = `DELETE FROM supastash_sync_status WHERE table_name = '${tableName}'`;
+            const clearDeleteStatusSql = `DELETE FROM supastash_deleted_status WHERE table_name = '${tableName}'`;
+            await db.execAsync(dropSql);
+            await db.execAsync(clearSyncStatusSql);
+            await db.execAsync(clearDeleteStatusSql);
+            await clearSchemaCache(tableName);
+            log(`[Supastash] Dropped table ${tableName}`);
+        }
+        await db.execAsync(sql);
+    }
+    catch (error) {
+        console.error(`[Supastash] Error defining schema for table ${tableName}`, error);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"expo_sqlite.d.ts","sourceRoot":"","sources":["../../../src/db/adapters/expo_sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,sBAAsB,EAEvB,MAAM,mCAAmC,CAAC;AAE3C,eAAO,MAAM,iBAAiB,EAAE,sBA8B/B,CAAC"}

package/dist/db/adapters/expo_sqlite.js

@@ -0,0 +1,21 @@
+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;
+            },
+        };
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rn_nitro.d.ts","sourceRoot":"","sources":["../../../src/db/adapters/rn_nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,sBAAsB,EAEvB,MAAM,mCAAmC,CAAC;AAE3C,eAAO,MAAM,kBAAkB,EAAE,sBA+BhC,CAAC"}

package/dist/db/adapters/rn_nitro.js

@@ -0,0 +1,22 @@
+export const SQLiteAdapterNitro = {
+    async openDatabaseAsync(name, sqliteClient) {
+        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;
+            },
+        };
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rn_sqlite_storage.d.ts","sourceRoot":"","sources":["../../../src/db/adapters/rn_sqlite_storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,sBAAsB,EAEvB,MAAM,mCAAmC,CAAC;AAE3C,eAAO,MAAM,oBAAoB,EAAE,sBA+BlC,CAAC"}

package/dist/db/adapters/rn_sqlite_storage.js

@@ -0,0 +1,22 @@
+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;
+            },
+        };
+    },
+};

package/dist/db/dbErrorMsg.d.ts

@@ -0,0 +1,2 @@
+export declare const supastashDbErrorMsg: string;
+//# sourceMappingURL=dbErrorMsg.d.ts.map

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

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

package/dist/db/dbErrorMsg.js

@@ -0,0 +1,28 @@
+export const supastashDbErrorMsg = "SQLite client not found. Please provide a SQLite client in the config. /n/n" +
+    "Supastash supports the following SQLite clients: \n" +
+    " - expo-sqlite \n" +
+    " - react-native-nitro-sqlite \n" +
+    " - react-native-sqlite-storage \n" +
+    "\n\n" +
+    "Add a SQLite client to your config and set the sqliteClientType to the client you are using. \n" +
+    "Example: \n" +
+    "import { openDatabaseAsync } from 'expo-sqlite';\n" +
+    "configureSupastash({ \n" +
+    "  sqliteClient: { openDatabaseAsync }, \n" +
+    "  sqliteClientType: 'expo', \n" +
+    "});" +
+    "\n\n" +
+    "or \n" +
+    "import { open } from 'react-native-nitro-sqlite';\n" +
+    "configureSupastash({ \n" +
+    "  sqliteClient: { open }, \n" +
+    "  sqliteClientType: 'rn-nitro', \n" +
+    "});" +
+    "\n\n" +
+    "or \n" +
+    "import { openDatabaseAsync } from 'react-native-sqlite-storage';\n" +
+    "configureSupastash({ \n" +
+    "  sqliteClient: { openDatabaseAsync }, \n" +
+    "  sqliteClientType: 'rn-storage', \n" +
+    "});" +
+    "\n\n";

package/dist/db/dbInitializer.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"dbInitializer.d.ts","sourceRoot":"","sources":["../../src/db/dbInitializer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAQzE;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAsBvE"}