@capawesome/capacitor-libsql 0.1.0

package/ios/Plugin/Classes/Options/RollbackTransactionOptions.swift

@@ -0,0 +1,19 @@
+import Foundation
+import Capacitor
+
+@objc public class RollbackTransactionOptions: NSObject {
+    let connectionId: String
+    let transactionId: String
+
+    init(_ call: CAPPluginCall) throws {
+        guard let connectionId = call.getString("connectionId") else {
+            throw LibsqlError.connectionIdMissing
+        }
+        guard let transactionId = call.getString("transactionId") else {
+            throw LibsqlError.transactionIdMissing
+        }
+
+        self.connectionId = connectionId
+        self.transactionId = transactionId
+    }
+}

package/ios/Plugin/Classes/Options/SyncOptions.swift

@@ -0,0 +1,14 @@
+import Foundation
+import Capacitor
+
+@objc public class SyncOptions: NSObject {
+    let connectionId: String
+
+    init(_ call: CAPPluginCall) throws {
+        guard let connectionId = call.getString("connectionId") else {
+            throw LibsqlError.connectionIdMissing
+        }
+
+        self.connectionId = connectionId
+    }
+}

package/ios/Plugin/Classes/Results/BeginTransactionResult.swift

@@ -0,0 +1,16 @@
+import Foundation
+import Capacitor
+
+@objc public class BeginTransactionResult: NSObject, Result {
+    let transactionId: String
+
+    init(transactionId: String) {
+        self.transactionId = transactionId
+    }
+
+    @objc public func toJSObject() -> AnyObject {
+        var result = JSObject()
+        result["transactionId"] = transactionId
+        return result as AnyObject
+    }
+}

package/ios/Plugin/Classes/Results/ConnectResult.swift

@@ -0,0 +1,16 @@
+import Foundation
+import Capacitor
+
+@objc public class ConnectResult: NSObject, Result {
+    let connectionId: String
+
+    init(connectionId: String) {
+        self.connectionId = connectionId
+    }
+
+    @objc public func toJSObject() -> AnyObject {
+        var result = JSObject()
+        result["connectionId"] = connectionId
+        return result as AnyObject
+    }
+}

package/ios/Plugin/Classes/Results/QueryResult.swift

@@ -0,0 +1,36 @@
+import Foundation
+import Capacitor
+import Libsql
+
+@objc public class QueryResult: NSObject, Result {
+    let rows: [[Any]]
+
+    init(rows: Rows, columns: [String]) {
+        self.rows = QueryResult.convertRowsToAnyArray(rows, columns)
+    }
+
+    @objc public func toJSObject() -> AnyObject {
+        var result = JSObject()
+        result["rows"] = rows
+        return result as AnyObject
+    }
+
+    private static func convertRowsToAnyArray(_ rows: Rows, _ columns: [String]) -> [[Any]] {
+        var rowsResult: [[Any]] = []
+        while let row = rows.next() {
+            var rowResult: [Any] = []
+            var index = Int32(0)
+            for _ in columns {
+                do {
+                    let value = try row.get(index)
+                    rowResult.append(value)
+                    index += 1
+                } catch {
+                    break // Exit the loop when an error occurs (e.g., no more columns)
+                }
+            }
+            rowsResult.append(rowResult)
+        }
+        return rowsResult
+    }
+}

package/ios/Plugin/Enums/LibsqlError.swift

