@capacitor-community/sqlite 5.0.5 → 5.0.7-1

package/ios/Plugin/Utils/UtilsSQLStatement.swift

@@ -0,0 +1,450 @@
+//
+//  UtilsSQLStatement.swift
+//  CapacitorCommunitySqlite
+//
+//  Created by  Quéau Jean Pierre on 30/07/2023.
+//
+
+import Foundation
+enum UtilsSQLStatementError: Error {
+    case extractColumnNames(message:String)
+    case extractForeignKeyInfo(message:String)
+    case addPrefixToWhereClause(message:String)
+}
+
+class UtilsSQLStatement {
+  
+    // MARK: - extractTableName
+
+    class func extractTableName(from statement: String) -> String? {
+        let pattern =
+            "(?:INSERT\\s+INTO|UPDATE|DELETE\\s+FROM)\\s+([^\\s]+)"
+        guard let regex = try? NSRegularExpression(pattern: pattern,
+                                                   options: []) else {
+            return nil }
+
+        let range = NSRange(location: 0, length: statement.count)
+        if let match = regex.firstMatch(in: statement, options: [],
+                                        range: range) {
+            let tableNameRange = match.range(at: 1)
+            if let tableNameRange = Range(tableNameRange,
+                                          in: statement) {
+                let tableName = String(statement[tableNameRange])
+                return tableName
+            }
+        }
+
+        return nil
+    }
+
+    // MARK: - extractWhereClause
+    
+    class func extractWhereClause(from statement: String) -> String? {
+        let pattern = "WHERE(.+?)(?:ORDER\\s+BY|LIMIT|$)"
+        guard let regex = try? NSRegularExpression(
+                pattern: pattern,
+                options: [.caseInsensitive,
+                          .dotMatchesLineSeparators]) else {
+            return nil
+
+        }
+
+        let range = NSRange(location: 0, length: statement.count)
+        if let match = regex.firstMatch(in: statement, options: [],
+                                        range: range) {
+            let whereClauseRange = match.range(at: 1)
+            if let whereClauseRange = Range(whereClauseRange,
+                                            in: statement) {
+                let whereClause = String(statement[whereClauseRange])
+                return whereClause
+                    .trimmingCharacters(in: .whitespacesAndNewlines)
+            }
+        }
+
+        return nil
+    }
+    
+    // MARK: - addPrefixToWhereClause
+    
+    class func addPrefixToWhereClause(_ whereClause: String, from: [String],
+                                      to: [String],prefix: String)
+                                                    throws -> String {
+        var columnValuePairs: [String]
+        if whereClause.contains("AND") {
+            if #available(iOS 16.0, *) {
+                let subSequenceArray = whereClause
+                                .split(separator: "AND")
+                columnValuePairs = subSequenceArray.map { String($0) }
+            } else {
+                columnValuePairs = whereClause
+                                .components(separatedBy: "AND")
+            }
+        } else {
+            columnValuePairs = [whereClause]
+        }
+        let modifiedPairs = try columnValuePairs.map { pair -> String in
+            let pattern = #"(\w+)\s*(=|IN|BETWEEN|LIKE)\s*(.+)"#
+                          
+            if let range = pair.range(of: pattern, options: .regularExpression) {
+                let match = String(pair[range])
+                let regex = try NSRegularExpression(pattern: pattern)
+                let matchRange = NSRange(match.startIndex..., in: match)
+                
+                if let matchResult = regex.firstMatch(in: match, range: matchRange) {
+                    let columnRange = Range(matchResult.range(at: 1), in: match)!
+                    let operatorRange = Range(matchResult.range(at: 2), in: match)!
+                    let valueRange = Range(matchResult.range(at: 3), in: match)!
+                    
+                    let column = String(match[columnRange]).trimmingCharacters(in: .whitespacesAndNewlines)
+                    let mOperator = String(match[operatorRange]).trimmingCharacters(in: .whitespacesAndNewlines)
+                    let value = String(match[valueRange]).trimmingCharacters(in: .whitespacesAndNewlines)
+                    
+                    var newColumn = column
+                    if let index = UtilsSQLStatement
+                        .findIndexOfStringInArray(column, to), index != -1 {
+                        guard let mNewColumn = UtilsSQLStatement
+                            .getStringAtIndex(from, index) else {
+                            let msg = "addPrefixToWhereClause: index " +
+                                        "mistmatch "
+                            throw UtilsSQLStatementError
+                                .addPrefixToWhereClause(message: msg)
+                        }
+                        newColumn = mNewColumn
+                    }
+                    
+                    let modifiedColumn = "\(prefix)\(newColumn)"
+                    return "\(modifiedColumn) \(mOperator) \(value)"
+                }
+            }
+            return pair
+        }
+        return modifiedPairs.joined(separator: " AND ")
+                                                        
+    }
+    
+    // MARK: - findIndexOfStringInArray
+    
+    class func findIndexOfStringInArray(_ target: String, _ array: [String]) -> Int? {
+        return array.firstIndex(of: target)
+    }
+    
+    // MARK: - getStringAtIndex
+    
+    class func getStringAtIndex(_ array: [String], _ index: Int) -> String? {
+        if index >= 0 && index < array.count {
+            return array[index]
+        } else {
+            return nil
+        }
+    }
+    // MARK: - extractForeignKeyInfo
+    
+    class func extractForeignKeyInfo(from sqlStatement: String)
+                                                        throws ->
+                                                [String: Any] {
+        var foreignKeyInfo: [String: Any] = [:]
+        // Define the regular expression patterns for extracting the
+        // FOREIGN KEY clause and composite primary keys
+        let foreignKeyPattern = #"\bFOREIGN\s+KEY\s*\(([^)]+)\)\s+REFERENCES\s+(\w+)\s*\(([^)]+)\)\s+(ON\s+DELETE\s+(RESTRICT|CASCADE|SET\s+NULL|SET\s+DEFAULT|NO\s+ACTION))?"#
+
+        // Create a regular expression object
+        guard let regex = try? NSRegularExpression(
+                pattern: foreignKeyPattern, options: []) else {
+            let msg = "extractForeignKeyInfo: creating regular " +
+                        "expression pattern"
+            throw UtilsSQLStatementError
+                        .extractForeignKeyInfo(message: msg)
+
+        }
+
+        // Find the range of the FOREIGN KEY clause in the SQL
+        // statement
+        let range = NSRange(location: 0,
+                            length: sqlStatement.utf16.count)
+        if let match = regex.firstMatch(in: sqlStatement, options: [],
+                                        range: range) {
+            // Extract the column names for the FOREIGN KEY
+            let foreignKeyColumnsRange = match.range(at: 1)
+            if let foreignKeyColumnsRangeInString =
+                Range(foreignKeyColumnsRange, in: sqlStatement) {
+                let foreignKeyColumns =
+                String(sqlStatement[foreignKeyColumnsRangeInString])
+                                .components(separatedBy: ", ")
+
+                // Extract the referenced table and columns
+                let referencedTableRange = match.range(at: 2)
+                let referencedColumnsRange = match.range(at: 3)
+                if
+                    let referencedTableRangeInString =
+                        Range(referencedTableRange, in: sqlStatement),
+                    let referencedColumnsRangeInString =
+                        Range(referencedColumnsRange, in: sqlStatement)
+                {
+                    let referencedTable = String(
+                        sqlStatement[referencedTableRangeInString])
+                    let referencedColumns = String(
+                        sqlStatement[referencedColumnsRangeInString])
+                        .components(separatedBy: ", ")
+
+                    // Extract the ON DELETE action if available
+                    let onDeleteActionRange = match.range(at: 5)
+                    if let onDeleteActionRangeInString =
+                        Range(onDeleteActionRange, in: sqlStatement) {
+                        let onDeleteAction = String(
+                            sqlStatement[onDeleteActionRangeInString])
+                        foreignKeyInfo["forKeys"] = foreignKeyColumns
+                        foreignKeyInfo["tableName"] = referencedTable
+                        foreignKeyInfo["refKeys"] = referencedColumns
+                        foreignKeyInfo["action"] = onDeleteAction
+                        return foreignKeyInfo
+                    } else {
+                        foreignKeyInfo["forKeys"] = foreignKeyColumns
+                        foreignKeyInfo["tableName"] = referencedTable
+                        foreignKeyInfo["refKeys"] = referencedColumns
+                        foreignKeyInfo["action"] = "NO_ACTION"
+                        return foreignKeyInfo
+                    }
+                } else {
+                    let msg = "extractForeignKeyInfo: No match found"
+                    throw UtilsSQLStatementError
+                        .extractForeignKeyInfo(message: msg)
+                }
+            }
+        } else {
+            let msg = "extractForeignKeyInfo: No FOREIGN KEY found"
+            throw UtilsSQLStatementError
+                        .extractForeignKeyInfo(message: msg)
+        }
+        foreignKeyInfo["forKeys"] = []
+        foreignKeyInfo["tableName"] = ""
+        foreignKeyInfo["refKeys"] = []
+        foreignKeyInfo["action"] = "NO_ACTION"
+        return foreignKeyInfo
+    }
+    
+
+    // MARK: - extractColumnNames
+    
+    class func extractColumnNames(from whereClause: String)
+                                            throws -> [String] {
+        let regexPattern = #"\b(\w+)\s*(?=(?:[=<>]|IN\s*\(VALUES\s*|\bBETWEEN\b|\bLIKE\s*'))|(?<=\()\s*(\w+),\s*(\w+)\s*(?=\))"#
+
+        do {
+
+            let regex = try NSRegularExpression(pattern: regexPattern)
+            let matches = regex.matches(in: whereClause, range: NSRange(whereClause.startIndex..., in: whereClause))
+            var columnNames: [String] = []
+
+            for match in matches {
+                for rangeIdx in 1..<match.numberOfRanges {
+                    let range = match.range(at: rangeIdx)
+                    if range.location != NSNotFound, let columnNameRange = Range(range, in: whereClause) {
+                        let columnName = String(whereClause[columnNameRange])
+                        columnNames.append(columnName)
+                    }
+                }
+            }
+
+            return columnNames
+
+        } catch {
+            let msg = "Error creating regular expression: " +
+                        "\(error.localizedDescription)"
+            throw UtilsSQLStatementError.extractColumnNames(message: msg)
+        }
+    }
+           
+    // MARK: - flattenMultilineString
+    
+    class func flattenMultilineString(_ input: String) -> String {
+        let lines = input
+            .components(separatedBy: CharacterSet.newlines)
+        return lines.joined(separator: " ")
+    }
+
+    // MARK: - getStmtAndRetColNames
+
+    class func getStmtAndRetColNames(sqlStmt: String, retMode: String)
+                                                -> [String: String] {
+        let retWord = "RETURNING"
+
+        var retStmtNames: [String: String] = [:]
+        retStmtNames["stmt"] = sqlStmt
+        retStmtNames["names"] = ""
+        if let range = sqlStmt.uppercased().range(of: retWord) {
+            let prefix = sqlStmt.prefix(upTo: range.lowerBound)
+            retStmtNames["stmt"] = "\(prefix);"
+            retStmtNames["names"] = ""
+            if retMode.prefix(2) == "wA" {
+                let suffix = sqlStmt.suffix(from: range.upperBound)
+                let names =
+                    "\(suffix)".trimmingLeadingAndTrailingSpaces()
+                if names.suffix(1) == ";" {
+                    retStmtNames["names"] = String(names.dropLast())
+                }
+            }
+
+        }
+        return retStmtNames
+    }
+
+    // MARK: - extractCombinedPrimaryKey
+
+    class func extractCombinedPrimaryKey(from whereClause: String)
+                                        -> [[String]]? {
+        // Regular expression pattern to match the combined primary
+        // key comparison with IN operator or without it
+        // meaning = operator
+        let pattern = #"WHERE\s*\((.+?)\)\s*(?:=|IN)\s*\((.+?)\)"#
+        
+        guard let regex = try? NSRegularExpression(pattern: pattern,
+                                                   options: []) else {
+            print("Invalid regular expression pattern.")
+            return nil
+        }
+        let range = NSRange(location: 0,
+                            length: whereClause.utf16.count)
+        let matches = regex.matches(in: whereClause, options: [],
+                                    range: range)
+        var primaryKeySets: [[String]] = []
+
+        for match in matches {
+            
+            let keysRange = Range(match.range(at: 1), in: whereClause)!
+            let keysString = String(whereClause[keysRange])
+            let keys = keysString.split(separator: ",").map {
+                String($0.trimmingCharacters(in: .whitespaces)) }
+            primaryKeySets.append(keys)
+        }
+        return primaryKeySets.isEmpty ? nil : primaryKeySets
+    }
+    
+    // MARK: - getWhereStatementForCombinedPK
+
+    class func getWhereStmtForCombinedPK(whStmt: String,
+                                         withRefs: [String],
+                                         colNames: [String],
+                                         keys: [[String]])
+                                                    -> String {
+        var retWhere: String = whStmt
+        var repKeys: [String] = []
+        for grpKeys in keys {
+            if grpKeys == withRefs {
+                repKeys = colNames
+            } else {
+                repKeys = withRefs
+            }
+            for (index, key) in grpKeys.enumerated() {
+                retWhere = replaceAllString(originalStr: retWhere,
+                                            searchStr: key,
+                                            replaceStr: repKeys[index])
+            }
+        }
+        return retWhere
+    }
+    
+    // MARK: - replaceAllString
+
+    class func replaceAllString(originalStr: String, searchStr: String,
+                                replaceStr: String) -> String {
+        let modifiedStr = originalStr
+                .replacingOccurrences(of: searchStr, with: replaceStr)
+        return modifiedStr
+    }
+    
+    // MARK: - replaceString
+    
+    class func replaceString(originalStr: String, searchStr: String,
+                             replaceStr: String) -> String {
+        var modifiedStr = originalStr
+        if let range = originalStr.range(of: searchStr) {
+            modifiedStr.replaceSubrange(range, with: replaceStr)
+        }
+        return modifiedStr
+    }
+    
+    // MARK: - getWhereStmtForNonCombinedPK
+
+    class func getWhereStmtForNonCombinedPK(whStmt: String,
+                                            withRefs: [String],
+                                            colNames: [String])
+                                                    -> String {
+        var whereStmt = ""
+        var stmt: String = String(whStmt.stringRange(
+                                    fromIdx: 6,
+                                    toIdx: whStmt.count))
+        for (idx, wRf) in withRefs.enumerated() {
+            var colType: String = "withRefsNames"
+            var idxs: [Int] = stmt.indicesOf(string: wRf)
+            if idxs.count == 0 {
+                idxs = stmt.indicesOf(string: colNames[idx])
+                colType = "colNames"
+            }
+            if idxs.count > 0 {
+                var valStr: String = ""
+                let indicesEqual: [Int] = stmt
+                    .indicesOf(string: "=",
+                               fromIdx: idxs[0])
+                
+                if indicesEqual.count > 0 {
+                    let indicesAnd: [Int] = stmt
+                        .indicesOf(string: "AND",
+                                   fromIdx: indicesEqual[0])
+                    if indicesAnd.count > 0 {
+                        valStr = String(stmt.stringRange(
+                            fromIdx: indicesEqual[0] + 1,
+                            toIdx: indicesAnd[0] - 1))
+                        stmt = String(stmt.stringRange(
+                            fromIdx: indicesAnd[0] + 3,
+                            toIdx: stmt.count))
+                    } else {
+                        valStr = String(stmt.stringRange(
+                            fromIdx: indicesEqual[0] + 1,
+                            toIdx: stmt.count))
+                    }
+                    if idx > 0 {
+                        whereStmt += " AND "
+                    }
+                    if colType == "withRefsNames" {
+                        whereStmt += colNames[idx] + " = " + valStr
+                    } else {
+                        whereStmt += withRefs[idx] + " = " + valStr
+                    }
+                }
+            }
+        }
+        whereStmt = "WHERE " + whereStmt
+        return whereStmt
+    }
+    
+    // MARK: - updateWhere
+    
+    class func updateWhere(whStmt: String, withRefs: [String],
+                           colNames: [String]) -> String {
+        var whereStmt = ""
+        if whStmt.count <= 0 {
+            return whereStmt
+        }
+        if whStmt.uppercased().prefix(5) != "WHERE" {
+            return whereStmt
+        }
+        if withRefs.count == colNames.count {
+            // get whereStmt for primary combined key
+            if let keys: [[String]] = UtilsSQLStatement
+                .extractCombinedPrimaryKey(from: whStmt) {
+                whereStmt = UtilsSQLStatement
+                    .getWhereStmtForCombinedPK(whStmt: whStmt,
+                                               withRefs: withRefs,
+                                               colNames: colNames,
+                                               keys: keys)
+            } else {
+                // get for non primary combined key
+                whereStmt = UtilsSQLStatement
+                    .getWhereStmtForNonCombinedPK(whStmt: whStmt,
+                                                  withRefs: withRefs,
+                                                  colNames: colNames)
+            }
+        }
+        return whereStmt
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "5.0.5",
+  "version": "5.0.7-1",
   "description": "Community plugin for native & electron SQLite databases",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -95,6 +95,6 @@
     }
   },
   "dependencies": {
-    "jeep-sqlite": "^2.3.8"
+    "jeep-sqlite": "^2.4.1"
   }
 }

