@anfenn/dync 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adam Fennell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,212 @@
+## Dync
+
+[![npm version](https://img.shields.io/npm/v/@anfenn/dync.svg)](https://www.npmjs.com/package/@anfenn/dync)
+
+A complete React offline-first data layer with sync engine for any local storage (IndexedDB, Sqlite, etc.), and any backend (Restful, GraphQL, Supabase, etc.) in a Website, PWA, CapacitorJs, React Native, or Electron app.
+
+Start with a Website or PWA using IndexedDB, sync with your existing REST API, and later ship native apps with encrypted SQLite - without changing a line of code.
+
+## Why Dync?
+
+1. Frictionless upgrade path from an offline-first PWA targeting IndexedDB, to when:
+
+    **A)** Full text search is required on many records (IndexedDB doesn't support this so will do a full table scan in the JS VM, which is slow on many records)
+
+    **_and/or_**
+
+    **B)** Encryption is required (Browsers can't store the encryption key securely)
+
+    ... you can simply add CapacitorJs or move to React Native which have sqlite & secure enclave storage, and only change the adapter Dync uses
+
+2. Write once, run anywhere (Web, CapacitorJs, React Native, Electron & Node) with no code changes and native storage performance
+3. Completely free and open source
+
+<br>See first-hand in this fully working example: [examples/react-capacitor](examples/react-capacitor)
+
+And see how Dync compares to the alternatives [below](#hasnt-this-already-been-done).
+
+## Goals
+
+- Persist SQL or NoSQL data locally and sync some or all tables to a backend
+- Storage agnostic. Comes with `Memory`, `IndexedDB` and `Sqlite` adapters (for CapacitorJs & React Native), and extendable with your own custom adapters
+- Lazy loaded data keeps it in native storage, allowing low memory and fast app response, even with >100K records
+- Fast React Native Sqlite access via JSI
+- Dexie.js style collection based api, with query() escape hatch, and native storage performance e.g.:
+    - `db.myTable.add()` | `.update()` | `.where('myField').equals(42).first()`
+    - `db.query()` is only intended to retrieve records, any mutations will be ignored by the sync engine:
+        ```js
+        db.query(async (ctx) => {
+            if (ctx instanceof DexieQueryContext) {
+                return await ctx.table('items').where('value').equals('dexie-test');
+            } else if (ctx instanceof SqliteQueryContext) {
+                return await ctx.queryRows('SELECT * FROM items WHERE value = ?', ['sqlite-test']);
+            }
+        });
+        ```
+
+- Sync some or all tables with any backend in 2 ways:
+    - Option 1: Map remote api CRUD urls to a local collection:
+
+        ```ts
+        const db = makeDync(
+            ...,
+            {
+                // Only add an entry here for tables that should be synced
+                items: {
+                    add: (item) => fetch('/api/items'),
+                    update: (id, changes) => fetch(`/api/items/${id}`),
+                    remove: (id) => fetch(`/api/items/${id}`),
+                    list: (since) => fetch(`/api/items?since=${since}`),
+                },
+            },
+        );
+        ```
+
+    - Option 2: Batch sync to remote /push & /pull endpoints:
+
+        ```ts
+        const db = makeDync(
+            ...,
+            {
+                syncTables: ['items'], // Only add tables to this array that should be synced
+                push: (changes) => fetch('/api/sync/push'),
+                pull: (since) => fetch(`/api/sync/pull?since=${since}`),
+            },
+        );
+        ```
+
+        See [examples/shared/api.ts](examples/shared/api.ts) for a fully documented example of these two options.
+
+- Full conflict resolution: `local-wins`, `remote-wins` or with `try-shallow-merge` the user can resolve with:
+
+    ```ts
+    const { syncState, db } = useDync();
+    syncState.conflicts; // Record<id, Conflict> Use to show user conflicts
+    db.sync.resolveConflict(id, true);
+    ```
+
+- Optional first load data download before periodic sync is enabled
+- Missing remote record on update strategy: `ignore` | `delete-local-record` | `insert-remote-record`
+- Reactive updates when data changes via `useLiveQuery()` React hook:
+
+    ```ts
+    useLiveQuery(async (db) => {
+        const items = await db.items.toArray();
+        setItems(items);
+    }, []);
+    ```
+
+- Sqlite schema migration
+- "It just works" philosophy
+- Modern and always free (MIT)
+
+## Non-Goals
+
+- IndexedDB & SQL unified query language:
+    - Using IndexedDB functions or raw SQL will always be more expressive independently
+    - No need to learn another api when you might only need one storage type
+    - Would greatly increase complexity of this library
+
+## Hasn't this already been done?
+
+Many times, with varying degrees of functionality, compatibility, and cost.
+
+Dync aims to be a performant, multi-platform, modern and always free alternative.
+
+This is how Dync compares to other multi-platform sync engines:
+
+**_Legend:_**
+
+- _**SQLite:** Used natively by an installed Capacitor, React Native, Electron or Node app_
+- _**WA-SQLite:** Official SQLite compiled to WebAssembly that runs in the browser. Persists to IndexedDB or OPFS depending on VFS configuration (see [SQLite vs WA-SQLite](#sqlite-vs-wa-sqlite))_
+
+| Library                                                               | Installed Components | IndexedDB | SQLite     | WA-SQLite  | Any Backend              | CRUD Sync | Batch Sync | Conflict Resolution | Platforms                            | Notes                                                                                                                                  |
+| --------------------------------------------------------------------- | -------------------- | --------- | ---------- | ---------- | ------------------------ | --------- | ---------- | ------------------- | ------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------- |
+| [**Dync**](https://github.com/anfen/dync)                             | Client               | ✅        | ✅ Free    | ✅ Free    | ✅                       | ✅        | ✅         | ✅                  | Web, Capacitor, RN, Electron, Node   |                                                                                                                                        |
+| [**RxDB**](https://github.com/pubkey/rxdb)                            | Client               | ✅        | 💰 Premium | 💰 Premium | ✅                       | ❌        | ✅         | ✅                  | Web, Capacitor, RN, Electron, Node   |                                                                                                                                        |
+| [**WatermelonDB**](https://github.com/Nozbe/WatermelonDB)             | Client               | ✅        | ✅ Free    | ❌         | ✅                       | ❌        | ✅         | ❌                  | Web, RN, Node                        | ⚠️ Not Vite compatible<br>⚠️ Uses legacy JS proposals                                                                                  |
+| [**Legend State**](https://github.com/LegendApp/legend-state)         | Client               | ✅        | ✅ Free    | ❌         | ✅                       | ✅        | ❌         | ❌                  | Web, RN                              | ⚠️ [Data loss bugs as of 01/01/2026](https://github.com/LegendApp/legend-state/issues/547)<br>⚠️ Confusing observables based React api |
+| [**SignalDB**](https://github.com/maxnowack/signaldb)                 | Client               | ✅        | ❌         | ❌         | ✅                       | ❌        | ✅         | ❌                  | Web                                  |                                                                                                                                        |
+| [**TanStack DB**](https://github.com/TanStack/db)                     | Client               | ❌        | ❌         | ❌         | ✅                       | ✅        | ❌         | ❌                  | Web, RN                              | In-memory only<br>Integrates with RxDB/PowerSync/Electric for persistence                                                              |
+| [**Dexie.js**](https://github.com/dexie/Dexie.js)                     | Client               | ✅        | ❌         | ❌         | ❌ Dexie cloud only      | ❌        | ✅         | ❌                  | Web, Capacitor, RN, Electron         |                                                                                                                                        |
+| [**PouchDB**](https://github.com/pouchdb/pouchdb)                     | Client               | ✅        | ❌         | ❌         | ❌ CouchDB only          | ❌        | ✅         | ✅                  | Web, Electron, Node                  |                                                                                                                                        |
+| [**TinyBase**](https://github.com/tinyplex/tinybase)                  | Client               | ✅        | ✅ Free    | ✅ Free    | ❌ Client-to-client only | ❌        | ✅         | ✅                  | Web, RN, Electron, Node              |                                                                                                                                        |
+| [**ElectricSQL**](https://github.com/electric-sql/electric)           | Client & Server      | ❌        | ✅ Free    | ✅ Free    | ❌ Postgres only         | ❌        | ✅         | ✅                  | Web, RN, Electron, Node              |                                                                                                                                        |
+| [**PowerSync**](https://github.com/powersync-ja/powersync-js)         | Client & Server      | ❌        | ✅ Free    | ✅ Free    | ❌ PowerSync server only | ❌        | ✅         | ✅                  | Web, Capacitor, RN, Electron, Node   |                                                                                                                                        |
+| [**InstantDB**](https://github.com/instantdb/instant)                 | Client               | ✅        | ❌         | ❌         | ❌ InstantDB cloud only  | ❌        | ✅         | ✅                  | Web, RN                              |                                                                                                                                        |
+| [**Firebase/Firestore**](https://github.com/firebase/firebase-js-sdk) | Client               | ✅        | ❌         | ❌         | ❌ Firebase cloud only   | ❌        | ✅         | ✅                  | Web, iOS, Android, RN, Flutter, Node |                                                                                                                                        |
+
+## Examples
+
+Both are fully commented and can be run in the browser and natively on iOS/Android without code change:
+
+1. **React + Capacitor**: [examples/react-capacitor](examples/react-capacitor) - IndexedDB in the browser, SQLite natively
+2. **React Native + Expo SQLite**: [examples/react-native-expo-sqlite](examples/react-native-expo-sqlite) - WA-SQLite in the browser, SQLite natively
+
+## Design
+
+### Server Requirements
+
+Your server records **must** have these fields. If it does but they're named differently, rename them in your client's [api.ts](examples/shared/api.ts) using the included `changeKeysFrom()` & `changeKeysTo()` helpers:
+
+| Field        | Description                                                                                                                                                                                                                                                            |
+| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `id`         | Unique identifier (any datatype). Can be assigned by client or server.                                                                                                                                                                                                 |
+| `updated_at` | Server-assigned **millisecond** timestamp (e.g. via db trigger or API layer). The client never sends this as client clocks are unreliable. Ensure precision doesn't exceed milliseconds (like PostgreSQL's microsecond timestamptz), otherwise updates may be ignored. |
+| `deleted`    | Boolean for soft deletes. Allows other clients to sync deletions to their local store.                                                                                                                                                                                 |
+
+### Client Records
+
+Dync auto-injects these fields into your local table schema:
+
+| Field        | Description                                                                                                                       |
+| ------------ | --------------------------------------------------------------------------------------------------------------------------------- |
+| `_localId`   | Stable local identifier, never sent to the server. Ideal for React keys. Generate with `createLocalId()` or use any unique value. |
+| `id`         | Unique identifier (any datatype). Can be assigned by client or server.                                                            |
+| `updated_at` | Assigned from the server's `updated_at` after sync. You may set it optimistically, but it's always overwritten on sync.           |
+
+Note: `deleted` doesn't exist on the client, as it's removed during sync.
+
+## SQLite vs WA-SQLite
+
+**SQLite** runs natively in Capacitor, React Native, Electron, and Node apps via platform-specific drivers.
+
+**WA-SQLite** is SQLite compiled to WebAssembly, enabling SQL in the browser. It persists data to IndexedDB or OPFS depending on the Virtual File System (VFS) you choose.
+
+### When to use WA-SQLite
+
+- You need SQL queries in a web app (full-text search, complex joins, etc.)
+- Your dataset is too large for efficient IndexedDB queries
+- You want the same SQLite schema across web and native apps
+- You don't need encryption, as browsers can't securely store the encryption key
+- You're happy for a larger runtime memory footprint
+
+### WA-SQLite VFS Options
+
+Choose a VFS based on your app's requirements. See [`WaSqliteDriverOptions`](src/storage/sqlite/drivers/WaSqliteDriver.ts) for configuration.
+
+| VFS                     | Context | Multi-Tab | Durability | Performance | Best For                              |
+| ----------------------- | ------- | --------- | ---------- | ----------- | ------------------------------------- |
+| **IDBBatchAtomicVFS**   | Any     | ✅        | ✅ Full    | Good        | General use, maximum compatibility    |
+| **IDBMirrorVFS**        | Any     | ✅        | ⚠️ Async   | Fast        | Small databases, performance critical |
+| **OPFSCoopSyncVFS**     | Worker  | ✅        | ✅ Full    | Good        | Multi-tab apps needing OPFS           |
+| **AccessHandlePoolVFS** | Worker  | ❌        | ✅ Full    | Best        | Single-tab apps, maximum performance  |
+
+**Notes:**
+
+- **IDBBatchAtomicVFS** (default) is recommended for most apps - works in main thread and has full durability
+- **IDBMirrorVFS** keeps data in memory and mirrors to IndexedDB asynchronously - fast but may lose recent writes on crash
+- **OPFS VFS types** require a Web Worker context and are not supported on Safari/iOS
+
+```ts
+import { WaSqliteDriver, SQLiteAdapter } from '@anfenn/dync/wa-sqlite';
+
+const driver = new WaSqliteDriver('mydb', {
+    vfs: 'IDBBatchAtomicVFS', // or 'IDBMirrorVFS', 'OPFSCoopSyncVFS', 'AccessHandlePoolVFS'
+});
+const adapter = new SQLiteAdapter(driver);
+```
+
+## Community
+
+PRs are welcome! [pnpm](https://pnpm.io) is used as a package manager. Run `pnpm install` to install local dependencies. Thank you for contributing!

package/dist/capacitor.cjs

@@ -0,0 +1,228 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/capacitor.ts
+var capacitor_exports = {};
+__export(capacitor_exports, {
+  CapacitorFastSqlDriver: () => CapacitorFastSqlDriver,
+  CapacitorSQLiteDriver: () => CapacitorSQLiteDriver
+});
+module.exports = __toCommonJS(capacitor_exports);
+
+// src/storage/sqlite/drivers/CapacitorSQLiteDriver.ts
+var sqliteModuleCache = null;
+async function getSqliteModule() {
+  if (!sqliteModuleCache) {
+    sqliteModuleCache = await import("@capacitor-community/sqlite");
+  }
+  return sqliteModuleCache;
+}
+var CapacitorSQLiteDriver = class {
+  type = "CapacitorSQLiteDriver";
+  connectionFactory;
+  config;
+  db;
+  openPromise;
+  opened = false;
+  name;
+  constructor(databaseName, config = {}) {
+    this.name = databaseName;
+    this.config = config;
+  }
+  async getConnectionFactory() {
+    if (!this.connectionFactory) {
+      const { CapacitorSQLite, SQLiteConnection } = await getSqliteModule();
+      this.connectionFactory = new SQLiteConnection(CapacitorSQLite);
+    }
+    return this.connectionFactory;
+  }
+  async ensureDb() {
+    if (!this.db) {
+      const connectionFactory = await this.getConnectionFactory();
+      const readonly = this.config.readonly ?? false;
+      const existsResult = await connectionFactory.isConnection(this.name, readonly);
+      if (existsResult.result) {
+        this.db = await connectionFactory.retrieveConnection(this.name, readonly);
+      } else {
+        await connectionFactory.closeConnection(this.name, readonly).catch(() => {
+        });
+        this.db = await connectionFactory.createConnection(
+          this.name,
+          this.config.encrypted ?? false,
+          this.config.mode ?? "no-encryption",
+          this.config.version ?? 1,
+          readonly
+        );
+      }
+      this.opened = false;
+    }
+    return this.db;
+  }
+  async open() {
+    if (this.opened) return;
+    if (this.openPromise) return this.openPromise;
+    this.openPromise = (async () => {
+      const connectionFactory = await this.getConnectionFactory();
+      if (this.config.getEncryptionKey) {
+        const { result: isStored } = await connectionFactory.isSecretStored();
+        if (!isStored) {
+          const key = this.config.getEncryptionKey();
+          if (!key && this.config.encrypted) {
+            throw new Error("CapacitorSQLiteDriverOptions.encrypted=true but no encryption key was provided (getEncryptionKey).");
+          }
+          await connectionFactory.setEncryptionSecret(key);
+        }
+      }
+      const db = await this.ensureDb();
+      await db.open();
+      this.opened = true;
+    })();
+    try {
+      await this.openPromise;
+    } finally {
+      this.openPromise = void 0;
+    }
+  }
+  async close() {
+    if (!this.db) return;
+    await this.db.close();
+    const connectionFactory = await this.getConnectionFactory();
+    await connectionFactory.closeConnection(this.name, this.config.readonly ?? false);
+    this.db = void 0;
+    this.opened = false;
+    this.openPromise = void 0;
+  }
+  async execute(statement) {
+    await this.open();
+    const db = await this.ensureDb();
+    await db.execute(statement, false);
+  }
+  async run(statement, values = []) {
+    await this.open();
+    const db = await this.ensureDb();
+    const result = await db.run(statement, values, false, "no");
+    const changes = result?.changes?.changes ?? result?.changes ?? 0;
+    const lastId = result?.changes?.lastId ?? void 0;
+    return { changes, lastId };
+  }
+  async query(statement, values = []) {
+    await this.open();
+    const db = await this.ensureDb();
+    const result = await db.query(statement, values, true);
+    if (Array.isArray(result?.values) && result.values.length > 0 && !Array.isArray(result.values[0])) {
+      const columns = Object.keys(result.values[0]);
+      const rows = result.values.map((row) => columns.map((column) => row[column]));
+      return { columns, values: rows };
+    }
+    return { columns: result?.columns ?? [], values: result?.values ?? [] };
+  }
+};
+
+// src/storage/sqlite/drivers/CapacitorFastSqlDriver.ts
+var fastSqlModuleCache = null;
+async function getFastSqlModule() {
+  if (!fastSqlModuleCache) {
+    fastSqlModuleCache = await import("@capgo/capacitor-fast-sql");
+  }
+  return fastSqlModuleCache;
+}
+var CapacitorFastSqlDriver = class {
+  type = "CapacitorFastSqlDriver";
+  options;
+  db;
+  openPromise;
+  opened = false;
+  name;
+  constructor(databaseName, options = {}) {
+    this.name = databaseName;
+    this.options = options;
+  }
+  async open() {
+    if (this.opened) return;
+    if (this.openPromise) return this.openPromise;
+    this.openPromise = (async () => {
+      if (!this.db) {
+        const { FastSQL } = await getFastSqlModule();
+        const encryptionKey = this.options.getEncryptionKey?.();
+        if (!encryptionKey && this.options.encrypted) {
+          throw new Error("FastSqlDriverOptions.encrypted=true but no encryption key was provided (getEncryptionKey).");
+        }
+        this.db = await FastSQL.connect({
+          database: this.name,
+          encrypted: this.options.encrypted,
+          encryptionKey,
+          readOnly: this.options.readonly
+        });
+        this.opened = true;
+      }
+    })();
+    try {
+      await this.openPromise;
+    } finally {
+      this.openPromise = void 0;
+    }
+  }
+  async close() {
+    if (this.db) {
+      const { FastSQL } = await getFastSqlModule();
+      await FastSQL.disconnect(this.name);
+      this.db = void 0;
+      this.opened = false;
+      this.openPromise = void 0;
+    }
+  }
+  async execute(statement) {
+    await this.open();
+    await this.db.execute(statement);
+  }
+  async run(statement, values = []) {
+    await this.open();
+    const result = await this.db.run(statement, values);
+    return {
+      changes: result.rowsAffected,
+      lastId: result.insertId
+    };
+  }
+  async query(statement, values = []) {
+    await this.open();
+    const rows = await this.db.query(statement, values);
+    if (!rows.length) {
+      return { columns: [], values: [] };
+    }
+    const columns = Object.keys(rows[0]);
+    const resultValues = rows.map((row) => columns.map((col) => row[col]));
+    return { columns, values: resultValues };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CapacitorFastSqlDriver,
+  CapacitorSQLiteDriver
+});
+//# sourceMappingURL=capacitor.cjs.map

package/dist/capacitor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/capacitor.ts","../src/storage/sqlite/drivers/CapacitorSQLiteDriver.ts","../src/storage/sqlite/drivers/CapacitorFastSqlDriver.ts"],"sourcesContent":["// Capacitor SQLite Drivers\n// Import this entry point only in Capacitor/native builds\nexport { CapacitorSQLiteDriver } from './storage/sqlite/drivers/CapacitorSQLiteDriver';\nexport { CapacitorFastSqlDriver, type FastSqlDriverOptions } from './storage/sqlite/drivers/CapacitorFastSqlDriver';\n","import type { SQLiteConnection, SQLiteDBConnection } from '@capacitor-community/sqlite';\nimport type { SQLiteDatabaseDriver, SQLiteRunResult, SQLiteQueryResult } from '../types';\n\n// Lazily loaded module cache to avoid top-level imports that break web bundlers\nlet sqliteModuleCache: typeof import('@capacitor-community/sqlite') | null = null;\n\nasync function getSqliteModule(): Promise<typeof import('@capacitor-community/sqlite')> {\n    if (!sqliteModuleCache) {\n        sqliteModuleCache = await import('@capacitor-community/sqlite');\n    }\n    return sqliteModuleCache;\n}\n\nexport interface CapacitorSQLiteDriverOptions {\n    encrypted?: boolean;\n    getEncryptionKey?: () => string;\n    readonly?: boolean;\n    mode?: string;\n    version?: number;\n}\n\nexport class CapacitorSQLiteDriver implements SQLiteDatabaseDriver {\n    readonly type = 'CapacitorSQLiteDriver';\n    private connectionFactory?: SQLiteConnection;\n    private readonly config: CapacitorSQLiteDriverOptions;\n    private db?: SQLiteDBConnection;\n    private openPromise?: Promise<void>;\n    private opened = false;\n    readonly name: string;\n\n    constructor(databaseName: string, config: CapacitorSQLiteDriverOptions = {}) {\n        this.name = databaseName;\n        this.config = config;\n    }\n\n    private async getConnectionFactory(): Promise<SQLiteConnection> {\n        if (!this.connectionFactory) {\n            const { CapacitorSQLite, SQLiteConnection } = await getSqliteModule();\n            this.connectionFactory = new SQLiteConnection(CapacitorSQLite);\n        }\n        return this.connectionFactory;\n    }\n\n    private async ensureDb(): Promise<SQLiteDBConnection> {\n        if (!this.db) {\n            const connectionFactory = await this.getConnectionFactory();\n            const readonly = this.config.readonly ?? false;\n\n            // Check if a connection already exists (e.g., after page reload)\n            const existsResult = await connectionFactory.isConnection(this.name, readonly);\n            if (existsResult.result) {\n                // Connection exists - retrieve it instead of creating a new one\n                this.db = await connectionFactory.retrieveConnection(this.name, readonly);\n            } else {\n                // Close any stale native connection (e.g., after page reload) before creating\n                await connectionFactory.closeConnection(this.name, readonly).catch(() => {});\n                this.db = await connectionFactory.createConnection(\n                    this.name,\n                    this.config.encrypted ?? false,\n                    this.config.mode ?? 'no-encryption',\n                    this.config.version ?? 1,\n                    readonly,\n                );\n            }\n\n            // New/retrieved connection means we need to (re)open it.\n            this.opened = false;\n        }\n        return this.db;\n    }\n\n    async open(): Promise<void> {\n        if (this.opened) return;\n        if (this.openPromise) return this.openPromise;\n\n        this.openPromise = (async () => {\n            const connectionFactory = await this.getConnectionFactory();\n            // Set encryption secret if provided and not already stored (must be done before opening)\n            if (this.config.getEncryptionKey) {\n                const { result: isStored } = await connectionFactory.isSecretStored();\n                if (!isStored) {\n                    const key = this.config.getEncryptionKey();\n                    if (!key && this.config.encrypted) {\n                        throw new Error('CapacitorSQLiteDriverOptions.encrypted=true but no encryption key was provided (getEncryptionKey).');\n                    }\n                    await connectionFactory.setEncryptionSecret(key);\n                }\n            }\n            const db = await this.ensureDb();\n            await db.open();\n            this.opened = true;\n        })();\n\n        try {\n            await this.openPromise;\n        } finally {\n            this.openPromise = undefined;\n        }\n    }\n\n    async close(): Promise<void> {\n        if (!this.db) return;\n        await this.db.close();\n        const connectionFactory = await this.getConnectionFactory();\n        await connectionFactory.closeConnection(this.name, this.config.readonly ?? false);\n        this.db = undefined;\n        this.opened = false;\n        this.openPromise = undefined;\n    }\n\n    async execute(statement: string): Promise<void> {\n        await this.open();\n        const db = await this.ensureDb();\n        await db.execute(statement, false);\n    }\n\n    async run(statement: string, values: any[] = []): Promise<SQLiteRunResult> {\n        await this.open();\n        const db = await this.ensureDb();\n        const result = await db.run(statement, values, false, 'no');\n        const changes = (result as any)?.changes?.changes ?? (result as any)?.changes ?? 0;\n        const lastId = (result as any)?.changes?.lastId ?? undefined;\n        return { changes, lastId };\n    }\n\n    async query(statement: string, values: any[] = []): Promise<SQLiteQueryResult> {\n        await this.open();\n        const db = await this.ensureDb();\n        const result: any = await db.query(statement, values, true);\n        if (Array.isArray(result?.values) && result.values.length > 0 && !Array.isArray(result.values[0])) {\n            const columns = Object.keys(result.values[0]);\n            const rows = result.values.map((row: Record<string, any>) => columns.map((column) => row[column]));\n            return { columns, values: rows };\n        }\n        return { columns: result?.columns ?? [], values: result?.values ?? [] };\n    }\n}\n","import type { SQLConnection, SQLValue } from '@capgo/capacitor-fast-sql';\n\nimport type { SQLiteDatabaseDriver, SQLiteRunResult, SQLiteQueryResult } from '../types';\n\nexport interface FastSqlDriverOptions {\n    encrypted?: boolean;\n    getEncryptionKey?: () => string;\n    readonly?: boolean;\n}\n\n// Lazily loaded module cache to avoid top-level imports that break web bundlers\nlet fastSqlModuleCache: typeof import('@capgo/capacitor-fast-sql') | null = null;\n\nasync function getFastSqlModule(): Promise<typeof import('@capgo/capacitor-fast-sql')> {\n    if (!fastSqlModuleCache) {\n        fastSqlModuleCache = await import('@capgo/capacitor-fast-sql');\n    }\n    return fastSqlModuleCache;\n}\n\n/**\n * SQLiteDatabaseDriver implementation for @capgo/capacitor-fast-sql plugin.\n *\n * This driver provides a compatible interface with the existing SQLiteAdapter\n * while using the Capgo Fast SQL plugin which offers better performance through\n * a local HTTP server approach that bypasses Capacitor's bridge.\n * \n * Update your AndroidManifest.xml to allow cleartext traffic:\n * <application\n        ...\n        android:usesCleartextTraffic=\"true\">\n\n    Requires Capacitor HTTP plugin to prevent CORS, as FastSql server runs on localhost:9000, not Capacitor's localhost\n */\nexport class CapacitorFastSqlDriver implements SQLiteDatabaseDriver {\n    readonly type = 'CapacitorFastSqlDriver';\n    private readonly options: FastSqlDriverOptions;\n    private db?: SQLConnection;\n    private openPromise?: Promise<void>;\n    private opened = false;\n    readonly name: string;\n\n    constructor(databaseName: string, options: FastSqlDriverOptions = {}) {\n        this.name = databaseName;\n        this.options = options;\n    }\n\n    async open(): Promise<void> {\n        if (this.opened) return;\n        if (this.openPromise) return this.openPromise;\n\n        this.openPromise = (async () => {\n            if (!this.db) {\n                const { FastSQL } = await getFastSqlModule();\n                const encryptionKey = this.options.getEncryptionKey?.();\n                if (!encryptionKey && this.options.encrypted) {\n                    throw new Error('FastSqlDriverOptions.encrypted=true but no encryption key was provided (getEncryptionKey).');\n                }\n                this.db = await FastSQL.connect({\n                    database: this.name,\n                    encrypted: this.options.encrypted,\n                    encryptionKey,\n                    readOnly: this.options.readonly,\n                });\n                this.opened = true;\n            }\n        })();\n\n        try {\n            await this.openPromise;\n        } finally {\n            this.openPromise = undefined;\n        }\n    }\n\n    async close(): Promise<void> {\n        if (this.db) {\n            const { FastSQL } = await getFastSqlModule();\n            await FastSQL.disconnect(this.name);\n            this.db = undefined;\n            this.opened = false;\n            this.openPromise = undefined;\n        }\n    }\n\n    async execute(statement: string): Promise<void> {\n        await this.open();\n        await this.db!.execute(statement);\n    }\n\n    async run(statement: string, values: any[] = []): Promise<SQLiteRunResult> {\n        await this.open();\n        const result = await this.db!.run(statement, values as SQLValue[]);\n        return {\n            changes: result.rowsAffected,\n            lastId: result.insertId,\n        };\n    }\n\n    async query(statement: string, values: any[] = []): Promise<SQLiteQueryResult> {\n        await this.open();\n        const rows = await this.db!.query(statement, values as SQLValue[]);\n\n        // Convert array of objects to columns + values format expected by adapter\n        if (!rows.length) {\n            return { columns: [], values: [] };\n        }\n\n        const columns = Object.keys(rows[0]!);\n        const resultValues = rows.map((row) => columns.map((col) => (row as Record<string, any>)[col]));\n\n        return { columns, values: resultValues };\n    }\n}\n"],"mappings":"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","names":[]}

package/dist/capacitor.d.cts

@@ -0,0 +1,62 @@
+import { S as SQLiteDatabaseDriver, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-CSbIAfu2.cjs';
+
+interface CapacitorSQLiteDriverOptions {
+    encrypted?: boolean;
+    getEncryptionKey?: () => string;
+    readonly?: boolean;
+    mode?: string;
+    version?: number;
+}
+declare class CapacitorSQLiteDriver implements SQLiteDatabaseDriver {
+    readonly type = "CapacitorSQLiteDriver";
+    private connectionFactory?;
+    private readonly config;
+    private db?;
+    private openPromise?;
+    private opened;
+    readonly name: string;
+    constructor(databaseName: string, config?: CapacitorSQLiteDriverOptions);
+    private getConnectionFactory;
+    private ensureDb;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    execute(statement: string): Promise<void>;
+    run(statement: string, values?: any[]): Promise<SQLiteRunResult>;
+    query(statement: string, values?: any[]): Promise<SQLiteQueryResult>;
+}
+
+interface FastSqlDriverOptions {
+    encrypted?: boolean;
+    getEncryptionKey?: () => string;
+    readonly?: boolean;
+}
+/**
+ * SQLiteDatabaseDriver implementation for @capgo/capacitor-fast-sql plugin.
+ *
+ * This driver provides a compatible interface with the existing SQLiteAdapter
+ * while using the Capgo Fast SQL plugin which offers better performance through
+ * a local HTTP server approach that bypasses Capacitor's bridge.
+ *
+ * Update your AndroidManifest.xml to allow cleartext traffic:
+ * <application
+        ...
+        android:usesCleartextTraffic="true">
+
+    Requires Capacitor HTTP plugin to prevent CORS, as FastSql server runs on localhost:9000, not Capacitor's localhost
+ */
+declare class CapacitorFastSqlDriver implements SQLiteDatabaseDriver {
+    readonly type = "CapacitorFastSqlDriver";
+    private readonly options;
+    private db?;
+    private openPromise?;
+    private opened;
+    readonly name: string;
+    constructor(databaseName: string, options?: FastSqlDriverOptions);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    execute(statement: string): Promise<void>;
+    run(statement: string, values?: any[]): Promise<SQLiteRunResult>;
+    query(statement: string, values?: any[]): Promise<SQLiteQueryResult>;
+}
+
+export { CapacitorFastSqlDriver, CapacitorSQLiteDriver, type FastSqlDriverOptions };

package/dist/capacitor.d.ts

@@ -0,0 +1,62 @@
+import { S as SQLiteDatabaseDriver, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-CSbIAfu2.js';
+
+interface CapacitorSQLiteDriverOptions {
+    encrypted?: boolean;
+    getEncryptionKey?: () => string;
+    readonly?: boolean;
+    mode?: string;
+    version?: number;
+}
+declare class CapacitorSQLiteDriver implements SQLiteDatabaseDriver {
+    readonly type = "CapacitorSQLiteDriver";
+    private connectionFactory?;
+    private readonly config;
+    private db?;
+    private openPromise?;
+    private opened;
+    readonly name: string;
+    constructor(databaseName: string, config?: CapacitorSQLiteDriverOptions);
+    private getConnectionFactory;
+    private ensureDb;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    execute(statement: string): Promise<void>;
+    run(statement: string, values?: any[]): Promise<SQLiteRunResult>;
+    query(statement: string, values?: any[]): Promise<SQLiteQueryResult>;
+}
+
+interface FastSqlDriverOptions {
+    encrypted?: boolean;
+    getEncryptionKey?: () => string;
+    readonly?: boolean;
+}
+/**
+ * SQLiteDatabaseDriver implementation for @capgo/capacitor-fast-sql plugin.
+ *
+ * This driver provides a compatible interface with the existing SQLiteAdapter
+ * while using the Capgo Fast SQL plugin which offers better performance through
+ * a local HTTP server approach that bypasses Capacitor's bridge.
+ *
+ * Update your AndroidManifest.xml to allow cleartext traffic:
+ * <application
+        ...
+        android:usesCleartextTraffic="true">
+
+    Requires Capacitor HTTP plugin to prevent CORS, as FastSql server runs on localhost:9000, not Capacitor's localhost
+ */
+declare class CapacitorFastSqlDriver implements SQLiteDatabaseDriver {
+    readonly type = "CapacitorFastSqlDriver";
+    private readonly options;
+    private db?;
+    private openPromise?;
+    private opened;
+    readonly name: string;
+    constructor(databaseName: string, options?: FastSqlDriverOptions);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    execute(statement: string): Promise<void>;
+    run(statement: string, values?: any[]): Promise<SQLiteRunResult>;
+    query(statement: string, values?: any[]): Promise<SQLiteQueryResult>;
+}
+
+export { CapacitorFastSqlDriver, CapacitorSQLiteDriver, type FastSqlDriverOptions };

package/dist/capacitor.js

@@ -0,0 +1,9 @@
+import {
+  CapacitorFastSqlDriver,
+  CapacitorSQLiteDriver
+} from "./chunk-SQB6E7V2.js";
+export {
+  CapacitorFastSqlDriver,
+  CapacitorSQLiteDriver
+};
+//# sourceMappingURL=capacitor.js.map

package/dist/capacitor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}