@@ -0,0 +1,61 @@
+import Foundation
+
+enum LibsqlError: Error {
+    case connectionIdMissing
+    case statementMissing
+    case tableNameNotRecognized
+    case transactionIdMissing
+    case connectionNotFound
+    case databaseNotFound
+    case transactionNotFound
+    case invalidStatement
+    case invalidValues
+
+    var code: String? {
+        switch self {
+        case .connectionIdMissing:
+            return nil
+        case .statementMissing:
+            return nil
+        case .tableNameNotRecognized:
+            return nil
+        case .transactionIdMissing:
+            return nil
+        case .connectionNotFound:
+            return nil
+        case .databaseNotFound:
+            return nil
+        case .transactionNotFound:
+            return nil
+        case .invalidStatement:
+            return nil
+        case .invalidValues:
+            return nil
+        }
+    }
+}
+
+extension LibsqlError: LocalizedError {
+    public var errorDescription: String? {
+        switch self {
+        case .connectionIdMissing:
+            return NSLocalizedString("connectionId must be provided.", comment: "connectionIdMissing")
+        case .statementMissing:
+            return NSLocalizedString("statement must be provided.", comment: "statementMissing")
+        case .tableNameNotRecognized:
+            return NSLocalizedString("Table name not recognized.", comment: "tableNameNotRecognized")
+        case .transactionIdMissing:
+            return NSLocalizedString("transactionId must be provided.", comment: "transactionIdMissing")
+        case .connectionNotFound:
+            return NSLocalizedString("Connection not found.", comment: "connectionNotFound")
+        case .databaseNotFound:
+            return NSLocalizedString("Database not found.", comment: "databaseNotFound")
+        case .transactionNotFound:
+            return NSLocalizedString("Transaction not found.", comment: "transactionNotFound")
+        case .invalidStatement:
+            return NSLocalizedString("All statements must be strings.", comment: "invalidStatement")
+        case .invalidValues:
+            return NSLocalizedString("All values must be arrays.", comment: "invalidValues")
+        }
+    }
+}

package/ios/Plugin/Libsql.swift

