@capacitor-community/sqlite 3.2.5-2 → 3.3.3-1

package/ios/Plugin/CapacitorSQLite.swift

@@ -57,6 +57,67 @@ enum CapacitorSQLiteError: Error {
         }
 
     }
+    // MARK: - getNCDatabasePath
+
+    @objc public func getNCDatabasePath(_ folderPath: String, dbName: String ) throws -> String {
+        do {
+            let databasePath: String = try UtilsNCDatabase
+                .getNCDatabasePath(folderPath: folderPath,
+                                   database: dbName )
+            return databasePath
+        } catch let error {
+            throw CapacitorSQLiteError.failed(message: "\(error)")
+        }
+
+    }
+
+    // MARK: - CreateNCConnection
+
+    @objc public func createNCConnection(_ databasePath: String,
+                                         version: Int) throws {
+
+        // check if the connection already exists
+        let conn = dbDict[databasePath]
+        if conn != nil {
+            let msg = "Connection \(databasePath) already exists"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+
+        do {
+            let isFileExists: Bool = UtilsFile
+                .isFileExist(filePath: databasePath)
+
+            if !isFileExists {
+                throw CapacitorSQLiteError.failed(message: "database \(databasePath) does not exist")
+            }
+            let mDb: Database = try Database(
+                databaseName: databasePath,
+                encrypted: false, mode: "no-encryption", version: version,
+                vUpgDict: [:])
+            dbDict[databasePath] = mDb
+            return
+        } catch let error {
+            throw CapacitorSQLiteError.failed(message: "\(error)")
+        }
+    }
+
+    // MARK: - CloseNCConnection
+
+    @objc public func closeNCConnection(_ dbName: String) throws {
+        guard let mDb: Database = dbDict[dbName] else {
+            let msg = "Connection to \(dbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if mDb.isDBOpen() {
+            do {
+                try mDb.close()
+            } catch DatabaseError.close(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            }
+        }
+        dbDict.removeValue(forKey: dbName)
+        return
+    }
 
     // MARK: - CreateConnection
 
@@ -133,6 +194,7 @@ enum CapacitorSQLiteError: Error {
             throw CapacitorSQLiteError.failed(message: message)
         }
     }
+
     // MARK: - Close Connection
 
     @objc public func closeConnection(_ dbName: String) throws {
@@ -193,6 +255,7 @@ enum CapacitorSQLiteError: Error {
             throw CapacitorSQLiteError.failed(message: "\(error)")
         }
     }
+
     // MARK: - IsDatabase
 
     @objc public func isDatabase(_ dbName: String) throws -> NSNumber {
@@ -206,6 +269,18 @@ enum CapacitorSQLiteError: Error {
         }
     }
 
