@capacitor-community/sqlite 4.6.2-1 → 4.6.2-2

package/ios/Plugin/CapacitorSQLite.swift

@@ -606,6 +606,34 @@ enum CapacitorSQLiteError: Error {
         }
     }
 
+    // MARK: - IsDatabaseEncrypted
+
+    @objc public func isDatabaseEncrypted(_ dbName: String) throws -> NSNumber {
+        if isInit {
+            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+            let isFileExists: Bool = UtilsFile
+                .isFileExist(databaseLocation: databaseLocation,
+                             fileName: mDbName + "SQLite.db")
+            if isFileExists {
+                let state: State = UtilsSQLCipher
+                        .getDatabaseState(databaseLocation: databaseLocation,
+                                          databaseName: mDbName + "SQLite.db",
+                                          account: account)
+                if state.rawValue == "ENCRYPTEDGLOBALSECRET" || state.rawValue == "ENCRYPTEDSECRET" {
+                    return 1;
+                }
+                if state.rawValue == "UNENCRYPTED" {
+                    return 0;
+                }
+                throw CapacitorSQLiteError.failed(message: "Database unknown")
+            } else {
+                throw CapacitorSQLiteError.failed(message: "Database does not exist")
+            }
+        } else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+    }
+
     // MARK: - IsNCDatabase
 
     @objc public func isNCDatabase(_ databasePath: String) throws -> NSNumber {

package/ios/Plugin/CapacitorSQLitePlugin.m

@@ -46,4 +46,7 @@ CAP_PLUGIN(CapacitorSQLitePlugin, "CapacitorSQLite",
            CAP_PLUGIN_METHOD(clearEncryptionSecret, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(getFromHTTPRequest, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(checkEncryptionSecret, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(isInConfigEncryption, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(isInConfigBiometricAuth, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(isDatabaseEncrypted, CAPPluginReturnPromise);
 )

package/ios/Plugin/CapacitorSQLitePlugin.swift

@@ -41,6 +41,56 @@ public class CapacitorSQLitePlugin: CAPPlugin {
         }
     }
 
+    // MARK: - IsInConfigEncryption
+
+    @objc func isInConfigEncryption(_ call: CAPPluginCall) {
+        var bRes: Bool = false
+        if self.config?.iosIsEncryption == 1 {
+            bRes = true
+        }
+
+        retHandler.rResult(call: call, ret: bRes)
+    }
+
+    // MARK: - IsInConfigBiometricAuth
+
+    @objc func isInConfigBiometricAuth(_ call: CAPPluginCall) {
+        var bRes: Bool = false
+        if self.config?.biometricAuth == 1 {
+            bRes = true
+        }
+
+        retHandler.rResult(call: call, ret: bRes)
+    }
+    // MARK: - IsDatabaseEncrypted
+
+    @objc func isDatabaseEncrypted(_ call: CAPPluginCall) {
+        guard let dbName = call.options["database"] as? String else {
+            retHandler.rResult(
+                call: call, ret: false,
+                message: "isDatabaseEncrypted: Must provide a database name")
+            return
+        }
+        do {
+            let res = try implementation?.isDatabaseEncrypted(dbName)
+            var bRes: Bool = false
+            if res == 1 {
+                bRes = true
+            }
+            retHandler.rResult(call: call, ret: bRes)
+        } catch CapacitorSQLiteError.failed(let message) {
+            let msg = "isDatabaseEncrypted: \(message)"
+            retHandler.rResult(call: call, message: msg)
+            return
+        } catch let error {
+            retHandler.rResult(
+                call: call,
+                message: "isDatabaseEncrypted: \(error)")
+            return
+        }
+
+    }
+
     // MARK: - IsSecretStored
 
     @objc func isSecretStored(_ call: CAPPluginCall) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "4.6.2-1",
+  "version": "4.6.2-2",
   "description": "Community plugin for native & electron SQLite databases",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",

package/src/definitions.ts

@@ -158,6 +158,25 @@ export interface CapacitorSQLitePlugin {
    * @since 3.0.0-beta.5
    */
   isDBOpen(options: capSQLiteOptions): Promise<capSQLiteResult>;
+  /**
+   * Check if a SQLite database is encrypted
+   * @param options: capSQLiteOptions
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isDatabaseEncrypted(options: capSQLiteOptions): Promise<capSQLiteResult>;
+  /**
+   * Check encryption value in capacitor.config
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isInConfigEncryption(): Promise<capSQLiteResult>;
+  /**
+   * Check encryption value in capacitor.config
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isInConfigBiometricAuth(): Promise<capSQLiteResult>;
   /**
    * Check if a SQLite database exists without connection
    * @param options: capSQLiteOptions
@@ -1054,6 +1073,25 @@ export interface ISQLiteConnection {
    * @since 4.1.1
    */
   getFromHTTPRequest(url?: string, overwrite?: boolean): Promise<void>;
+  /**
+   * Check if a SQLite database is encrypted
+   * @param options: capSQLiteOptions
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isDatabaseEncrypted(database: string): Promise<capSQLiteResult>;
+  /**
+   * Check encryption value in capacitor.config
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isInConfigEncryption(): Promise<capSQLiteResult>;
+  /**
+   * Check encryption value in capacitor.config
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isInConfigBiometricAuth(): Promise<capSQLiteResult>;
   /**
    * Check if a database exists
    * @param database
@@ -1418,6 +1456,31 @@ export class SQLiteConnection implements ISQLiteConnection {
       return Promise.reject(err);
     }
   }
+  async isDatabaseEncrypted(database: string): Promise<capSQLiteResult> {
+    if (database.endsWith('.db')) database = database.slice(0, -3);
+    try {
+      const res = await this.sqlite.isDatabaseEncrypted({ database: database });
+      return Promise.resolve(res);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async isInConfigEncryption(): Promise<capSQLiteResult> {
+    try {
+      const res = await this.sqlite.isInConfigEncryption();
+      return Promise.resolve(res);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async isInConfigBiometricAuth(): Promise<capSQLiteResult> {
+    try {
+      const res = await this.sqlite.isInConfigBiometricAuth();
+      return Promise.resolve(res);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
   async isDatabase(database: string): Promise<capSQLiteResult> {
     if (database.endsWith('.db')) database = database.slice(0, -3);
     try {

package/src/web.ts

@@ -536,4 +536,17 @@ export class CapacitorSQLiteWeb
     console.log('isNCDatabase', options);
     throw this.unimplemented('Not implemented on web.');
   }
+
+  async isDatabaseEncrypted(options: capSQLiteOptions): Promise<capSQLiteResult> {
+    console.log('isDatabaseEncrypted', options);
+    throw this.unimplemented('Not implemented on web.');
+  }
+
+  async isInConfigEncryption(): Promise<capSQLiteResult> {
+    throw this.unimplemented('Not implemented on web.');
+  }
+
+  async isInConfigBiometricAuth(): Promise<capSQLiteResult> {
+    throw this.unimplemented('Not implemented on web.');
+  }
 }