@capgo/capacitor-fast-sql 7.0.1

package/CapgoCapacitorFastSql.podspec

@@ -0,0 +1,18 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapgoCapacitorFastSql'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '14.0'
+  s.dependency 'Capacitor'
+  s.dependency 'Telegraph', '~> 0.30'
+  s.swift_version = '5.1'
+end

package/Package.swift

@@ -0,0 +1,30 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapgoCapacitorFastSql",
+    platforms: [.iOS(.v14)],
+    products: [
+        .library(
+            name: "CapgoCapacitorFastSql",
+            targets: ["CapgoCapacitorFastSqlPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0"),
+        .package(url: "https://github.com/Building42/Telegraph.git", from: "0.30.0")
+    ],
+    targets: [
+        .target(
+            name: "CapgoCapacitorFastSqlPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm"),
+                .product(name: "Telegraph", package: "Telegraph")
+            ],
+            path: "ios/Sources/CapgoCapacitorFastSqlPlugin"),
+        .testTarget(
+            name: "CapgoCapacitorFastSqlPluginTests",
+            dependencies: ["CapgoCapacitorFastSqlPlugin"],
+            path: "ios/Tests/CapgoCapacitorFastSqlPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,340 @@
+# @capgo/capacitor-fast-sql
+  <a href="https://capgo.app/"><img src='https://raw.githubusercontent.com/Cap-go/capgo/main/assets/capgo_banner.png' alt='Capgo - Instant updates for capacitor'/></a>
+
+<div align="center">
+  <h2><a href="https://capgo.app/?ref=plugin"> ➡️ Get Instant updates for your App with Capgo</a></h2>
+  <h2><a href="https://capgo.app/consulting/?ref=plugin"> Missing a feature? We'll build the plugin for you 💪</a></h2>
+</div>
+
+High-performance native SQLite plugin with HTTP server for efficient sync operations and IndexedDB replacement.
+
+## Documentation
+
+The most complete doc is available here: https://capgo.app/docs/plugins/fast-sql/
+
+## Install
+
+```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 sql.js + IndexedDB for persistence)
+
+## iOS Configuration
+
+Add to your `Info.plist` if you encounter any issues:
+
+```xml
+<key>NSAppTransportSecurity</key>
+<dict>
+    <key>NSAllowsLocalNetworking</key>
+    <true/>
+</dict>
+```
+
+## Android Configuration
+
+Add to your `AndroidManifest.xml` if needed:
+
+```xml
+<application
+    android:usesCleartextTraffic="true">
+    ...
+</application>
+```
+
+## Usage
+
+### Basic Example
+
+```typescript
+import { NativeSQL } from '@capgo/capacitor-fast-sql';
+
+// Connect to database
+const db = await NativeSQL.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 NativeSQL.disconnect('myapp');
+```
+
+### Transaction Example
+
+```typescript
+const db = await NativeSQL.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 NativeSQL.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'] },
+]);
+```
+
+## API
+
+<docgen-index>
+
+* [`connect(...)`](#connect)
+* [`disconnect(...)`](#disconnect)
+* [`getServerInfo(...)`](#getserverinfo)
+* [`execute(...)`](#execute)
+* [`beginTransaction(...)`](#begintransaction)
+* [`commitTransaction(...)`](#committransaction)
+* [`rollbackTransaction(...)`](#rollbacktransaction)
+* [`getPluginVersion()`](#getpluginversion)
+* [Interfaces](#interfaces)
+* [Enums](#enums)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+Native SQL Plugin for high-performance SQLite database access.
+
+This plugin uses a custom HTTP-based protocol for efficient data transfer,
+bypassing Capacitor's standard bridge for better performance with sync operations.
+
+### connect(...)
+
+```typescript
+connect(options: SQLConnectionOptions) => Promise<{ port: number; token: string; database: string; }>
+```
+
+Initialize the database connection and start the HTTP server.
+
+| Param         | Type                                                                  | Description         |
+| ------------- | --------------------------------------------------------------------- | ------------------- |
+| **`options`** | <code><a href="#sqlconnectionoptions">SQLConnectionOptions</a></code> | - Connection options |
+
+**Returns:** <code>Promise&lt;{ port: number; token: string; database: string; }&gt;</code>
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### disconnect(...)
+
+```typescript
+disconnect(options: { database: string; }) => Promise<void>
+```
+
+Close database connection and stop the HTTP server.
+
+| Param         | Type                               | Description           |
+| ------------- | ---------------------------------- | --------------------- |
+| **`options`** | <code>{ database: string; }</code> | - Database name to close |
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### getServerInfo(...)
+
+```typescript
+getServerInfo(options: { database: string; }) => Promise<{ port: number; token: string; }>
+```
+
+Get the HTTP server port and token for direct communication.
+
+| Param         | Type                               | Description     |
+| ------------- | ---------------------------------- | --------------- |
+| **`options`** | <code>{ database: string; }</code> | - Database name |
+
+**Returns:** <code>Promise&lt;{ port: number; token: string; }&gt;</code>
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### execute(...)
+
+```typescript
+execute(options: { database: string; statement: string; params?: SQLValue[]; }) => Promise<SQLResult>
+```
+
+Execute a SQL query via Capacitor bridge (for simple queries).
+For better performance with large datasets, use the HTTP protocol directly via SQLConnection class.
+
+| Param         | Type                                                                                         | Description        |
+| ------------- | -------------------------------------------------------------------------------------------- | ------------------ |
+| **`options`** | <code>{ database: string; statement: string; params?: <a href="#sqlvalue">SQLValue</a>[]; }</code> | - Query parameters |
+
+**Returns:** <code>Promise&lt;<a href="#sqlresult">SQLResult</a>&gt;</code>
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### beginTransaction(...)
+
+```typescript
+beginTransaction(options: { database: string; isolationLevel?: IsolationLevel; }) => Promise<void>
+```
+
+Begin a database transaction.
+
+| Param         | Type                                                                                                   | Description             |
+| ------------- | ------------------------------------------------------------------------------------------------------ | ----------------------- |
+| **`options`** | <code>{ database: string; isolationLevel?: <a href="#isolationlevel">IsolationLevel</a>; }</code> | - Transaction options |
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### commitTransaction(...)
+
+```typescript
+commitTransaction(options: { database: string; }) => Promise<void>
+```
+
+Commit the current transaction.
+
+| Param         | Type                               | Description     |
+| ------------- | ---------------------------------- | --------------- |
+| **`options`** | <code>{ database: string; }</code> | - Database name |
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### rollbackTransaction(...)
+
+```typescript
+rollbackTransaction(options: { database: string; }) => Promise<void>
+```
+
+Rollback the current transaction.
+
+| Param         | Type                               | Description     |
+| ------------- | ---------------------------------- | --------------- |
+| **`options`** | <code>{ database: string; }</code> | - Database name |
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### getPluginVersion()
+
+```typescript
+getPluginVersion() => Promise<{ version: string; }>
+```
+
+Get the native Capacitor plugin version.
+
+**Returns:** <code>Promise&lt;{ version: string; }&gt;</code>
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### Interfaces
+
+
+#### SQLConnectionOptions
+
+Database connection options
+
+| Prop                | Type                 | Description                                         |
+| ------------------- | -------------------- | --------------------------------------------------- |
+| **`database`**      | <code>string</code>  | Database name (file will be created in app data directory) |
+| **`encrypted`**     | <code>boolean</code> | Enable encryption (iOS/Android only)                |
+| **`encryptionKey`** | <code>string</code>  | Encryption key (required if encrypted is true)      |
+| **`readOnly`**      | <code>boolean</code> | Read-only mode                                      |
+
+
+#### SQLResult
+
+Result of a SQL query execution
+
+| Prop                | Type                                          | Description                                                      |
+| ------------------- | --------------------------------------------- | ---------------------------------------------------------------- |
+| **`rows`**          | <code><a href="#sqlrow">SQLRow</a>[]</code>  | Rows returned by the query (for SELECT statements)               |
+| **`rowsAffected`**  | <code>number</code>                           | Number of rows affected by the query (for INSERT/UPDATE/DELETE) |
+| **`insertId`**      | <code>number</code>                           | ID of the last inserted row (for INSERT statements with auto-increment) |
+
+
+#### SQLRow
+
+SQL row result - values indexed by column name
+
+
+### Enums
+
+
+#### IsolationLevel
+
+Transaction isolation levels
+
+| Members                | Value                          |
+| ---------------------- | ------------------------------ |
+| **`ReadUncommitted`**  | <code>'READ UNCOMMITTED'</code> |
+| **`ReadCommitted`**    | <code>'READ COMMITTED'</code>   |
+| **`RepeatableRead`**   | <code>'REPEATABLE READ'</code>  |
+| **`Serializable`**     | <code>'SERIALIZABLE'</code>     |
+
+
+### Type Aliases
+
+
+#### SQLValue
+
+<code>string | number | boolean | null | Uint8Array</code>
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,60 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
+}
+
+buildscript {
+    repositories {
+        mavenCentral()
+        google()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.7.2'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace 'app.capgo.capacitor.fastsql'
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    jcenter()
+    mavenCentral()
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation 'com.google.code.gson:gson:2.10.1'
+    implementation 'org.nanohttpd:nanohttpd:2.3.1'
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.INTERNET" />
+</manifest>

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

@@ -0,0 +1,220 @@
+package app.capgo.capacitor.fastsql;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Native SQL Plugin for Android
+ *
+ * This plugin uses a custom HTTP server for efficient data transfer,
+ * bypassing Capacitor's standard bridge for better performance.
+ */
+@CapacitorPlugin(name = "CapgoCapacitorFastSql")
+public class CapgoCapacitorFastSqlPlugin extends Plugin {
+
+    private Map<String, SQLDatabase> databases = new HashMap<>();
+    private SQLHTTPServer server;
+
+    @PluginMethod
+    public void connect(PluginCall call) {
+        String database = call.getString("database");
+        if (database == null) {
+            call.reject("Database name is required");
+            return;
+        }
+
+        // Check if already connected
+        if (databases.containsKey(database)) {
+            if (server != null) {
+                JSObject ret = new JSObject();
+                ret.put("port", server.getPort());
+                ret.put("token", server.getToken());
+                ret.put("database", database);
+                call.resolve(ret);
+                return;
+            }
+        }
+
+        try {
+            // Get database path
+            File dbFile = getDatabasePath(database);
+
+            // Open database
+            SQLDatabase db = new SQLDatabase(dbFile.getAbsolutePath());
+            databases.put(database, db);
+
+            // Start HTTP server if not already running
+            if (server == null) {
+                server = new SQLHTTPServer(databases);
+                server.start();
+            }
+
+            JSObject ret = new JSObject();
+            ret.put("port", server.getPort());
+            ret.put("token", server.getToken());
+            ret.put("database", database);
+            call.resolve(ret);
+        } catch (Exception e) {
+            call.reject("Failed to connect to database: " + e.getMessage(), e);
+        }
+    }
+
+    @PluginMethod
+    public void disconnect(PluginCall call) {
+        String database = call.getString("database");
+        if (database == null) {
+            call.reject("Database name is required");
+            return;
+        }
+
+        SQLDatabase db = databases.get(database);
+        if (db == null) {
+            call.reject("Database '" + database + "' is not connected");
+            return;
+        }
+
+        db.close();
+        databases.remove(database);
+
+        // Stop server if no more databases
+        if (databases.isEmpty() && server != null) {
+            server.stop();
+            server = null;
+        }
+
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void getServerInfo(PluginCall call) {
+        String database = call.getString("database");
+        if (database == null) {
+            call.reject("Database name is required");
+            return;
+        }
+
+        if (!databases.containsKey(database)) {
+            call.reject("Database '" + database + "' is not connected");
+            return;
+        }
+
+        if (server == null) {
+            call.reject("Server is not running");
+            return;
+        }
+
+        JSObject ret = new JSObject();
+        ret.put("port", server.getPort());
+        ret.put("token", server.getToken());
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void execute(PluginCall call) {
+        String database = call.getString("database");
+        if (database == null) {
+            call.reject("Database name is required");
+            return;
+        }
+
+        String statement = call.getString("statement");
+        if (statement == null) {
+            call.reject("Statement is required");
+            return;
+        }
+
+        SQLDatabase db = databases.get(database);
+        if (db == null) {
+            call.reject("Database '" + database + "' is not connected");
+            return;
+        }
+
+        JSArray params = call.getArray("params", new JSArray());
+
+        try {
+            JSObject result = db.execute(statement, params);
+            call.resolve(result);
+        } catch (Exception e) {
+            call.reject("Failed to execute statement: " + e.getMessage(), e);
+        }
+    }
+
+    @PluginMethod
+    public void beginTransaction(PluginCall call) {
+        String database = call.getString("database");
+        if (database == null) {
+            call.reject("Database name is required");
+            return;
+        }
+
+        SQLDatabase db = databases.get(database);
+        if (db == null) {
+            call.reject("Database '" + database + "' is not connected");
+            return;
+        }
+
+        try {
+            db.beginTransaction();
+            call.resolve();
+        } catch (Exception e) {
+            call.reject("Failed to begin transaction: " + e.getMessage(), e);
+        }
+    }
+
+    @PluginMethod
+    public void commitTransaction(PluginCall call) {
+        String database = call.getString("database");
+        if (database == null) {
+            call.reject("Database name is required");
+            return;
+        }
+
+        SQLDatabase db = databases.get(database);
+        if (db == null) {
+            call.reject("Database '" + database + "' is not connected");
+            return;
+        }
+
+        try {
+            db.commitTransaction();
+            call.resolve();
+        } catch (Exception e) {
+            call.reject("Failed to commit transaction: " + e.getMessage(), e);
+        }
+    }
+
+    @PluginMethod
+    public void rollbackTransaction(PluginCall call) {
+        String database = call.getString("database");
+        if (database == null) {
+            call.reject("Database name is required");
+            return;
+        }
+
+        SQLDatabase db = databases.get(database);
+        if (db == null) {
+            call.reject("Database '" + database + "' is not connected");
+            return;
+        }
+
+        try {
+            db.rollbackTransaction();
+            call.resolve();
+        } catch (Exception e) {
+            call.reject("Failed to rollback transaction: " + e.getMessage(), e);
+        }
+    }
+
+    private File getDatabasePath(String database) {
+        File dataDir = getContext().getFilesDir();
+        return new File(dataDir, database + ".db");
+    }
+}