@@ -0,0 +1,219 @@
+import Foundation
+import Libsql
+
+@objc public class Libsql: NSObject {
+
+    private var databases: [String: Database] = [:]
+    private var connections: [String: Connection] = [:]
+    private var transactions: [String: String] = [:]
+
+    @objc public func connect(_ options: ConnectOptions, completion: @escaping (_ result: ConnectResult?, _ error: Error?) -> Void) throws {
+        do {
+            let connectionId = UUID().uuidString
+
+            let database: Database
+
+            if let url = options.url, let path = options.getPath(), let authToken = options.authToken {
+                // Embedded replica mode
+                database = try Database(
+                    path: path,
+                    url: url,
+                    authToken: authToken
+                )
+            } else if let url = options.url, let authToken = options.authToken {
+                // Remote-only mode
+                database = try Database(
+                    url: url,
+                    authToken: authToken
+                )
+            } else if let path = options.getPath() {
+                // Local-only mode
+                database = try Database(path)
+            } else {
+                // In-memory database
+                database = try Database(":memory:")
+            }
+
+            let connection = try database.connect()
+
+            self.databases[connectionId] = database
+            self.connections[connectionId] = connection
+
+            let result = ConnectResult(connectionId: connectionId)
+            completion(result, nil)
+        } catch {
+            completion(nil, error)
+        }
+    }
+
+    @objc public func execute(_ options: ExecuteOptions, completion: @escaping (_ error: Error?) -> Void) throws {
+        do {
+            guard let connection = self.connections[options.connectionId] else {
+                completion(LibsqlError.connectionNotFound)
+                return
+            }
+
+            if let values = options.values, !values.isEmpty {
+                try connection.execute(options.statement, values as! [ValueRepresentable])
+            } else {
+                try connection.execute(options.statement)
+            }
+
+            completion(nil)
+        } catch {
+            completion(error)
+        }
+    }
+
+    @objc public func executeBatch(_ options: ExecuteBatchOptions, completion: @escaping (_ error: Error?) -> Void) throws {
+        do {
+            guard let connection = self.connections[options.connectionId] else {
+                completion(LibsqlError.connectionNotFound)
+                return
+            }
+
+            for (index, statement) in options.statement.enumerated() {
+                let values = options.values?[safe: index]
+
+                if let values = values, !values.isEmpty {
+                    try connection.execute(statement, values as! [ValueRepresentable])
+                } else {
+                    try connection.execute(statement)
+                }
+            }
+
+            completion(nil)
+        } catch {
+            completion(error)
+        }
+    }
+
+    @objc public func query(_ options: QueryOptions, completion: @escaping (_ result: QueryResult?, _ error: Error?) -> Void) throws {
+        do {
+            guard let connection = self.connections[options.connectionId] else {
+                completion(nil, LibsqlError.connectionNotFound)
+                return
+            }
+
+            let rows: Rows
+            let tableName = extractTableName(from: options.statement)
+
+            guard let tableName = tableName else {
+                throw LibsqlError.tableNameNotRecognized
+            }
+
+            let columns = try connection.query("PRAGMA table_info(\(tableName))")
+            var columnNames: [String] = []
+
+            while let column = columns.next() {
+                let nameValue = try column.get(1)
+                if case .text(let columnName) = nameValue {
+                    columnNames.append(columnName)
+                }
+            }
+
+            if let values = options.values, !values.isEmpty {
+                rows = try connection.query(options.statement, values as! [ValueRepresentable])
+            } else {
+                rows = try connection.query(options.statement)
+            }
+
+            let result = QueryResult(rows: rows, columns: columnNames)
+            completion(result, nil)
+        } catch {
+            completion(nil, error)
+        }
+    }
+
+    @objc public func beginTransaction(_ options: BeginTransactionOptions, completion: @escaping (_ result: BeginTransactionResult?, _ error: Error?) -> Void) throws {
+        do {
+            guard let connection = self.connections[options.connectionId] else {
+                completion(nil, LibsqlError.connectionNotFound)
+                return
+            }
+
+            _ = try connection.execute("BEGIN TRANSACTION")
+
+            let transactionId = UUID().uuidString
+            self.transactions[transactionId] = options.connectionId
+
+            let result = BeginTransactionResult(transactionId: transactionId)
+            completion(result, nil)
+        } catch {
+            completion(nil, error)
+        }
+    }
+
+    @objc public func commitTransaction(_ options: CommitTransactionOptions, completion: @escaping (_ error: Error?) -> Void) throws {
+        do {
+            guard let connection = self.connections[options.connectionId] else {
+                completion(LibsqlError.connectionNotFound)
+                return
+            }
+
+            guard self.transactions[options.transactionId] != nil else {
+                completion(LibsqlError.transactionNotFound)
+                return
+            }
+
+            _ = try connection.execute("COMMIT")
+            self.transactions.removeValue(forKey: options.transactionId)
+            completion(nil)
+        } catch {
+            completion(error)
+        }
+    }
+
+    @objc public func rollbackTransaction(_ options: RollbackTransactionOptions, completion: @escaping (_ error: Error?) -> Void) throws {
+        do {
+            guard let connection = self.connections[options.connectionId] else {
+                completion(LibsqlError.connectionNotFound)
+                return
+            }
+
+            guard self.transactions[options.transactionId] != nil else {
+                completion(LibsqlError.transactionNotFound)
+                return
+            }
+
+            _ = try connection.execute("ROLLBACK")
+            self.transactions.removeValue(forKey: options.transactionId)
+            completion(nil)
+        } catch {
+            completion(error)
+        }
+    }
+
+    @objc public func sync(_ options: SyncOptions, completion: @escaping (_ error: Error?) -> Void) throws {
+        do {
+            guard let database = self.databases[options.connectionId] else {
+                completion(LibsqlError.databaseNotFound)
+                return
+            }
+
+            try database.sync()
+            completion(nil)
+        } catch {
+            completion(error)
+        }
+    }
+
+    private func extractTableName(from query: String) -> String? {
+        let pattern = #"(?i)SELECT\s+\*\s+FROM\s+([a-zA-Z0-9_]+)"#
+
+        if let regex = try? NSRegularExpression(pattern: pattern) {
+            let range = NSRange(query.startIndex..., in: query)
+            if let match = regex.firstMatch(in: query, range: range),
+               let tableRange = Range(match.range(at: 1), in: query) {
+                return String(query[tableRange])
+            }
+        }
+        return nil
+    }
+}
+
+extension Array {
+    subscript(safe index: Index) -> Element? {
+        return indices.contains(index) ? self[index] : nil
+    }
+}

package/ios/Plugin/LibsqlPlugin.swift

