@capacitor-community/sqlite 5.5.1 → 5.6.0

package/ios/Plugin/CapacitorSQLite.swift

@@ -1012,7 +1012,6 @@ enum CapacitorSQLiteError: Error {
 
     // MARK: - deleteDatabase
 
-    // swiftlint:disable function_body_length
     // swiftlint:disable cyclomatic_complexity
     @objc func deleteDatabase(_ dbName: String, readonly: Bool) throws {
         guard isInit else {
@@ -1032,8 +1031,9 @@ enum CapacitorSQLiteError: Error {
             if !mDb.isDBOpen() {
                 // check the state of the DB
                 let state: State = UtilsSQLCipher.getDatabaseState(databaseLocation: databaseLocation, databaseName: "\(mDbName)SQLite.db", account: account)
-                if !isEncryption &&  (state.rawValue == "ENCRYPTEDGLOBALSECRET" ||
-                                        state.rawValue == "ENCRYPTEDSECRET") {
+                if !isEncryption && 
+                        (state.rawValue == "ENCRYPTEDGLOBALSECRET" ||
+                         state.rawValue == "ENCRYPTEDSECRET") {
                     var msg = "Cannot delete an Encrypted database with "
                     msg += "No Encryption set in capacitor.config"
                     throw CapacitorSQLiteError.failed(message: msg)
@@ -1067,7 +1067,6 @@ enum CapacitorSQLiteError: Error {
         }
     }
     // swiftlint:enable cyclomatic_complexity
-    // swiftlint:enable function_body_length
 
     // MARK: - isJsonValid
 

package/ios/Plugin/Database.swift

@@ -689,7 +689,9 @@ class Database {
                 // Set the last exported date
                 try ExportToJson.setLastExportDate(mDB: self, sTime: syncTime)
             } else {
-                throw DatabaseError.exportToJson(message: "No sync_table available")
+                if expMode == "partial" {
+                    throw DatabaseError.exportToJson(message: "No sync_table available")
+                }
             }
             // Launch the export process
             let data: [String: Any] = [

package/ios/Plugin/Utils/UtilsDelete.swift

@@ -290,7 +290,7 @@ class UtilsDelete {
         var relatedItems: [[String: Any]] = []
         var key: String = ""
         let t1Names = withRefsNames.map { "t1.\($0)" }
-        let t2Names = colNames.map{ "t2.\($0)" }
+        let t2Names = colNames.map { "t2.\($0)" }
 
         do {
             var whereClause = try UtilsSQLStatement

package/ios/Plugin/Utils/UtilsSQLCipher.swift

@@ -447,7 +447,7 @@ class UtilsSQLCipher {
             msg.append("Database not opened")
             throw UtilsSQLCipherError.prepareSQL(message: msg)
         }
-//        let systemVersion = UIDevice.current.systemVersion
+        //        let systemVersion = UIDevice.current.systemVersion
         var runSQLStatement: OpaquePointer?
         var message: String = ""
         var lastId: Int64 = -1
@@ -554,7 +554,6 @@ class UtilsSQLCipher {
             return (lastId, result)
         }
     }
-    
 
     // MARK: - returningWorkAround
 

package/ios/Plugin/Utils/UtilsSQLStatement.swift

@@ -327,51 +327,49 @@ class UtilsSQLStatement {
 
     class func isReturning(sqlStmt: String) -> (Bool, String, String) {
         var stmt = sqlStmt.replacingOccurrences(of: "\n", with: "")
-                          .trimmingCharacters(in: .whitespacesAndNewlines)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
         if stmt.hasSuffix(";") {
             // Remove the suffix
             stmt = String(stmt.dropLast())
-                        .trimmingCharacters(in: .whitespacesAndNewlines)
+                .trimmingCharacters(in: .whitespacesAndNewlines)
         }
 
-        switch (stmt.prefix(6).uppercased())  {
-            
-          case "INSERT":
+        switch stmt.prefix(6).uppercased() {
+
+        case "INSERT":
             if let valuesIndex = stmt.range(of: "VALUES", options: .caseInsensitive)?.lowerBound,
                let closingParenthesisIndex = stmt.range(of: ")", options: .backwards, range: valuesIndex..<stmt.endIndex)?.upperBound {
-                    guard closingParenthesisIndex < stmt.endIndex else {
-                        stmt += ";"
-                        return (false, stmt, "")
-                    }
+                guard closingParenthesisIndex < stmt.endIndex else {
+                    stmt += ";"
+                    return (false, stmt, "")
+                }
 
-                    let intParenthesisValue = stmt.distance(from: stmt.startIndex, to: closingParenthesisIndex)
-                    let substringAfterValues = stmt[closingParenthesisIndex...]
-                    var resultString = String(substringAfterValues)
-                                .trimmingCharacters(in: .whitespacesAndNewlines)
-                    if resultString.count > 0 && !resultString.hasSuffix(";") {
-                        resultString += ";"
-                    }
+                let intParenthesisValue = stmt.distance(from: stmt.startIndex, to: closingParenthesisIndex)
+                let substringAfterValues = stmt[closingParenthesisIndex...]
+                var resultString = String(substringAfterValues)
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                if resultString.count > 0 && !resultString.hasSuffix(";") {
+                    resultString += ";"
+                }
 
-                    let substringStartToEndParenthesis = stmt[...closingParenthesisIndex]
-                    let stmtString = String(substringStartToEndParenthesis)
-                                .trimmingCharacters(in: .whitespacesAndNewlines)
-                                .appending(";")
+                let substringStartToEndParenthesis = stmt[...closingParenthesisIndex]
+                let stmtString = String(substringStartToEndParenthesis)
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                    .appending(";")
 
-                    if substringAfterValues.lowercased().contains("returning") {
-                        return (true,stmtString,resultString)
-                    } else {
-                        return (false, stmt, "")
-                    }
+                if substringAfterValues.lowercased().contains("returning") {
+                    return (true, stmtString, resultString)
+                } else {
+                    return (false, stmt, "")
                 }
-                return (false, stmt, "")
-            
-            
-          case "DELETE", "UPDATE":
+            }
+            return (false, stmt, "")
+
+        case "DELETE", "UPDATE":
             let words = stmt.components(separatedBy: .whitespacesAndNewlines)
             var wordsBeforeReturning: [String] = []
             var returningString: [String] = []
 
-
             var isReturningOutsideMessage = false
             for word in words {
                 if word.lowercased() == "returning" {
@@ -387,7 +385,7 @@ class UtilsSQLStatement {
                 let joinedWords = wordsBeforeReturning.joined(separator: " ") + ";"
                 var joinedReturningString = returningString.joined(separator: " ")
                 if joinedReturningString.count > 0 &&
-                            !joinedReturningString.hasSuffix(";") {
+                    !joinedReturningString.hasSuffix(";") {
                     joinedReturningString += ";"
                 }
 
@@ -395,11 +393,11 @@ class UtilsSQLStatement {
             } else {
                 return (false, stmt, "")
             }
-            
-          default:
+
+        default:
             return (false, stmt, "")
         }
-        
+
     }
 
     // MARK: - wordsAfter
@@ -410,13 +408,13 @@ class UtilsSQLStatement {
         }
         return Array(words.suffix(from: index + 1))
     }
-    
+
     // MARK: - getStmtAndRetColNames
 
     class func getStmtAndRetColNames(sqlStmt: String, retMode: String)
     -> [String: String] {
         var retStmtNames: [String: String] = [:]
-        
+
         let (isReturning, stmt, suffix) = isReturning(sqlStmt: sqlStmt)
         retStmtNames["stmt"] = stmt
         retStmtNames["names"] = ""
@@ -426,7 +424,7 @@ class UtilsSQLStatement {
                 let substring = suffix[returningIndex.upperBound...]
 
                 let names =
-                "\(substring)".trimmingLeadingAndTrailingSpaces()
+                    "\(substring)".trimmingLeadingAndTrailingSpaces()
                 if names.suffix(1) == ";" {
                     retStmtNames["names"] = String(names.dropLast())
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "5.5.1",
+  "version": "5.6.0",
   "description": "Community plugin for native & electron SQLite databases",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -59,11 +59,11 @@
     "prepublishOnly": "npm run build && npm run build-electron && npm run docgen"
   },
   "devDependencies": {
-    "@capacitor/android": "^5.5.1",
-    "@capacitor/cli": "^5.5.1",
-    "@capacitor/core": "^5.5.1",
+    "@capacitor/android": "^5.6.0",
+    "@capacitor/cli": "^5.6.0",
+    "@capacitor/core": "^5.6.0",
     "@capacitor/docgen": "^0.0.17",
-    "@capacitor/ios": "^5.5.1",
+    "@capacitor/ios": "^5.6.0",
     "@ionic/eslint-config": "^0.3.0",
     "@ionic/prettier-config": "^1.0.1",
     "@ionic/swiftlint-config": "^1.1.2",
@@ -97,6 +97,6 @@
     }
   },
   "dependencies": {
-    "jeep-sqlite": "^2.5.7"
+    "jeep-sqlite": "^2.5.9"
   }
 }

package/src/definitions.ts

@@ -2207,7 +2207,6 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
     try {
       if (!this.readonly) {
         if (values && values.length > 0) {
-
           res = await this.sqlite.run({
             database: this.dbName,
             statement: statement,

package/src/web-typeorm-utils/database.ts

@@ -0,0 +1,111 @@
+/************************************************
+ * Only to be used to run TypeOrm Cli
+ * migration:generate
+ * A in-memory database is used
+ ************************************************
+ */
+
+import type { capSQLiteChanges, capSQLiteValues } from '../definitions';
+
+import { UtilsSQLite } from './utilsSQLite';
+
+export class Database {
+  private _isDBOpen: boolean;
+  private wasmPath = 'assets';
+  private sqliteUtil: UtilsSQLite = new UtilsSQLite();
+  private typeOrmDBFolder = this.sqliteUtil.getTypeOrmDBFolder();
+  private dbPath = '';
+  public mDb: any;
+
+  constructor() {
+    this.mDb = null;
+    this._isDBOpen = false;
+  }
+  public async open(dbName: string): Promise<void> {
+    try {
+      this.dbPath = this.sqliteUtil.getTypeOrmDBPath(
+        this.typeOrmDBFolder,
+        `${dbName}SQLite.db`,
+      );
+
+      this.mDb = await this.sqliteUtil.openOrCreateDatabase(
+        this.wasmPath,
+        this.dbPath,
+      );
+      this._isDBOpen = true;
+      return Promise.resolve();
+    } catch (err) {
+      return Promise.reject(`Open: ${err}`);
+    }
+  }
+  public async close(): Promise<void> {
+    try {
+      if (this._isDBOpen) {
+        await this.sqliteUtil.saveDatabase(this.mDb, this.dbPath);
+        await this.mDb.close();
+      }
+      return Promise.resolve();
+    } catch (err) {
+      return Promise.reject(`Close: ${err}`);
+    }
+  }
+
+  public async executeSQL(statements: string): Promise<number> {
+    let changes = -1;
+    try {
+      if (this._isDBOpen) {
+        const initChanges = await this.sqliteUtil.dbChanges(this.mDb);
+        changes = await this.sqliteUtil.execute(this.mDb, statements);
+        if (changes < 0) {
+          return Promise.reject(new Error('ExecuteSQL: changes < 0'));
+        }
+        changes = (await this.sqliteUtil.dbChanges(this.mDb)) - initChanges;
+      }
+      return Promise.resolve(changes);
+    } catch (err) {
+      return Promise.reject(`ExecuteSQL: ${err}`);
+    }
+  }
+  public async run(
+    statement: string,
+    values: any[],
+    returnMode: string,
+  ): Promise<capSQLiteChanges> {
+    const retRes: any = { changes: -1, lastId: -1 };
+
+    try {
+      if (this._isDBOpen) {
+        const initChanges = await this.sqliteUtil.dbChanges(this.mDb);
+        const retObj = await this.sqliteUtil.run(
+          this.mDb,
+          statement,
+          values,
+          returnMode,
+        );
+        const lastId = retObj['lastId'];
+        if (lastId < 0) {
+          return Promise.reject(new Error('RunSQL: lastId < 0'));
+        }
+        const changes =
+          (await this.sqliteUtil.dbChanges(this.mDb)) - initChanges;
+        retRes.changes = changes;
+        retRes.lastId = lastId;
+        retRes.values = retObj['values'] ? retObj['values'] : [];
+      }
+      return Promise.resolve({ changes: retRes });
+    } catch (err) {
+      return Promise.reject(`Run: ${err}`);
+    }
+  }
+  public async selectSQL(sql: string, values: any[]): Promise<capSQLiteValues> {
+    let retArr: any[] = [];
+    try {
+      if (this._isDBOpen) {
+        retArr = await this.sqliteUtil.queryAll(this.mDb, sql, values);
+      }
+      return Promise.resolve({ values: retArr });
+    } catch (err) {
+      return Promise.reject(`SelectSQL: ${err}`);
+    }
+  }
+}

package/src/web-typeorm-utils/utilsSQLite.ts

@@ -0,0 +1,249 @@
+/************************************************
+ * Only to be used to run TypeOrm Cli
+ * migration:generate
+ * A in-memory database is used
+ ************************************************
+ */
+
+export class UtilsSQLite {
+  public initSqlJs: any;
+  public FS: any;
+  public OS: any;
+  public Path: any;
+  private isExists = false;
+  private retExists = { isExists: false, pathWasm: '' };
+
+  constructor() {
+    this.initSqlJs = require('sql.js');
+    this.OS = require('os');
+    this.FS = require('fs');
+    this.Path = require('path');
+  }
+  public getTypeOrmDBFolder(): string {
+    // Find the index of the "node_modules" string in the path
+    const nodeModulesIndex = __dirname.indexOf('node_modules');
+
+    // Extract the part of the path before "node_modules"
+    const outputPath = __dirname.slice(0, nodeModulesIndex);
+
+    // Extract the App name
+    const appName = this.Path.basename(outputPath);
+
+    // Get the Documents path
+    const documentsDirectory = this.Path.join(this.OS.homedir(), 'Documents');
+
+    // Add "CapacitorSQLite" and appName
+    const outputFolderPath = this.Path.join(
+      documentsDirectory,
+      'CapacitorSQLite',
+      appName,
+    );
+
+    // Ensure the output folder exists
+    this.FS.mkdirSync(outputFolderPath, { recursive: true });
+    return outputFolderPath;
+  }
+  public getTypeOrmDBPath(outputFolderPath: string, dbName: string): string {
+    return this.Path.resolve(outputFolderPath, dbName);
+  }
+  public async checkFileExistence(wasmPath: string): Promise<any> {
+    // check if a public folder exists
+    const folder = (await this.checkFolderExistence('public'))
+      ? 'public'
+      : 'src';
+    const pathWasm = this.Path.join(folder, wasmPath);
+    const retObj: any = {};
+    retObj.pathWasm = pathWasm;
+    try {
+      if (this.FS.existsSync(pathWasm)) {
+        retObj.isExists = true;
+        return Promise.resolve(retObj);
+      } else {
+        retObj.isExists = false;
+        return Promise.resolve(retObj);
+      }
+    } catch (err) {
+      retObj.isExists = false;
+      return Promise.resolve(retObj);
+    }
+  }
+  public async checkFolderExistence(folder: string): Promise<boolean> {
+    try {
+      if (this.FS.existsSync(folder)) {
+        return Promise.resolve(true);
+      } else {
+        return Promise.resolve(false);
+      }
+    } catch (err) {
+      return Promise.resolve(false);
+    }
+  }
+  public async openOrCreateDatabase(
+    wasmPath: string,
+    databasePath: string,
+  ): Promise<any> {
+    let mDB: any;
+    const msg = 'OpenOrCreateDatabase';
+    try {
+      this.retExists = await this.checkFileExistence(wasmPath);
+      this.isExists = this.retExists.isExists;
+    } catch (err) {
+      this.isExists = false;
+    }
+    if (!this.isExists) {
+      return Promise.reject(msg + ' No sql-wasm.wasm found in ' + wasmPath);
+    }
+
+    try {
+      const config = {
+        locateFile: (file: any) => `${this.retExists.pathWasm}/${file}`,
+      };
+
+      const SQL = await this.initSqlJs(config);
+      // Check if the database exists
+      if (!this.FS.existsSync(databasePath)) {
+        mDB = new SQL.Database();
+      } else {
+        // Read the database file from the local disk
+        const fileBuffer = this.FS.readFileSync(databasePath);
+        // Create a new database instance
+        mDB = new SQL.Database(fileBuffer);
+      }
+
+      return Promise.resolve(mDB);
+    } catch (err: any) {
+      return Promise.reject(msg + ' open database failed');
+    }
+  }
+  public async saveDatabase(mDb: any, outputPath: string): Promise<void> {
+    try {
+      // Export the modified database to a Uint8Array
+      const data = mDb.export();
+
+      // Write the Uint8Array to a file on the local disk
+      this.FS.writeFileSync(outputPath, Buffer.from(data));
+
+      return Promise.resolve();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  public closeDB(mDB: any): Promise<void> {
+    const msg = 'closeDB';
+    try {
+      mDB.close();
+      return Promise.resolve();
+    } catch (err: any) {
+      const errmsg = err.message ? err.message : err;
+      return Promise.reject(`${msg} ${errmsg}`);
+    }
+  }
+  public async dbChanges(mDB: any): Promise<number> {
+    const SELECT_CHANGE = 'SELECT total_changes()';
+    let changes = 0;
+    try {
+      const res = mDB.exec(SELECT_CHANGE);
+      // process the row here
+      changes = res[0].values[0][0];
+      return Promise.resolve(changes);
+    } catch (err: any) {
+      const errmsg = err.message ? err.message : err;
+      return Promise.reject(`DbChanges failed: ${errmsg}`);
+    }
+  }
+  public async getLastId(mDB: any): Promise<number> {
+    const SELECT_LAST_ID = 'SELECT last_insert_rowid()';
+    let lastId = -1;
+    try {
+      const res = mDB.exec(SELECT_LAST_ID);
+      // process the row here
+      lastId = res[0].values[0][0];
+      return Promise.resolve(lastId);
+    } catch (err: any) {
+      const errmsg = err.message ? err.message : err;
+      return Promise.reject(new Error(`GetLastId failed: ${errmsg}`));
+    }
+  }
+  public async execute(mDB: any, sql: string): Promise<number> {
+    try {
+      mDB.exec(sql);
+      const changes = await this.dbChanges(mDB);
+      return Promise.resolve(changes);
+    } catch (err: any) {
+      const errmsg = err.message ? err.message : err;
+      return Promise.reject(new Error(`Execute failed: ${errmsg}`));
+    }
+  }
+  public async run(
+    mDB: any,
+    statement: string,
+    values: any[],
+    returnMode: string,
+  ): Promise<any> {
+    let res: any;
+    let retValues: any[] = [];
+    const retObj: any = {};
+
+    try {
+      if (values.length > 0) {
+        res = mDB.exec(statement, values);
+      } else {
+        res = mDB.exec(statement);
+      }
+      if (returnMode === 'all' || returnMode === 'one') {
+        if (res && res.length > 0) {
+          retValues = this.getReturnedValues(res[0], returnMode);
+        }
+      }
+      const lastId = await this.getLastId(mDB);
+      retObj['lastId'] = lastId;
+      if (retValues != null && retValues.length > 0)
+        retObj['values'] = retValues;
+      return Promise.resolve(retObj);
+    } catch (err: any) {
+      const errmsg = err.message ? err.message : err;
+      return Promise.reject(new Error(`Run failed: ${errmsg}`));
+    }
+  }
+  public getReturnedValues(result: any, returnMode: string): any[] {
+    const retValues: any[] = [];
+    for (const values of result.values) {
+      const row: any = {};
+
+      for (let j = 0; j < result.columns.length; j++) {
+        row[result.columns[j]] = values[j];
+      }
+
+      retValues.push(row);
+
+      if (returnMode === 'one') {
+        break;
+      }
+    }
+    return retValues;
+  }
+  public async queryAll(mDB: any, sql: string, values: any[]): Promise<any[]> {
+    try {
+      let retArr: any[] = [];
+      if (values != null && values.length > 0) {
+        retArr = mDB.exec(sql, values);
+      } else {
+        retArr = mDB.exec(sql);
+      }
+      if (retArr.length == 0) return Promise.resolve([]);
+
+      const result = retArr[0].values.map((entry: any[]) => {
+        const obj: any = {};
+        retArr[0].columns.forEach((column: string, index: number) => {
+          obj[`${column}`] = entry[index];
+        });
+        return obj;
+      });
+
+      return Promise.resolve(result);
+    } catch (err: any) {
+      const errmsg = err.message ? err.message : err;
+      return Promise.reject(new Error(`queryAll: ${errmsg}`));
+    }
+  }
+}