@capgo/capacitor-fast-sql 8.2.11 → 8.2.13

package/README.md

@@ -1,16 +1,17 @@
-# @capgo/capacitor-fast-sql
+# @capgo/capacitor-fast-sql
 
 Run SQLite fast in your Capacitor app: queries go through a local HTTP channel instead of the bridge, so large result sets and sync jobs stay quick. A practical replacement for IndexedDB, with optional encryption.
 
-<a href="https://capgo.app/?ref=plugin_fast_sql"><img src="https://capgo.app/readme-banner.svg?repo=Cap-go/capacitor-fast-sql" alt="Capgo - Instant updates for Capacitor" /></a>
+<a href="https://capgo.app/?ref=plugin_fast_sql"><img src="https://capgo.app/readme-banner.svg?repo=Cap-go/capacitor-fast-sql" alt="Capgo - Build Capacitor apps with AI, ship updates instantly" /></a>
 
 <div align="center">
   <p><b>Capgo</b>: push fixes to your Capacitor users in minutes, build signed iOS and Android apps without a Mac, and roll back in one click.</p>
   <h2><a href="https://capgo.app/register/?ref=plugin_fast_sql">➡️ Get started for free</a></h2>
   <p>14-day unlimited free trial. No credit card required</p>
-  <p><a href="https://capgo.app/consulting/?ref=plugin_fast_sql">Missing a feature? We'll build the plugin for you 💪</a></p>
 </div>
 