@@ -0,0 +1,166 @@
+import Foundation
+import Capacitor
+
+@objc(LibsqlPlugin)
+public class LibsqlPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "LibsqlPlugin"
+    public let jsName = "Libsql"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "connect", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "execute", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "executeBatch", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "query", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "beginTransaction", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "commitTransaction", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "rollbackTransaction", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "sync", returnType: CAPPluginReturnPromise)
+    ]
+
+    public static let tag = "Libsql"
+    private let implementation = Libsql()
+
+    @objc func connect(_ call: CAPPluginCall) {
+        do {
+            let options = try ConnectOptions(call)
+
+            try implementation.connect(options, completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            self.rejectCall(call, error)
+        }
+    }
+
+    @objc func execute(_ call: CAPPluginCall) {
+        do {
+            let options = try ExecuteOptions(call)
+
+            try implementation.execute(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            self.rejectCall(call, error)
+        }
+    }
+
+    @objc func executeBatch(_ call: CAPPluginCall) {
+        do {
+            let options = try ExecuteBatchOptions(call)
+
+            try implementation.executeBatch(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            self.rejectCall(call, error)
+        }
+    }
+
+    @objc func query(_ call: CAPPluginCall) {
+        do {
+            let options = try QueryOptions(call)
+
+            try implementation.query(options, completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            self.rejectCall(call, error)
+        }
+    }
+
+    @objc func beginTransaction(_ call: CAPPluginCall) {
+        do {
+            let options = try BeginTransactionOptions(call)
+
+            try implementation.beginTransaction(options, completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            self.rejectCall(call, error)
+        }
+    }
+
+    @objc func commitTransaction(_ call: CAPPluginCall) {
+        do {
+            let options = try CommitTransactionOptions(call)
+
+            try implementation.commitTransaction(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            self.rejectCall(call, error)
+        }
+    }
+
+    @objc func rollbackTransaction(_ call: CAPPluginCall) {
+        do {
+            let options = try RollbackTransactionOptions(call)
+
+            try implementation.rollbackTransaction(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            self.rejectCall(call, error)
+        }
+    }
+
+    @objc func sync(_ call: CAPPluginCall) {
+        do {
+            let options = try SyncOptions(call)
+
+            try implementation.sync(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            self.rejectCall(call, error)
+        }
+    }
+
+    private func rejectCall(_ call: CAPPluginCall, _ error: Error) {
+        CAPLog.print("[", LibsqlPlugin.tag, "] ", error)
+        call.reject(error.localizedDescription)
+    }
+
+    private func resolveCall(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    private func resolveCall(_ call: CAPPluginCall, _ result: Result?) {
+        if let result = result?.toJSObject() as? JSObject {
+            call.resolve(result)
+        } else {
+            call.resolve()
+        }
+    }
+}

package/ios/Plugin/Protocols/Result.swift

@@ -0,0 +1,6 @@
+import Foundation
+import Capacitor
+
+@objc public protocol Result {
+    @objc func toJSObject() -> AnyObject
+}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@capawesome/capacitor-libsql",
+  "version": "0.1.0",
+  "description": "Capacitor plugin for libSQL databases.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Plugin/",
+    "Package.swift"
+  ],
+  "author": "Robin Genz <mail@robingenz.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/capawesome-team/capacitor-plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/capawesome-team/capacitor-plugins/issues"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/capawesome-team/"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/capawesome"
+    }
+  ],
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme CapawesomeCapacitorLibsql -destination generic/platform=iOS",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\"",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api LibsqlPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "ios:spm:install": "cd ios && swift package resolve && cd ..",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "7.0.0",
+    "@capacitor/cli": "7.0.0",
+    "@capacitor/core": "7.0.0",
+    "@capacitor/docgen": "0.3.0",
+    "@capacitor/ios": "7.0.0",
+    "@ionic/eslint-config": "0.4.0",
+    "@ionic/swiftlint-config": "2.0.0",
+    "eslint": "8.57.0",
+    "prettier": "3.4.2",
+    "prettier-plugin-java": "2.6.7",
+    "rimraf": "6.0.1",
+    "rollup": "4.30.1",
+    "swiftlint": "2.0.0",
+    "typescript": "4.1.5"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=7.0.0"
+  },
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}