package/src/definitions.ts

@@ -120,6 +120,20 @@ export interface CapacitorSQLitePlugin {
    * @since 0.0.1
    */
   close(options: capSQLiteOptions): Promise<void>;
+  /**
+   * Load a SQlite extension
+   * @param options :capSQLiteExtensionPath
+   * @returns Promise<void>
+   * @since 5.0.6
+   */
+  //  loadExtension(options: capSQLiteExtensionPath): Promise<void>;
+  /**
+   * Enable Or Disable Extension Loading
+   * @param options
+   * @returns Promise<void>
+   * @since 5.0.6
+   */
+  //  enableLoadExtension(options: capSQLiteExtensionEnable): Promise<void>;
   /**
    * GetUrl get the database Url
    * @param options: capSQLiteOptions
@@ -391,6 +405,38 @@ export interface capEchoOptions {
    */
   value?: string;
 }
+export interface capSQLiteExtensionPath {
+  /**
+   * The database name
+   */
+  database?: string;
+  /**
+   * The extension path
+   */
+  path?: string;
+  /**
+   * ReadOnly / ReadWrite
+   * default ReadWrite (false)
+   * @since 4.1.0-7
+   */
+  readonly?: boolean;
+}
+export interface capSQLiteExtensionEnable {
+  /**
+   * The database name
+   */
+  database?: string;
+  /**
+   * The enabling toggle (1: ON, 0: OFF)
+   */
+  toggle?: boolean;
+  /**
+   * ReadOnly / ReadWrite
+   * default ReadWrite (false)
+   * @since 4.1.0-7
+   */
+  readonly?: boolean;
+}
 export interface capConnectionOptions {
   /**
    * The database name
@@ -436,6 +482,7 @@ export interface capSQLiteOptions {
    */
   readonly?: boolean;
 }