+> 🤖 **Building with an AI coding agent?** Install [Capgo skills](https://capgo.app/skills/?ref=plugin_fast_sql) so Claude Code, Codex, Cursor, Copilot, or Gemini CLI know how to install and use `@capgo/capacitor-fast-sql` in your Capacitor app: `npx skills add Cap-go/capgo-skills`. Then ask your agent: *"Add @capgo/capacitor-fast-sql to my Capacitor app and wire it up."* [Agent setup guides](https://capgo.app/agents/?ref=plugin_fast_sql) · [Hosted MCP](https://capgo.app/docs/ai/mcp/?ref=plugin_fast_sql)
+
 <p align="center">
   <img src="https://raw.githubusercontent.com/Cap-go/capacitor-fast-sql/main/assets/github-social-preview.png" alt="@capgo/capacitor-fast-sql for Capacitor apps" width="300" />
 </p>
@@ -24,151 +25,151 @@ Run SQLite fast in your Capacitor app: queries go through a local HTTP channel i
 - **Web**: `configureWeb()` sets up the official SQLite Wasm module, with OPFS persistence when your server allows it.
 - **Platforms**: iOS, Android and Web. Native SQLite on iOS and Android, SQLite Wasm on web.
 
-## Why Fast SQL?
-
-Traditional Capacitor plugins serialize data through the JavaScript bridge, which becomes inefficient with large datasets. Fast SQL solves this by establishing a local HTTP server for direct native communication, making it ideal for:
-
-- **Local-first sync systems** (CRDTs, operational transforms)
-- **IndexedDB replacement** on platforms with broken/limited implementations
-- **Large dataset operations** requiring high throughput
-- **Batch operations** with thousands of rows
-- **Binary data storage** (BLOBs, files)
-
-## Documentation
-
-The most complete doc is available here: https://capgo.app/docs/plugins/fast-sql/
-
-## Compatibility
-
-| Plugin version | Capacitor compatibility | Maintained |
-| -------------- | ----------------------- | ---------- |
-| v8.\*.\*       | v8.\*.\*                | ✅          |
-| v7.\*.\*       | v7.\*.\*                | On demand   |
-| v6.\*.\*       | v6.\*.\*                | ❌          |
-| v5.\*.\*       | v5.\*.\*                | ❌          |
-
-> **Note:** The major version of this plugin follows the major version of Capacitor. Use the version that matches your Capacitor installation (e.g., plugin v8 for Capacitor 8). Only the latest major version is actively maintained.
-
-## Install
-
-You can use our AI-Assisted Setup to install the plugin. Add the Capgo skills to your AI tool using the following command:
-
-```bash
-npx skills add https://github.com/cap-go/capacitor-skills --skill capacitor-plugins
-```
-
-Then use the following prompt:
-
-```text
-Use the `capacitor-plugins` skill from `cap-go/capacitor-skills` to install the `@capgo/capacitor-fast-sql` plugin in my project.
-```
-
-If you prefer Manual Setup, install the plugin by running the following commands and follow the platform-specific instructions below:
-
-```bash
-npm install @capgo/capacitor-fast-sql
-npx cap sync
-```
-
-## Overview
-
-This plugin provides direct native SQLite database access with a custom communication protocol inspired by [capacitor-blob-writer](https://github.com/diachedelic/capacitor-blob-writer). Instead of using Capacitor's standard bridge (which serializes data inefficiently), it establishes a local HTTP server for optimal performance with large datasets and sync operations.
-
-### Key Features
-
-- **Custom HTTP Protocol**: Bypasses Capacitor's bridge for up to 25x faster performance with large data
-- **Direct Native SQLite**: Full SQL support with transactions, batch operations, and binary data
-- **Sync-Friendly**: Designed for local sync systems (CRDTs, operational transforms, etc.)
-- **IndexedDB Replacement**: Provides reliable alternative to broken/limited IndexedDB implementations
+## Why Fast SQL?
+
+Traditional Capacitor plugins serialize data through the JavaScript bridge, which becomes inefficient with large datasets. Fast SQL solves this by establishing a local HTTP server for direct native communication, making it ideal for:
+
+- **Local-first sync systems** (CRDTs, operational transforms)
+- **IndexedDB replacement** on platforms with broken/limited implementations
+- **Large dataset operations** requiring high throughput
+- **Batch operations** with thousands of rows
+- **Binary data storage** (BLOBs, files)
+
+## Documentation
+
+The most complete doc is available here: https://capgo.app/docs/plugins/fast-sql/
+
+## Compatibility
+
+| Plugin version | Capacitor compatibility | Maintained |
+| -------------- | ----------------------- | ---------- |
+| v8.\*.\*       | v8.\*.\*                | ✅          |
+| v7.\*.\*       | v7.\*.\*                | On demand   |
+| v6.\*.\*       | v6.\*.\*                | ❌          |
+| v5.\*.\*       | v5.\*.\*                | ❌          |
+
+> **Note:** The major version of this plugin follows the major version of Capacitor. Use the version that matches your Capacitor installation (e.g., plugin v8 for Capacitor 8). Only the latest major version is actively maintained.
+
+## Install
+
+You can use our AI-Assisted Setup to install the plugin. Add the Capgo skills to your AI tool using the following command:
+
+```bash
+npx skills add https://github.com/cap-go/capacitor-skills --skill capacitor-plugins
+```
+
+Then use the following prompt:
+
+```text
+Use the `capacitor-plugins` skill from `cap-go/capacitor-skills` to install the `@capgo/capacitor-fast-sql` plugin in my project.
+```
+
+If you prefer Manual Setup, install the plugin by running the following commands and follow the platform-specific instructions below:
+
+```bash
+npm install @capgo/capacitor-fast-sql
+npx cap sync
+```
+
+## Overview
+
+This plugin provides direct native SQLite database access with a custom communication protocol inspired by [capacitor-blob-writer](https://github.com/diachedelic/capacitor-blob-writer). Instead of using Capacitor's standard bridge (which serializes data inefficiently), it establishes a local HTTP server for optimal performance with large datasets and sync operations.
+
+### Key Features
+
+- **Custom HTTP Protocol**: Bypasses Capacitor's bridge for up to 25x faster performance with large data
+- **Direct Native SQLite**: Full SQL support with transactions, batch operations, and binary data
+- **Sync-Friendly**: Designed for local sync systems (CRDTs, operational transforms, etc.)
+- **IndexedDB Replacement**: Provides reliable alternative to broken/limited IndexedDB implementations
 - **Cross-Platform**: iOS, Android, and Web (using [@sqlite.org/sqlite-wasm](https://github.com/sqlite/sqlite-wasm) with OPFS persistence)
-- **Optional RAG VectorStore**: Persist many named vector stores for retrieval-augmented generation without adding a native dependency
-
-## iOS Configuration
-
-This plugin runs a local HTTP server on `localhost`. iOS App Transport Security (ATS) blocks cleartext HTTP by default, so you **must** allow local networking in your `Info.plist`:
-
-```xml
-<key>NSAppTransportSecurity</key>
-<dict>
-    <key>NSAllowsLocalNetworking</key>
-    <true/>
-</dict>
-```
-
-This only permits cleartext to loopback addresses (`localhost` / `127.0.0.1`), it does not weaken ATS for external connections.
-
-## Android Configuration
-
-This plugin runs a local HTTP server on `localhost` to bypass Capacitor's bridge for performance. Android 9+ blocks cleartext (non-HTTPS) traffic by default, so you **must** allow it for `localhost`.
-
-**Option A, Scoped to localhost only (recommended):**
-
-Create `android/app/src/main/res/xml/network_security_config.xml`:
-
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<network-security-config>
-    <domain-config cleartextTrafficPermitted="true">
-        <domain includeSubdomains="false">localhost</domain>
-        <domain includeSubdomains="false">127.0.0.1</domain>
-    </domain-config>
-</network-security-config>
-```
-
-Then reference it in your `AndroidManifest.xml`:
-
-```xml
-<application
-    android:networkSecurityConfig="@xml/network_security_config">
-    ...
-</application>
-```
-
-**Option B, Allow all cleartext (simpler but less secure):**
-
-```xml
-<application
-    android:usesCleartextTraffic="true">
-    ...
-</application>
-```
-
-## Encryption
-
-### Android
-
-Encryption uses [SQLCipher](https://www.zetetic.net/sqlcipher/) and is opt-in. Add the SQLCipher dependency to your **app-level** `build.gradle`:
-
-```gradle
-dependencies {
-    implementation 'net.zetetic:sqlcipher-android:4.13.0'
-}
-```
-
-Then connect with encryption enabled:
-
-```typescript
-const db = await FastSQL.connect({
-  database: 'secure',
-  encrypted: true,
-  encryptionKey: 'my-secret-key',
-});
-```
-
-If SQLCipher is not installed and `encrypted: true` is passed, the plugin returns a clear error message instead of crashing.
-
-### iOS
-
-SQLCipher is optional on iOS. The plugin builds without it; encryption calls will return `Encryption is not available in this build` unless SQLCipher is installed.
-
-To enable encryption via CocoaPods, update your `ios/App/Podfile` after `capacitor install`/`cap sync` to use the SQLCipher subspec:
-
-```ruby
-pod 'CapgoCapacitorFastSql/SQLCipher', :path => '../../node_modules/@capgo/capacitor-fast-sql'
-```
-
-Then run `pod install` in the `ios/App` directory. If you skip this subspec, keep `encrypted: false`.
-
+- **Optional RAG VectorStore**: Persist many named vector stores for retrieval-augmented generation without adding a native dependency
+
+## iOS Configuration
+
+This plugin runs a local HTTP server on `localhost`. iOS App Transport Security (ATS) blocks cleartext HTTP by default, so you **must** allow local networking in your `Info.plist`:
+
+```xml
+<key>NSAppTransportSecurity</key>
+<dict>
+    <key>NSAllowsLocalNetworking</key>
+    <true/>
+</dict>
+```
+
+This only permits cleartext to loopback addresses (`localhost` / `127.0.0.1`), it does not weaken ATS for external connections.
+
+## Android Configuration
+
+This plugin runs a local HTTP server on `localhost` to bypass Capacitor's bridge for performance. Android 9+ blocks cleartext (non-HTTPS) traffic by default, so you **must** allow it for `localhost`.
+
+**Option A, Scoped to localhost only (recommended):**
+
+Create `android/app/src/main/res/xml/network_security_config.xml`:
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <domain-config cleartextTrafficPermitted="true">
+        <domain includeSubdomains="false">localhost</domain>
+        <domain includeSubdomains="false">127.0.0.1</domain>
+    </domain-config>
+</network-security-config>
+```
+
+Then reference it in your `AndroidManifest.xml`:
+
+```xml
+<application
+    android:networkSecurityConfig="@xml/network_security_config">
+    ...
+</application>
+```
+
+**Option B, Allow all cleartext (simpler but less secure):**
+
+```xml
+<application
+    android:usesCleartextTraffic="true">
+    ...
+</application>
+```
+
+## Encryption
+
+### Android
+
+Encryption uses [SQLCipher](https://www.zetetic.net/sqlcipher/) and is opt-in. Add the SQLCipher dependency to your **app-level** `build.gradle`:
+
+```gradle
+dependencies {
+    implementation 'net.zetetic:sqlcipher-android:4.13.0'
+}
+```
+
+Then connect with encryption enabled:
+
+```typescript
+const db = await FastSQL.connect({
+  database: 'secure',
+  encrypted: true,
+  encryptionKey: 'my-secret-key',
+});
+```
+
+If SQLCipher is not installed and `encrypted: true` is passed, the plugin returns a clear error message instead of crashing.
+
+### iOS
+
+SQLCipher is optional on iOS. The plugin builds without it; encryption calls will return `Encryption is not available in this build` unless SQLCipher is installed.
+
+To enable encryption via CocoaPods, update your `ios/App/Podfile` after `capacitor install`/`cap sync` to use the SQLCipher subspec:
+
+```ruby
+pod 'CapgoCapacitorFastSql/SQLCipher', :path => '../../node_modules/@capgo/capacitor-fast-sql'
+```
+
+Then run `pod install` in the `ios/App` directory. If you skip this subspec, keep `encrypted: false`.
+
 ## Web Platform
 
 On the web, this plugin uses the official [@sqlite.org/sqlite-wasm](https://github.com/sqlite/sqlite-wasm) build with [OPFS](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system) for persistence. SQLite reads and writes the database file directly, it is not loaded entirely into RAM or mirrored through IndexedDB.
@@ -213,147 +214,147 @@ const db = await FastSQL.connect({ database: 'myapp' });
 `configureWeb()` is a no-op on iOS and Android, it is safe to call unconditionally.
 
 > **Note:** Existing databases previously stored in IndexedDB by sql.js are not migrated automatically. Re-seed or import data after upgrading if needed.
-
-## Usage
-
-### Basic Example
-
-```typescript
-import { FastSQL } from '@capgo/capacitor-fast-sql';
-
-// Connect to database
-const db = await FastSQL.connect({ database: 'myapp' });
-
-// Create table
-await db.execute(`
-  CREATE TABLE IF NOT EXISTS users (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    name TEXT NOT NULL,
-    email TEXT UNIQUE
-  )
-`);
-
-// Insert data
-const result = await db.run(
-  'INSERT INTO users (name, email) VALUES (?, ?)',
-  ['John Doe', 'john@example.com']
-);
-console.log('Inserted row ID:', result.insertId);
-
-// Query data
-const users = await db.query('SELECT * FROM users WHERE name LIKE ?', ['John%']);
-console.log('Users:', users);
-
-// Close connection
-await FastSQL.disconnect('myapp');
-```
-
-### Transaction Example
-
-```typescript
-const db = await FastSQL.connect({ database: 'myapp' });
-
-try {
-  await db.transaction(async (tx) => {
-    await tx.run('INSERT INTO accounts (name, balance) VALUES (?, ?)', ['Alice', 1000]);
-    await tx.run('INSERT INTO accounts (name, balance) VALUES (?, ?)', ['Bob', 500]);
-    await tx.run('UPDATE accounts SET balance = balance - 100 WHERE name = ?', ['Alice']);
-    await tx.run('UPDATE accounts SET balance = balance + 100 WHERE name = ?', ['Bob']);
-  });
-  console.log('Transaction successful!');
-} catch (error) {
-  console.error('Transaction failed:', error);
-}
-```
-
-### Batch Operations
-
-```typescript
-const db = await FastSQL.connect({ database: 'myapp' });
-
-const results = await db.executeBatch([
-  { statement: 'INSERT INTO logs (message) VALUES (?)', params: ['Log 1'] },
-  { statement: 'INSERT INTO logs (message) VALUES (?)', params: ['Log 2'] },
-  { statement: 'INSERT INTO logs (message) VALUES (?)', params: ['Log 3'] },
-]);
-```
-
-### Key-Value Storage (Mobile-focused)
-
-```typescript
-import { KeyValueStore } from '@capgo/capacitor-fast-sql';
-
-const kv = await KeyValueStore.open({
-  database: 'myapp',
-  encrypted: true,
-  encryptionKey: 'super-secret-key',
-});
-
-await kv.set('session', { token: 'abc123', expiresAt: 1710000000 });
-const session = await kv.get('session');
-await kv.remove('session');
-```
-
-### RAG Vector Stores (Optional)
-
-`FastSQLVectorStore` provides a dependency-free VectorStore-compatible helper inspired by `@react-native-rag/op-sqlite`. It stores embeddings in SQLite as binary Float32 vectors and computes cosine similarity in TypeScript, so it works anywhere this plugin works.
-
-Each store is namespaced by the `store` option, so one database can hold as many independent vector stores as you need:
-
-```typescript
-import { FastSQLVectorStore } from '@capgo/capacitor-fast-sql';
-
-const docs = await FastSQLVectorStore.open({
-  database: 'rag',
-  store: 'docs',
-  embeddings,
-});
-
-const tickets = await FastSQLVectorStore.open({
-  database: 'rag',
-  store: 'tickets',
-  embeddings,
-});
-
-await docs.add({
-  document: 'Capgo ships instant updates for Capacitor apps.',
-  metadata: { source: 'docs' },
-});
-
-const results = await docs.query({
-  queryText: 'How do instant updates work?',
-  nResults: 3,
-});
-
-await docs.close();
-await tickets.close();
-```
-
-You can also use precomputed embeddings without an embeddings provider:
-
-```typescript
-const store = await FastSQLVectorStore.open({
-  database: 'rag',
-  store: 'offline-embeddings',
-  embeddingDimension: 384,
-});
-
-await store.add({
-  id: 'intro',
-  document: 'Local RAG entry',
-  embedding: [0.12, 0.08, 0.31 /* ...384 values */],
-});
-
-const matches = await store.query({
-  queryEmbedding: [0.11, 0.09, 0.29 /* ...384 values */],
-  nResults: 5,
-});
-```
-
-> Note: Web support is intended for minimal testing only. The primary focus is iOS/Android.
-
-## API
-
+
+## Usage
+
+### Basic Example
+
+```typescript
+import { FastSQL } from '@capgo/capacitor-fast-sql';
+
+// Connect to database
+const db = await FastSQL.connect({ database: 'myapp' });
+
+// Create table
+await db.execute(`
+  CREATE TABLE IF NOT EXISTS users (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    email TEXT UNIQUE
+  )
+`);
+
+// Insert data
+const result = await db.run(
+  'INSERT INTO users (name, email) VALUES (?, ?)',
+  ['John Doe', 'john@example.com']
+);
+console.log('Inserted row ID:', result.insertId);
+
+// Query data
+const users = await db.query('SELECT * FROM users WHERE name LIKE ?', ['John%']);
+console.log('Users:', users);
+
+// Close connection
+await FastSQL.disconnect('myapp');
+```
+
+### Transaction Example
+
+```typescript
+const db = await FastSQL.connect({ database: 'myapp' });
+
+try {
+  await db.transaction(async (tx) => {
+    await tx.run('INSERT INTO accounts (name, balance) VALUES (?, ?)', ['Alice', 1000]);
+    await tx.run('INSERT INTO accounts (name, balance) VALUES (?, ?)', ['Bob', 500]);
+    await tx.run('UPDATE accounts SET balance = balance - 100 WHERE name = ?', ['Alice']);
+    await tx.run('UPDATE accounts SET balance = balance + 100 WHERE name = ?', ['Bob']);
+  });
+  console.log('Transaction successful!');
+} catch (error) {
+  console.error('Transaction failed:', error);
+}
+```
+
+### Batch Operations
+
+```typescript
+const db = await FastSQL.connect({ database: 'myapp' });
+
+const results = await db.executeBatch([
+  { statement: 'INSERT INTO logs (message) VALUES (?)', params: ['Log 1'] },
+  { statement: 'INSERT INTO logs (message) VALUES (?)', params: ['Log 2'] },
+  { statement: 'INSERT INTO logs (message) VALUES (?)', params: ['Log 3'] },
+]);
+```
+
+### Key-Value Storage (Mobile-focused)
+
+```typescript
+import { KeyValueStore } from '@capgo/capacitor-fast-sql';
+
+const kv = await KeyValueStore.open({
+  database: 'myapp',
+  encrypted: true,
+  encryptionKey: 'super-secret-key',
+});
+
+await kv.set('session', { token: 'abc123', expiresAt: 1710000000 });
+const session = await kv.get('session');
+await kv.remove('session');
+```
+
+### RAG Vector Stores (Optional)
+
+`FastSQLVectorStore` provides a dependency-free VectorStore-compatible helper inspired by `@react-native-rag/op-sqlite`. It stores embeddings in SQLite as binary Float32 vectors and computes cosine similarity in TypeScript, so it works anywhere this plugin works.
+
+Each store is namespaced by the `store` option, so one database can hold as many independent vector stores as you need:
+
+```typescript
+import { FastSQLVectorStore } from '@capgo/capacitor-fast-sql';
+
+const docs = await FastSQLVectorStore.open({
+  database: 'rag',
+  store: 'docs',
+  embeddings,
+});
+
+const tickets = await FastSQLVectorStore.open({
+  database: 'rag',
+  store: 'tickets',
+  embeddings,
+});
+
+await docs.add({
+  document: 'Capgo ships instant updates for Capacitor apps.',
+  metadata: { source: 'docs' },
+});
+
+const results = await docs.query({
+  queryText: 'How do instant updates work?',
+  nResults: 3,
+});
+
+await docs.close();
+await tickets.close();
+```
+
+You can also use precomputed embeddings without an embeddings provider:
+
+```typescript
+const store = await FastSQLVectorStore.open({
+  database: 'rag',
+  store: 'offline-embeddings',
+  embeddingDimension: 384,
+});
+
+await store.add({
+  id: 'intro',
+  document: 'Local RAG entry',
+  embedding: [0.12, 0.08, 0.31 /* ...384 values */],
+});
+
+const matches = await store.query({
+  queryEmbedding: [0.11, 0.09, 0.29 /* ...384 values */],
+  nResults: 5,
+});
+```
+
+> Note: Web support is intended for minimal testing only. The primary focus is iOS/Android.
+
+## API
+
 <docgen-index>
 
 * [`connect(...)`](#connect)
@@ -369,8 +370,8 @@ const matches = await store.query({
 * [Type Aliases](#type-aliases)
 * [Enums](#enums)
 
-</docgen-index>
-
+</docgen-index>
+
 <docgen-api>
 <!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
 
@@ -698,4 +699,4 @@ Used to override the default SQLite Wasm worker.
 | **`RepeatableRead`**  | <code>'REPEATABLE READ'</code>  |
 | **`Serializable`**    | <code>'SERIALIZABLE'</code>     |
 
-</docgen-api>
+</docgen-api>

package/android/build.gradle

@@ -40,6 +40,9 @@ android {
         sourceCompatibility JavaVersion.VERSION_21
         targetCompatibility JavaVersion.VERSION_21
     }
+    testOptions {
+        unitTests.includeAndroidResources = true
+    }
 }
 
 repositories {
@@ -52,10 +55,10 @@ dependencies {
     implementation project(':capacitor-android')
     implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
     implementation 'androidx.sqlite:sqlite:2.7.1'
-    implementation 'com.google.code.gson:gson:2.14.0'
     implementation 'org.nanohttpd:nanohttpd:2.3.1'
     compileOnly 'net.zetetic:sqlcipher-android:4.19.1'
     testImplementation "junit:junit:$junitVersion"
+    testImplementation 'org.robolectric:robolectric:4.16'
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
 }

package/android/src/main/java/app/capgo/capacitor/fastsql/CapgoCapacitorFastSqlPlugin.java

@@ -19,7 +19,7 @@ import java.util.Map;
 @CapacitorPlugin(name = "CapgoCapacitorFastSql")
 public class CapgoCapacitorFastSqlPlugin extends Plugin {
 
-    private final String pluginVersion = "8.2.11";
+    private final String pluginVersion = "8.2.13";
 
     private Map<String, DatabaseConnection> databases = new HashMap<>();
     private SQLHTTPServer server;

package/android/src/main/java/app/capgo/capacitor/fastsql/HttpRequestJsonParams.java

@@ -0,0 +1,413 @@
+package app.capgo.capacitor.fastsql;
+
+import com.getcapacitor.JSArray;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONTokener;
+
+/**
+ * Converts HTTP request JSON parameter arrays to {@link JSArray} values with the same
+ * semantics as the previous Gson-based parsing in {@link SQLHTTPServer}.
+ */
+final class HttpRequestJsonParams {
+
+    private static final int MAX_NUMBER_STRING_LENGTH = 10_000;
+
+    private HttpRequestJsonParams() {}
+
+    static void populateJsArrayFromParamsJson(JSONArray paramsJson, JSArray params) throws JSONException {
+        populateJsArrayFromParamsJson(paramsJson, params, null);
+    }
+
+    static void populateJsArrayFromParamsJson(JSONArray paramsJson, JSArray params, String rawParamsArrayJson) throws JSONException {
+        List<String> rawElements = rawParamsArrayJson != null ? splitTopLevelJsonArrayElements(rawParamsArrayJson) : null;
+        for (int i = 0; i < paramsJson.length(); i++) {
+            String rawElement = rawElements != null && i < rawElements.size() ? rawElements.get(i) : null;
+            Object converted =
+                rawElement != null ? convertRequestParamFromRawJson(rawElement, paramsJson.get(i)) : convertRequestParam(paramsJson.get(i));
+            if (converted != null) {
+                params.put(converted);
+            }
+        }
+    }
+
+    static String extractJsonArrayAfterKey(String json, String key) throws JSONException {
+        int i = skipWhitespace(json, 0);
+        if (i >= json.length() || json.charAt(i) != '{') {
+            throw new JSONException("Expected JSON object");
+        }
+        i++;
+        String found = null;
+        boolean sawMatchingKey = false;
+        while (i < json.length()) {
+            i = skipWhitespace(json, i);
+            if (json.charAt(i) == '}') {
+                if (found != null) {
+                    return found;
+                }
+                if (sawMatchingKey) {
+                    throw new JSONException("No array for key: " + key);
+                }
+                throw new JSONException("No key: " + key);
+            }
+            int keyEnd = endOfJsonString(json, i);
+            String memberKey = parseQuotedStringToken(json, i, keyEnd);
+            i = skipWhitespace(json, keyEnd);
+            if (json.charAt(i) != ':') {
+                throw new JSONException("Expected ':' after object key");
+            }
+            i = skipWhitespace(json, i + 1);
+            if (memberKey.equals(key)) {
+                sawMatchingKey = true;
+                i = skipWhitespace(json, i);
+                if (i < json.length() && json.charAt(i) == '[') {
+                    int end = indexOfMatchingBracket(json, i, '[', ']');
+                    found = json.substring(i, end + 1);
+                    i = end + 1;
+                } else {
+                    found = null;
+                    i = endOfJsonValue(json, i);
+                }
+            } else {
+                i = endOfJsonValue(json, i);
+            }
+            i = skipWhitespace(json, i);
+            if (i < json.length() && json.charAt(i) == ',') {
+                i++;
+            }
+        }
+        if (found != null) {
+            return found;
+        }
+        if (sawMatchingKey) {
+            throw new JSONException("No array for key: " + key);
+        }
+        throw new JSONException("No key: " + key);
+    }
+
+    /**
+     * Converts one JSON param value for {@link JSArray#put(Object)}.
+     *
+     * @return converted value, or {@code null} to skip unsupported values (e.g. nested arrays)
+     */
+    static Object convertRequestParam(Object param) {
+        if (param == JSONObject.NULL) {
+            return JSONObject.NULL;
+        }
+        if (param instanceof Boolean) {
+            return param;
+        }
+        if (param instanceof Number) {
+            return convertNumberLikeGson((Number) param);
+        }
+        if (param instanceof String) {
+            return param;
+        }
+        if (param instanceof JSONObject) {
+            JSONObject obj = (JSONObject) param;
+            JSONObject jsonObj = new JSONObject();
+            Iterator<String> keys = obj.keys();
+            while (keys.hasNext()) {
+                String key = keys.next();
+                try {
+                    jsonObj.put(key, elementGetAsString(obj.get(key)));
+                } catch (JSONException e) {
+                    throw new IllegalStateException(e);
+                }
+            }
+            return jsonObj;
+        }
+        return null;
+    }
+
+    static Object convertRequestParamFromRawJson(String rawElement, Object parsedFallback) {
+        String raw = rawElement.trim();
+        if (raw.startsWith("{")) {
+            return convertFlatObjectParamFromRawJson(raw);
+        }
+        if (raw.startsWith("[")) {
+            return null;
+        }
+        if (raw.equals("null")) {
+            return JSONObject.NULL;
+        }
+        if (raw.equals("true") || raw.equals("false")) {
+            return Boolean.parseBoolean(raw);
+        }
+        if (raw.startsWith("\"")) {
+            try {
+                return new JSONTokener(raw).nextValue();
+            } catch (JSONException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+        return convertNumberLikeGsonFromLiteral(raw);
+    }
+
+    /** Mirrors Gson {@code JsonElement#getAsString()} for object field values. */
+    static String elementGetAsString(Object value) {
+        if (value == null || value == JSONObject.NULL) {
+            throw new IllegalStateException("Cannot get string from null");
+        }
+        if (value instanceof String) {
+            return (String) value;
+        }
+        if (value instanceof Number) {
+            try {
+                return JSONObject.numberToString((Number) value);
+            } catch (JSONException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+        if (value instanceof Boolean) {
+            return value.toString();
+        }
+        if (value instanceof JSONObject || value instanceof JSONArray) {
+            throw new IllegalStateException("Cannot get string from non-primitive");
+        }
+        return String.valueOf(value);
+    }
+
+    static String elementGetAsStringFromRawToken(String token) {
+        String raw = token.trim();
+        if (raw.equals("null")) {
+            throw new IllegalStateException("Cannot get string from null");
+        }
+        if (raw.startsWith("{") || raw.startsWith("[")) {
+            throw new IllegalStateException("Cannot get string from non-primitive");
+        }
+        if (raw.startsWith("\"")) {
+            try {
+                Object value = new JSONTokener(raw).nextValue();
+                if (value instanceof String) {
+                    return (String) value;
+                }
+            } catch (JSONException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+        if (raw.equals("true") || raw.equals("false")) {
+            return raw;
+        }
+        return raw;
+    }
+
+    /**
+     * Mirrors Gson {@code JsonPrimitive#getAsLong()} with {@code getAsDouble()} fallback on
+     * {@link NumberFormatException}, using LazilyParsedNumber-style parsing on the number's text.
+     */
+    static Number convertNumberLikeGson(Number number) {
+        return convertNumberLikeGsonFromLiteral(numberToJsonNumberString(number));
+    }
+
+    static Number convertNumberLikeGsonFromLiteral(String literal) {
+        try {
+            return gsonStyleLongFromNumberString(literal);
+        } catch (NumberFormatException e) {
+            return gsonStyleDoubleFromNumberString(literal, Double.parseDouble(literal));
+        }
+    }
+
+    static long gsonStyleLongFromNumberString(String s) {
+        checkNumberStringLength(s);
+        try {
+            return Long.parseLong(s);
+        } catch (NumberFormatException e) {
+            return parseBigDecimalLikeGson(s).longValue();
+        }
+    }
+
+    static double gsonStyleDoubleFromNumberString(String s, Number number) {
+        try {
+            return Double.parseDouble(s);
+        } catch (NumberFormatException e) {
+            return number.doubleValue();
+        }
+    }
+
+    static String numberToJsonNumberString(Number number) {
+        if (number instanceof BigDecimal) {
+            return ((BigDecimal) number).toPlainString();
+        }
+        return number.toString();
+    }
+
+    static JSONObject convertFlatObjectParamFromRawJson(String raw) {
+        JSONObject out = new JSONObject();
+        int i = skipWhitespace(raw, 1);
+        while (true) {
+            i = skipWhitespace(raw, i);
+            if (raw.charAt(i) == '}') {
+                break;
+            }
+            int keyEnd = endOfJsonString(raw, i);
+            String key;
+            try {
+                key = (String) new JSONTokener(raw.substring(i, keyEnd)).nextValue();
+            } catch (JSONException e) {
+                throw new IllegalStateException(e);
+            }
+            i = skipWhitespace(raw, keyEnd);
+            if (raw.charAt(i) != ':') {
+                throw new IllegalStateException("Expected ':' after object key");
+            }
+            i = skipWhitespace(raw, i + 1);
+            int valueEnd = endOfJsonValue(raw, i);
+            String valueToken = raw.substring(i, valueEnd);
+            try {
+                out.put(key, elementGetAsStringFromRawToken(valueToken));
+            } catch (JSONException e) {
+                throw new IllegalStateException(e);
+            }
+            i = skipWhitespace(raw, valueEnd);
+            if (i < raw.length() && raw.charAt(i) == ',') {
+                i++;
+            }
+        }
+        return out;
+    }
+
+    static List<String> splitTopLevelJsonArrayElements(String arrayJson) {
+        String trimmed = arrayJson.trim();
+        if (trimmed.length() < 2 || trimmed.charAt(0) != '[') {
+            throw new IllegalStateException("Not a JSON array");
+        }
+        List<String> elements = new ArrayList<>();
+        int i = skipWhitespace(trimmed, 1);
+        while (true) {
+            i = skipWhitespace(trimmed, i);
+            if (trimmed.charAt(i) == ']') {
+                break;
+            }
+            int end = endOfJsonValue(trimmed, i);
+            elements.add(trimmed.substring(i, end));
+            i = skipWhitespace(trimmed, end);
+            if (trimmed.charAt(i) == ',') {
+                i++;
+            }
+        }
+        return elements;
+    }
+
+    static int endOfJsonValue(String s, int start) {
+        start = skipWhitespace(s, start);
+        char c = s.charAt(start);
+        if (c == '"') {
+            return endOfJsonString(s, start);
+        }
+        if (c == '{') {
+            return indexOfMatchingBracket(s, start, '{', '}') + 1;
+        }
+        if (c == '[') {
+            return indexOfMatchingBracket(s, start, '[', ']') + 1;
+        }
+        if (s.startsWith("null", start)) {
+            return start + 4;
+        }
+        if (s.startsWith("true", start)) {
+            return start + 4;
+        }
+        if (s.startsWith("false", start)) {
+            return start + 5;
+        }
+        int i = start;
+        while (i < s.length()) {
+            char ch = s.charAt(i);
+            if (ch == ',' || ch == ']' || ch == '}' || Character.isWhitespace(ch)) {
+                break;
+            }
+            i++;
+        }
+        return i;
+    }
+
+    static int endOfJsonString(String s, int start) {
+        if (s.charAt(start) != '"') {
+            throw new IllegalStateException("Expected string");
+        }
+        boolean escape = false;
+        for (int i = start + 1; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (c == '\\') {
+                escape = true;
+                continue;
+            }
+            if (c == '"') {
+                return i + 1;
+            }
+        }
+        throw new IllegalStateException("Unterminated string");
+    }
+
+    static int indexOfMatchingBracket(String s, int openIdx, char open, char close) {
+        int depth = 0;
+        boolean inString = false;
+        boolean escape = false;
+        for (int i = openIdx; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (inString && c == '\\') {
+                escape = true;
+                continue;
+            }
+            if (c == '"') {
+                inString = !inString;
+                continue;
+            }
+            if (inString) {
+                continue;
+            }
+            if (c == open) {
+                depth++;
+            } else if (c == close) {
+                depth--;
+                if (depth == 0) {
+                    return i;
+                }
+            }
+        }
+        throw new IllegalStateException("Unbalanced brackets");
+    }
+
+    static int skipWhitespace(String s, int index) {
+        while (index < s.length() && Character.isWhitespace(s.charAt(index))) {
+            index++;
+        }
+        return index;
+    }
+
+    static String parseQuotedStringToken(String json, int start, int end) throws JSONException {
+        try {
+            return (String) new JSONTokener(json.substring(start, end)).nextValue();
+        } catch (JSONException e) {
+            throw new JSONException("Invalid object key", e);
+        }
+    }
+
+    private static void checkNumberStringLength(String s) {
+        if (s.length() > MAX_NUMBER_STRING_LENGTH) {
+            throw new NumberFormatException("Number string too large");
+        }
+    }
+
+    private static BigDecimal parseBigDecimalLikeGson(String s) {
+        checkNumberStringLength(s);
+        BigDecimal decimal = new BigDecimal(s);
+        if (Math.abs((long) decimal.scale()) >= 10_000) {
+            throw new NumberFormatException("Number has unsupported scale");
+        }
+        return decimal;
+    }
+}

package/android/src/main/java/app/capgo/capacitor/fastsql/SQLHTTPServer.java

@@ -2,16 +2,12 @@ package app.capgo.capacitor.fastsql;
 
 import com.getcapacitor.JSArray;
 import com.getcapacitor.JSObject;
-import com.google.gson.Gson;
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
 import fi.iki.elonen.NanoHTTPD; // Note: org.nanohttpd:nanohttpd:2.3.1 still uses fi.iki.elonen package
 import java.io.DataInputStream;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.security.SecureRandom;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -29,7 +25,6 @@ public class SQLHTTPServer extends NanoHTTPD {
 
     private final String token;
     private final Map<String, DatabaseConnection> databases;
-    private final Gson gson = new Gson();
     private final ExecutorService requestExecutor = Executors.newSingleThreadExecutor((runnable) -> {
         Thread thread = new Thread(runnable);
         thread.setName("FastSQL-DB");
@@ -120,37 +115,14 @@ public class SQLHTTPServer extends NanoHTTPD {
     private Response handleExecute(IHTTPSession session, DatabaseConnection db) throws Exception {
         // Read request body
         String body = readRequestBody(session);
-        JsonObject request = JsonParser.parseString(body).getAsJsonObject();
+        JSONObject request = new JSONObject(body);
 
-        String statement = request.get("statement").getAsString();
-        JsonArray paramsJson = request.has("params") ? request.getAsJsonArray("params") : new JsonArray();
+        String statement = request.getString("statement");
+        JSONArray paramsJson = request.has("params") ? request.getJSONArray("params") : new JSONArray();
 
-        // Convert to JSArray
         JSArray params = new JSArray();
-        for (JsonElement param : paramsJson) {
-            if (param.isJsonNull()) {
-                params.put(JSONObject.NULL);
-            } else if (param.isJsonPrimitive()) {
-                if (param.getAsJsonPrimitive().isNumber()) {
-                    try {
-                        params.put(param.getAsLong());
-                    } catch (NumberFormatException e) {
-                        params.put(param.getAsDouble());
-                    }
-                } else if (param.getAsJsonPrimitive().isBoolean()) {
-                    params.put(param.getAsBoolean());
-                } else {
-                    params.put(param.getAsString());
-                }
-            } else if (param.isJsonObject()) {
-                JsonObject obj = param.getAsJsonObject();
-                JSONObject jsonObj = new JSONObject();
-                for (String key : obj.keySet()) {
-                    jsonObj.put(key, obj.get(key).getAsString());
-                }
-                params.put(jsonObj);
-            }
-        }
+        String rawParamsArray = request.has("params") ? HttpRequestJsonParams.extractJsonArrayAfterKey(body, "params") : null;
+        HttpRequestJsonParams.populateJsArrayFromParamsJson(paramsJson, params, rawParamsArray);
 
         // Execute query
         JSObject result = db.execute(statement, params);
@@ -163,41 +135,21 @@ public class SQLHTTPServer extends NanoHTTPD {
     private Response handleBatch(IHTTPSession session, DatabaseConnection db) throws Exception {
         // Read request body
         String body = readRequestBody(session);
-        JsonObject request = JsonParser.parseString(body).getAsJsonObject();
-        JsonArray operations = request.getAsJsonArray("operations");
+        JSONObject request = new JSONObject(body);
+        JSONArray operations = request.getJSONArray("operations");
 
         JSONArray results = new JSONArray();
-        for (JsonElement opElement : operations) {
-            JsonObject operation = opElement.getAsJsonObject();
-            String statement = operation.get("statement").getAsString();
-            JsonArray paramsJson = operation.has("params") ? operation.getAsJsonArray("params") : new JsonArray();
+        String rawOperationsArray = HttpRequestJsonParams.extractJsonArrayAfterKey(body, "operations");
+        List<String> rawOperations = HttpRequestJsonParams.splitTopLevelJsonArrayElements(rawOperationsArray);
+        for (int i = 0; i < operations.length(); i++) {
+            JSONObject operation = operations.getJSONObject(i);
+            String statement = operation.getString("statement");
+            JSONArray paramsJson = operation.has("params") ? operation.getJSONArray("params") : new JSONArray();
 
-            // Convert to JSArray
             JSArray params = new JSArray();
-            for (JsonElement param : paramsJson) {
-                if (param.isJsonNull()) {
-                    params.put(JSONObject.NULL);
-                } else if (param.isJsonPrimitive()) {
-                    if (param.getAsJsonPrimitive().isNumber()) {
-                        try {
-                            params.put(param.getAsLong());
-                        } catch (NumberFormatException e) {
-                            params.put(param.getAsDouble());
-                        }
-                    } else if (param.getAsJsonPrimitive().isBoolean()) {
-                        params.put(param.getAsBoolean());
-                    } else {
-                        params.put(param.getAsString());
-                    }
-                } else if (param.isJsonObject()) {
-                    JsonObject obj = param.getAsJsonObject();
-                    JSONObject jsonObj = new JSONObject();
-                    for (String key : obj.keySet()) {
-                        jsonObj.put(key, obj.get(key).getAsString());
-                    }
-                    params.put(jsonObj);
-                }
-            }
+            String rawOperation = rawOperations.get(i);
+            String rawParamsArray = operation.has("params") ? HttpRequestJsonParams.extractJsonArrayAfterKey(rawOperation, "params") : null;
+            HttpRequestJsonParams.populateJsArrayFromParamsJson(paramsJson, params, rawParamsArray);
 
             JSObject result = db.execute(statement, params);
             results.put(new JSONObject(result.toString()));

package/ios/Sources/CapgoCapacitorFastSqlPlugin/CapgoCapacitorFastSqlPlugin.swift

@@ -10,7 +10,7 @@ import SQLite3
  */
 @objc(CapgoCapacitorFastSqlPlugin)
 public class CapgoCapacitorFastSqlPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.2.11"
+    private let pluginVersion: String = "8.2.13"
     public let identifier = "CapgoCapacitorFastSqlPlugin"
     public let jsName = "CapgoCapacitorFastSql"
     public let pluginMethods: [CAPPluginMethod] = [

package/ios/Sources/CapgoCapacitorFastSqlPlugin/SQLDatabase.swift

@@ -50,12 +50,11 @@ class SQLDatabase {
                 throw SQLError.encryptionKeyMissing
             }
             #if canImport(SQLCipher)
-            guard let keyData = key.data(using: .utf8) else {
-                throw SQLError.encryptionFailed(message: "Invalid encryption key encoding")
-            }
-            let keyResult = keyData.withUnsafeBytes { bytes in
-                sqlite3_key(db, bytes.baseAddress, Int32(keyData.count))
-            }
+            // `PRAGMA key` is SQLCipher's SQL interface to sqlite3_key(). It avoids
+            // calling sqlite3_key() directly, which SQLCipher's headers only declare
+            // when SQLITE_HAS_CODEC is defined for the importing target.
+            let escapedKey = key.replacingOccurrences(of: "'", with: "''")
+            let keyResult = sqlite3_exec(db, "PRAGMA key = '\(escapedKey)'", nil, nil, nil)
             if keyResult != SQLITE_OK {
                 let error = String(cString: sqlite3_errmsg(db))
                 throw SQLError.encryptionFailed(message: error)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-fast-sql",
-  "version": "8.2.11",
+  "version": "8.2.13",
   "description": "High-performance native SQLite plugin with custom protocol for efficient sync operations and IndexedDB replacement",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -81,7 +81,7 @@
     "rimraf": "^6.1.0",
     "rollup": "^4.53.2",
     "swiftlint": "^2.0.0",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
     "@capacitor/core": ">=8.0.0"