+    // MARK: - IsNCDatabase
+
+    @objc public func isNCDatabase(_ databasePath: String) throws -> NSNumber {
+        let isFileExists: Bool = UtilsFile
+            .isFileExist(filePath: databasePath)
+        if isFileExists {
+            return 1
+        } else {
+            return 0
+        }
+    }
+
     // MARK: - IsTableExists
 
     @objc public func isTableExists(_ dbName: String, tableName: String) throws -> NSNumber {
@@ -244,7 +319,7 @@ enum CapacitorSQLiteError: Error {
             let msg = "Connection to \(mDbName) not available"
             throw CapacitorSQLiteError.failed(message: msg)
         }
-        if mDb.isDBOpen() {
+        if !mDb.isNCDB() && mDb.isDBOpen() {
             do {
                 var stmts = statements
                 // remove carriage returns
@@ -268,7 +343,7 @@ enum CapacitorSQLiteError: Error {
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            let msg = "Database \(mDbName) not opened"
+            let msg = "Database \(mDbName) not opened or in read-only"
             throw CapacitorSQLiteError.failed(message: msg)
         }
     }
@@ -283,7 +358,7 @@ enum CapacitorSQLiteError: Error {
             let msg = "Connection to \(mDbName) not available"
             throw CapacitorSQLiteError.failed(message: msg)
         }
-        if mDb.isDBOpen() {
+        if !mDb.isNCDB() && mDb.isDBOpen() {
             do {
                 let res = try mDb.execSet(set: set, transaction: transaction)
                 return res
@@ -294,7 +369,7 @@ enum CapacitorSQLiteError: Error {
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            let msg = "Database \(mDbName) not opened"
+            let msg = "Database \(mDbName) not opened or in read-only"
             throw CapacitorSQLiteError.failed(message: msg)
         }
     }
@@ -310,7 +385,7 @@ enum CapacitorSQLiteError: Error {
             let msg = "Connection to \(mDbName) not available"
             throw CapacitorSQLiteError.failed(message: msg)
         }
-        if mDb.isDBOpen() {
+        if !mDb.isNCDB() && mDb.isDBOpen() {
             do {
                 var val: [Any] = []
                 if values.count > 0 {
@@ -343,7 +418,7 @@ enum CapacitorSQLiteError: Error {
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            let msg = "Database \(mDbName) not opened"
+            let msg = "Database \(mDbName) not opened or in read-only"
             throw CapacitorSQLiteError.failed(message: msg)
         }
     }
@@ -799,8 +874,10 @@ enum CapacitorSQLiteError: Error {
     }
     class func getDatabaseName(dbName: String) -> String {
         var retName: String = dbName
-        if retName.suffix(3) == ".db" {
-            retName = String(retName.dropLast(3))
+        if !retName.contains("/") {
+            if retName.suffix(3) == ".db" {
+                retName = String(retName.dropLast(3))
+            }
         }
         return retName
     }

package/ios/Plugin/CapacitorSQLitePlugin.m

@@ -7,6 +7,9 @@ CAP_PLUGIN(CapacitorSQLitePlugin, "CapacitorSQLite",
            CAP_PLUGIN_METHOD(echo, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(createConnection, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(closeConnection, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(createNCConnection, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(closeNCConnection, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(getNCDatabasePath, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(open, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(close, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(getVersion, CAPPluginReturnPromise);
@@ -26,6 +29,7 @@ CAP_PLUGIN(CapacitorSQLitePlugin, "CapacitorSQLite",
            CAP_PLUGIN_METHOD(addUpgradeStatement, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(copyFromAssets, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(isDatabase, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(isNCDatabase, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(isTableExists, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(getDatabaseList, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(getMigratableDbList, CAPPluginReturnPromise);

package/ios/Plugin/CapacitorSQLitePlugin.swift

@@ -966,6 +966,117 @@ public class CapacitorSQLitePlugin: CAPPlugin {
         }
     }
 
+    // MARK: - getNCDatabasePath
+
+    @objc func getNCDatabasePath(_ call: CAPPluginCall) {
+        guard let folderPath = call.options["path"] as? String else {
+            retHandler.rPath(call: call, ret: "",
+                             message: "getNCDatabasePath: Must provide a folder path")
+            return
+        }
+        guard let dbName = call.options["database"] as? String else {
+            retHandler.rPath(call: call, ret: "",
+                             message: "getNCDatabasePath: Must provide a database name")
+            return
+        }
+        do {
+
+            let path: String = try implementation.getNCDatabasePath(folderPath,
+                                                                    dbName: dbName)
+            retHandler.rPath(call: call, ret: path)
+            return
+        } catch CapacitorSQLiteError.failed(let message) {
+            let msg = "getNCDatabasePath: \(message)"
+            retHandler.rPath(call: call, ret: "", message: msg)
+            return
+        } catch let error {
+            retHandler.rPath(call: call, ret: "",
+                             message: "getNCDatabasePath: \(error)")
+            return
+        }
+    }
+
+    // MARK: - CreateNCConnection
+
+    @objc func createNCConnection(_ call: CAPPluginCall) {
+        guard let dbPath = call.options["databasePath"] as? String else {
+            retHandler.rResult(
+                call: call,
+                message: "CreateNCConnection: Must provide a database path")
+            return
+        }
+        let version: Int = call.getInt("version") ?? 1
+        do {
+            try implementation.createNCConnection(dbPath,
+                                                  version: version)
+            retHandler.rResult(call: call)
+            return
+        } catch CapacitorSQLiteError.failed(let message) {
+            let msg = "CreateNCConnection: \(message)"
+            retHandler.rResult(call: call, message: msg)
+            return
+        } catch let error {
+            retHandler.rResult(
+                call: call,
+                message: "CreateNCConnection: \(error)")
+            return
+        }
+    }
+
+    // MARK: - CloseNCConnection
+
+    @objc func closeNCConnection(_ call: CAPPluginCall) {
+        guard let dbPath = call.options["databasePath"] as? String else {
+            retHandler.rResult(
+                call: call,
+                message: "CloseNCConnection: Must provide a database path")
+            return
+        }
+        do {
+            try implementation.closeNCConnection(dbPath)
+            retHandler.rResult(call: call)
+            return
+        } catch CapacitorSQLiteError.failed(let message) {
+            let msg = "CloseNCConnection: \(message)"
+            retHandler.rResult(call: call, message: msg)
+            return
+        } catch let error {
+            retHandler.rResult(
+                call: call,
+                message: "CloseNCConnection: \(error)")
+            return
+        }
+    }
+
+    // MARK: - IsNCDatabase
+
+    @objc func isNCDatabase(_ call: CAPPluginCall) {
+        guard let dbPath = call.options["databasePath"] as? String else {
+            retHandler.rResult(
+                call: call, ret: false,
+                message: "isNCDatabase: Must provide a database path")
+            return
+        }
+        do {
+            let res = try implementation.isNCDatabase(dbPath)
+            var bRes: Bool = false
+            if res == 1 {
+                bRes = true
+            }
+            retHandler.rResult(call: call, ret: bRes)
+        } catch CapacitorSQLiteError.failed(let message) {
+            let msg = "isNCDatabase: \(message)"
+            retHandler.rResult(call: call, message: msg)
+            return
+        } catch let error {
+            retHandler.rResult(
+                call: call,
+                message: "isNCDatabase: \(error)")
+            return
+        }
+
+    }
+
     // MARK: - Add Observers
 
     @objc func addObserversToNotificationCenter() {

package/ios/Plugin/Database.swift

@@ -37,6 +37,8 @@ class Database {
     var mDb: OpaquePointer?
     let globalData: GlobalSQLite = GlobalSQLite()
     let uUpg: UtilsUpgrade = UtilsUpgrade()
+    var readOnly: Bool = false
+    var ncDB: Bool = false
 
     // MARK: - Init
     init(databaseName: String, encrypted: Bool,
@@ -48,12 +50,19 @@ class Database {
         self.dbName = databaseName
         self.mode = mode
         self.vUpgDict = vUpgDict
-        do {
-            self.path = try UtilsFile.getFilePath(
-                fileName: databaseName)
-        } catch UtilsFileError.getFilePathFailed {
-            throw DatabaseError.filePath(
-                message: "Could not generate the file path")
+        if databaseName.contains("/")  &&
+            databaseName.suffix(9) != "SQLite.db" {
+            self.readOnly = true
+            self.path = databaseName
+            self.ncDB = true
+        } else {
+            do {
+                self.path = try UtilsFile.getFilePath(
+                    fileName: databaseName)
+            } catch UtilsFileError.getFilePathFailed {
+                throw DatabaseError.filePath(
+                    message: "Could not generate the file path")
+            }
         }
         print("database path \(self.path)")
     }
@@ -64,6 +73,12 @@ class Database {
         return isOpen
     }
 
+    // MARK: - isNCDB
+
+    func isNCDB () -> Bool {
+        return ncDB
+    }
+
     // MARK: - Open
 
     // swiftlint:disable cyclomatic_complexity
@@ -92,27 +107,29 @@ class Database {
             mDb = try UtilsSQLCipher
                 .openOrCreateDatabase(filename: path,
                                       password: password,
-                                      readonly: false)
+                                      readonly: self.readOnly)
             isOpen = true
             // PRAGMA foreign_keys = ON;
             try UtilsSQLCipher
                 .setForeignKeyConstraintsEnabled(mDB: self,
                                                  toggle: true)
-            var curVersion: Int = try UtilsSQLCipher
-                .getVersion(mDB: self)
-            if curVersion == 0 {
-                try UtilsSQLCipher.setVersion(mDB: self, version: 1)
-                curVersion = try UtilsSQLCipher.getVersion(mDB: self)
-            }
-            if dbVersion > curVersion {
-                if vUpgDict.count > 0 {
-                    _ = try uUpg.onUpgrade(mDB: self, upgDict: vUpgDict,
-                                           dbName: dbName,
-                                           currentVersion: curVersion,
-                                           targetVersion: dbVersion)
-                    try UtilsSQLCipher.deleteBackupDB(databaseName: dbName)
-                } else {
-                    try UtilsSQLCipher.setVersion(mDB: self, version: dbVersion)
+            if !ncDB {
+                var curVersion: Int = try UtilsSQLCipher
+                    .getVersion(mDB: self)
+                if curVersion == 0 {
+                    try UtilsSQLCipher.setVersion(mDB: self, version: 1)
+                    curVersion = try UtilsSQLCipher.getVersion(mDB: self)
+                }
+                if dbVersion > curVersion {
+                    if vUpgDict.count > 0 {
+                        _ = try uUpg.onUpgrade(mDB: self, upgDict: vUpgDict,
+                                               dbName: dbName,
+                                               currentVersion: curVersion,
+                                               targetVersion: dbVersion)
+                        try UtilsSQLCipher.deleteBackupDB(databaseName: dbName)
+                    } else {
+                        try UtilsSQLCipher.setVersion(mDB: self, version: dbVersion)
+                    }
                 }
             }
         } catch UtilsSQLCipherError.openOrCreateDatabase(let message) {

package/ios/Plugin/ImportExportJson/ImportFromJson.swift

@@ -245,7 +245,8 @@ class ImportFromJson {
         var statements: [String] = []
         for jpos in 0..<mIndexes.count {
             var mUnique: String = ""
-            if let mMode = mIndexes[jpos].mode {
+            if var mMode = mIndexes[jpos].mode {
+                mMode = mMode.uppercased()
                 if mMode == "UNIQUE" {
                     mUnique = mMode + " "
                 }

package/ios/Plugin/ImportExportJson/JsonSQLite.swift

@@ -108,7 +108,7 @@ public struct JsonIndex: Codable {
         print("value: \(value) ")
         if let mMode = mode {
             if mMode.count > 0 {
-                print("mode: \(mMode) ")
+                print("mode: \(mMode.uppercased()) ")
             }
         }
     }

package/ios/Plugin/ReturnHandler.swift

@@ -93,4 +93,17 @@ class ReturnHandler {
             return
         }
     }
+
+    // MARK: - rPath
+
+    func rPath(call: CAPPluginCall, ret: String,
+               message: String? = nil) {
+        if let intMessage = message {
+            call.reject(intMessage)
+            return
+        } else {
+            call.resolve(["path": ret])
+            return
+        }
+    }
 }

package/ios/Plugin/Utils/UtilsFile.swift

@@ -180,17 +180,24 @@ class UtilsFile {
 
     // MARK: - GetFileList
 
-    class func getFileList(path: String, ext: String) throws -> [String] {
+    class func getFileList(path: String, ext: String? = nil) throws -> [String] {
+
         do {
-            var dbs: [String] = []
+            var files: [String] = []
             let filenames = try FileManager.default
                 .contentsOfDirectory(atPath: path)
             for file in filenames {
-                if file.hasSuffix(ext) {
-                    dbs.append(file)
+                if let mExtension = ext {
+                    if file.hasSuffix(mExtension) {
+                        files.append(file)
+                    }
+                } else {
+                    if file.prefix(1) != "." {
+                        files.append(file)
+                    }
                 }
             }
-            return dbs
+            return files
         } catch let error {
             print("Error: \(error)")
             throw UtilsFileError.getFileListFailed

package/ios/Plugin/Utils/UtilsMigrate.swift

@@ -14,7 +14,7 @@ enum UtilsMigrateError: Error {
 
 class UtilsMigrate {
 
-    // MARK: - addSQLiteSuffix
+    // MARK: - getMigratableList
 
     class func getMigratableList(folderPath: String) throws -> [String] {
         var mDbList: [String] = []
@@ -25,7 +25,7 @@ class UtilsMigrate {
             if FileManager.default.fileExists(atPath: dbPathURL.relativePath,
                                               isDirectory: &isDir) &&
                 isDir.boolValue {
-                mDbList = try UtilsFile.getFileList(path: dbPathURL.relativePath, ext: ".db")
+                mDbList = try UtilsFile.getFileList(path: dbPathURL.relativePath, ext: nil)
 
                 return mDbList
             } else {
@@ -47,7 +47,9 @@ class UtilsMigrate {
     }
 
     // MARK: - addSQLiteSuffix
+
     // swiftlint:disable function_body_length
+    // swiftlint:disable cyclomatic_complexity
     class func addSQLiteSuffix(folderPath: String, dbList: [String]) throws {
         var fromFile: String = ""
         var toFile: String = ""
@@ -59,12 +61,32 @@ class UtilsMigrate {
             if FileManager.default.fileExists(atPath: dbPathURL.relativePath,
                                               isDirectory: &isDir) &&
                 isDir.boolValue {
-                let mDbList: [String] = try UtilsFile
-                    .getFileList(path: dbPathURL.relativePath, ext: ".db")
+                var mDbList: [String]
+                if dbList.count > 0 {
+                    mDbList = try UtilsFile
+                        .getFileList(path: dbPathURL.relativePath, ext: nil)
+                } else {
+                    mDbList = try UtilsFile
+                        .getFileList(path: dbPathURL.relativePath, ext: "db")
+                }
                 for file: String in mDbList {
                     if !file.contains("SQLite.db") {
                         fromFile = file
-                        if dbList.contains(fromFile) {
+                        if dbList.count > 0 {
+                            if dbList.contains(fromFile) {
+                                if String(file.suffix(3)) == ".db" {
+                                    toFile = file
+                                        .replacingOccurrences(of: ".db", with: "SQLite.db")
+                                } else {
+                                    toFile = file + "SQLite.db"
+                                }
+                                try UtilsFile
+                                    .copyFromNames(dbPathURL: dbPathURL,
+                                                   fromFile: fromFile,
+                                                   databaseURL: databaseURL,
+                                                   toFile: toFile)
+                            }
+                        } else {
                             toFile = file
                                 .replacingOccurrences(of: ".db", with: "SQLite.db")
                             try UtilsFile
@@ -98,9 +120,13 @@ class UtilsMigrate {
             throw UtilsMigrateError.addSQLiteSuffix(message: msg)
         }
     }
+    // swiftlint:enable cyclomatic_complexity
     // swiftlint:enable function_body_length
 
     // MARK: - deleteOldDatabase
+
+    // swiftlint:disable function_body_length
+    // swiftlint:disable cyclomatic_complexity
     class func deleteOldDatabases(folderPath: String, dbList: [String]) throws {
         do {
             let dbPathURL: URL = try UtilsMigrate
@@ -109,17 +135,35 @@ class UtilsMigrate {
             if FileManager.default.fileExists(atPath: dbPathURL.relativePath,
                                               isDirectory: &isDir) &&
                 isDir.boolValue {
-                let mDbList: [String] = try UtilsFile
-                    .getFileList(path: dbPathURL.relativePath, ext: ".db")
+                var mDbList: [String]
+                if dbList.count > 0 {
+                    mDbList = try UtilsFile
+                        .getFileList(path: dbPathURL.relativePath, ext: nil)
+                } else {
+                    mDbList = try UtilsFile
+                        .getFileList(path: dbPathURL.relativePath, ext: "db")
+                }
                 for file: String in mDbList {
                     if !file.contains("SQLite.db") {
-                        if dbList.contains(file) {
-                            let ret: Bool = try UtilsFile
-                                .deleteFile(dbPathURL: dbPathURL, fileName: file)
-                            if !ret {
-                                throw UtilsMigrateError
-                                .deleteOldDatabases(message: "deleteFileFailed")
+                        if dbList.count > 0 {
+                            if dbList.contains(file) {
+                                let ret: Bool = try UtilsFile
+                                    .deleteFile(dbPathURL: dbPathURL, fileName: file)
+                                if !ret {
+                                    throw UtilsMigrateError
+                                    .deleteOldDatabases(message: "deleteFileFailed")
+                                }
+                            }
+                        } else {
+                            if file.contains(".db") {
+                                let ret: Bool = try UtilsFile
+                                    .deleteFile(dbPathURL: dbPathURL, fileName: file)
+                                if !ret {
+                                    throw UtilsMigrateError
+                                    .deleteOldDatabases(message: "deleteFileFailed")
+                                }
                             }
+
                         }
                     }
                 }
@@ -144,6 +188,8 @@ class UtilsMigrate {
             throw UtilsMigrateError.addSQLiteSuffix(message: msg)
         }
     }
+    // swiftlint:enable cyclomatic_complexity
+    // swiftlint:enable function_body_length
 
     // MARK: - getFolderURL
     class func getFolderURL(folderPath: String) throws -> URL {

package/ios/Plugin/Utils/UtilsNCDatabase.swift

@@ -0,0 +1,31 @@
+//
+//  UtilsNCDatabase.swift
+//  CapacitorCommunitySqlite
+//
+//  Created by  Quéau Jean Pierre on 17/12/2021.
+//
+
+import Foundation
+enum UtilsNCDatabaseError: Error {
+    case getNCDatabasePath(message: String)
+}
+
+class UtilsNCDatabase {
+
+    // MARK: - getNCDatabasePath
+
+    class func getNCDatabasePath(folderPath: String, database: String) throws -> String {
+        do {
+            let dbPathURL: URL = try UtilsMigrate
+                .getFolderURL(folderPath: folderPath)
+            return dbPathURL.appendingPathComponent("\(database)").path
+        } catch UtilsMigrateError.getFolderURL(let message) {
+            throw UtilsNCDatabaseError.getNCDatabasePath(message: message)
+        } catch let error {
+            var msg: String = "getNCDatabasePath command failed :"
+            msg.append(" \(error.localizedDescription)")
+            throw UtilsNCDatabaseError.getNCDatabasePath(message: msg)
+        }
+
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "3.2.5-2",
+  "version": "3.3.3-1",
   "description": "Community plugin for native & electron SQLite databases",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -55,10 +55,10 @@
     "prepublishOnly": "npm run build && npm run build-electron && npm run docgen"
   },
   "devDependencies": {
-    "@capacitor/android": "^3.2.5",
-    "@capacitor/core": "3.2.5",
+    "@capacitor/android": "^3.3.3",
+    "@capacitor/core": "3.3.3",
     "@capacitor/docgen": "^0.0.17",
-    "@capacitor/ios": "^3.2.5",
+    "@capacitor/ios": "^3.3.3",
     "@ionic/eslint-config": "^0.3.0",
     "@ionic/prettier-config": "^1.0.1",
     "@ionic/swiftlint-config": "^1.1.2",
@@ -74,7 +74,7 @@
     "typescript": "~4.0.5"
   },
   "peerDependencies": {
-    "@capacitor/core": "^3.2.5"
+    "@capacitor/core": "^3.3.3"
   },
   "prettier": "@ionic/prettier-config",
   "swiftlint": "@ionic/swiftlint-config",