+
 export interface capNCDatabasePathOptions {
   /**
    * the database path
@@ -769,6 +816,12 @@ export interface capSQLiteSyncDate {
 }
 
 /* JSON Types */
+export interface EncryptJson {
+  /**
+   * The encrypted JsonSQLite base64 string
+   */
+  expData: string;
+}
 export interface JsonSQLite {
   /**
    * The database name
@@ -1699,6 +1752,20 @@ export interface ISQLiteDBConnection {
    * @since 3.2.0
    */
   getVersion(): Promise<capVersionResult>;
+  /**
+   * Load a SQlite extension
+   * @param path :SQlite extension path
+   * @returns Promise<void>
+   * @since 5.0.6
+   */
+  loadExtension(path: string): Promise<void>;
+  /**
+   * Enable Or Disable Extension Loading
+   * @param toggle true:on false:off
+   * @returns Promise<void>
+   * @since 5.0.6
+   */
+  enableLoadExtension(toggle: boolean): Promise<void>;
   /**
    * Execute SQLite DB Connection Statements
    * @param statements
@@ -1849,6 +1916,43 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
       return Promise.reject(err);
     }
   }
+
+  async loadExtension(path: string): Promise<void> {
+    try {
+      console.log(`database: ${this.dbName}`);
+      console.log(`readonly: ${this.readonly}}`);
+      console.log(`path: ${path}}`);
+      await this.sqlite.loadExtension({
+        database: this.dbName,
+        path: path,
+        readonly: this.readonly,
+      });
+      console.log(`loadExtension successful`);
+      return Promise.resolve();
+    } catch (err) {
+      console.log(`loadExtension failed `);
+      return Promise.reject(err);
+    }
+  }
+  async enableLoadExtension(toggle: boolean): Promise<void> {
+    try {
+      console.log(`database: ${this.dbName}`);
+      console.log(`readonly: ${this.readonly}`);
+      console.log(`toggle: ${toggle}`);
+      await this.sqlite.enableLoadExtension({
+        database: this.dbName,
+        toggle: toggle,
+        readonly: this.readonly,
+      });
+      console.log(`enableLoadExtension successful`);
+      return Promise.resolve();
+    } catch (err) {
+      console.log(err);
+      console.log(`enableLoadExtension failed `);
+      return Promise.reject(err);
+    }
+  }
+
   async getUrl(): Promise<capSQLiteUrl> {
     try {
       const res: capSQLiteUrl = await this.sqlite.getUrl({

package/src/web.ts

@@ -32,6 +32,8 @@ import type {
   capSQLiteUrl,
   capSQLiteValues,
   capVersionResult,
+  capSQLiteExtensionPath,
+  capSQLiteExtensionEnable,
 } from './definitions';
 
 export class CapacitorSQLiteWeb
@@ -591,4 +593,12 @@ export class CapacitorSQLiteWeb
   async isInConfigBiometricAuth(): Promise<capSQLiteResult> {
     throw this.unimplemented('Not implemented on web.');
   }
+  async loadExtension(options: capSQLiteExtensionPath): Promise<void> {
+    console.log('loadExtension', options);
+    throw this.unimplemented('Not implemented on web.');
+  }
+  async enableLoadExtension(options: capSQLiteExtensionEnable): Promise<void> {
+    console.log('enableLoadExtension', options);
+    throw this.unimplemented('Not implemented on web.');
+  }
 }