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

package/electron/dist/plugin.js

@@ -9,9 +9,9 @@ var require$$3 = require('node-fetch');
 var require$$4 = require('os');
 var require$$5 = require('jszip');
 var require$$6 = require('electron');
-var require$$1$1 = require('better-sqlite3-multiple-ciphers');
-var require$$3$1 = require('electron-json-storage');
-var require$$1$2 = require('crypto');
+var require$$3$1 = require('better-sqlite3-multiple-ciphers');
+var require$$3$2 = require('electron-json-storage');
+var require$$1$1 = require('crypto');
 var require$$2$1 = require('crypto-js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -23,9 +23,9 @@ var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3);
 var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
 var require$$5__default = /*#__PURE__*/_interopDefaultLegacy(require$$5);
 var require$$6__default = /*#__PURE__*/_interopDefaultLegacy(require$$6);
-var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 var require$$3__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$3$1);
-var require$$1__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$1$2);
+var require$$3__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$3$2);
+var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 var require$$2__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$2$1);
 
 var src = {};
@@ -48,6 +48,131 @@ var exportToJson = {};
 
 var utilsSQLite = {};
 
+var utilsDelete = {};
+
+Object.defineProperty(utilsDelete, "__esModule", { value: true });
+utilsDelete.UtilsDelete = void 0;
+class UtilsDeleteError {
+    constructor(message) {
+        this.message = message;
+    }
+    static upDateWhereForDefault(message) {
+        return new UtilsDeleteError(message);
+    }
+    static upDateWhereForRestrict(message) {
+        return new UtilsDeleteError(message);
+    }
+    static upDateWhereForCascade(message) {
+        return new UtilsDeleteError(message);
+    }
+    static executeUpdateForDelete(message) {
+        return new UtilsDeleteError(message);
+    }
+}
+class UtilsDelete {
+    getReferencedTableName(refValue) {
+        let tableName = '';
+        if (refValue.length > 0) {
+            const arr = refValue.split(new RegExp('REFERENCES', 'i'));
+            if (arr.length === 2) {
+                const oPar = arr[1].indexOf("(");
+                tableName = arr[1].substring(0, oPar).trim();
+            }
+        }
+        return tableName;
+    }
+    upDateWhereForDefault(withRefsNames, results) {
+        let setStmt = '';
+        let uWhereStmt = '';
+        try {
+            const key = results.key;
+            const cols = [];
+            for (const relItem of results.relatedItems) {
+                const mVal = relItem[key];
+                if (mVal !== undefined) {
+                    cols.push(mVal);
+                }
+            }
+            // Create the set statement
+            for (const name of withRefsNames) {
+                setStmt += `${name} = NULL, `;
+            }
+            setStmt += 'sql_deleted = 0';
+            // Create the where statement
+            uWhereStmt = `WHERE ${key} IN (`;
+            for (const col of cols) {
+                uWhereStmt += `${col},`;
+            }
+            if (uWhereStmt.endsWith(',')) {
+                uWhereStmt = uWhereStmt.slice(0, -1);
+            }
+            uWhereStmt += ');';
+        }
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw UtilsDeleteError.upDateWhereForDefault(msg);
+        }
+        return { setStmt, uWhereStmt };
+    }
+    upDateWhereForRestrict(results) {
+        try {
+            const setStmt = '';
+            const uWhereStmt = '';
+            if (results.relatedItems.length > 0) {
+                const msg = 'Restrict mode related items exist, please delete them first';
+                throw UtilsDeleteError.upDateWhereForRestrict(msg);
+            }
+            return { setStmt, uWhereStmt };
+        }
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw UtilsDeleteError.upDateWhereForRestrict(msg);
+        }
+    }
+    upDateWhereForCascade(results) {
+        let setStmt = '';
+        let uWhereStmt = '';
+        try {
+            const key = results.key;
+            const cols = [];
+            for (const relItem of results.relatedItems) {
+                const mVal = relItem[key];
+                if (mVal !== undefined) {
+                    cols.push(mVal);
+                }
+            }
+            setStmt += 'sql_deleted = 1';
+            // Create the where statement
+            uWhereStmt = `WHERE ${key} IN (`;
+            for (const col of cols) {
+                uWhereStmt += `${col},`;
+            }
+            if (uWhereStmt.endsWith(',')) {
+                uWhereStmt = uWhereStmt.slice(0, -1);
+            }
+            uWhereStmt += ');';
+        }
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw UtilsDeleteError.upDateWhereForCascade(msg);
+        }
+        return { setStmt, uWhereStmt };
+    }
+    getCurrentTimeAsInteger() {
+        const currentTime = Math.floor(Date.now() / 1000);
+        return currentTime;
+    }
+    checkValuesMatch(array1, array2) {
+        for (const value of array1) {
+            if (!array2.includes(value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+utilsDelete.UtilsDelete = UtilsDelete;
+
 var utilsFile = {};
 
 Object.defineProperty(utilsFile, "__esModule", { value: true });
@@ -653,14 +778,259 @@ class UtilsFile {
 }
 utilsFile.UtilsFile = UtilsFile;
 
+var utilsSqlstatement = {};
+
+Object.defineProperty(utilsSqlstatement, "__esModule", { value: true });
+utilsSqlstatement.UtilsSQLStatement = void 0;
+class UtilsSQLStatement {
+    constructor() {
+        this.replaceString = (originalStr, searchStr, replaceStr) => {
+            const range = originalStr.indexOf(searchStr);
+            if (range !== -1) {
+                const modifiedStr = originalStr.substring(0, range) + replaceStr + originalStr.substring(range + searchStr.length);
+                return modifiedStr;
+            }
+            return originalStr;
+        };
+    }
+    extractTableName(statement) {
+        const pattern = /(?:INSERT\s+INTO|UPDATE|DELETE\s+FROM)\s+([^\s]+)/i;
+        const match = statement.match(pattern);
+        if (match?.[1]) {
+            const tableName = match[1];
+            return tableName;
+        }
+        return null;
+    }
+    extractWhereClause(statement) {
+        const pattern = /WHERE(.+?)(?:ORDER\s+BY|LIMIT|$)/i;
+        const match = statement.match(pattern);
+        if (match?.[1]) {
+            const whereClause = match[1].trim();
+            return whereClause;
+        }
+        return null;
+    }
+    addPrefixToWhereClause(whereClause, colNames, refNames, prefix) {
+        let columnValuePairs;
+        if (whereClause.includes("AND")) {
+            // Split the WHERE clause based on the "AND" keyword
+            const subSequenceArray = whereClause.split("AND");
+            console.log(" whereClause", whereClause);
+            console.log(" subSequenceArray", subSequenceArray);
+            columnValuePairs = subSequenceArray.map((pair) => pair.trim());
+        }
+        else {
+            columnValuePairs = [whereClause];
+        }
+        console.log(" columnValuePairs", columnValuePairs);
+        const modifiedPairs = columnValuePairs.map((pair) => {
+            const match = pair.match(/(\w+)\s*(=|IN|BETWEEN|LIKE)\s*(.+)/);
+            if (!match) {
+                return pair;
+            }
+            const column = match[1].trim();
+            const operator = match[2].trim();
+            const value = match[3].trim();
+            let newColumn = column;
+            const index = this.findIndexOfStringInArray(column, refNames);
+            if (index !== -1) {
+                newColumn = this.getStringAtIndex(colNames, index);
+            }
+            const modifiedColumn = `${prefix}${newColumn}`;
+            const ret = `${modifiedColumn} ${operator} ${value}`;
+            return ret;
+        });
+        return modifiedPairs.join(" AND ");
+    }
+    findIndexOfStringInArray(target, array) {
+        return array.indexOf(target);
+    }
+    getStringAtIndex(array, index) {
+        if (index >= 0 && index < array.length) {
+            return array[index];
+        }
+        else {
+            return undefined;
+        }
+    }
+    extractForeignKeyInfo(sqlStatement) {
+        // Define the regular expression pattern for extracting the FOREIGN KEY clause
+        const 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))?/;
+        const matches = sqlStatement.match(foreignKeyPattern);
+        if (matches) {
+            const foreignKeyInfo = {
+                forKeys: matches[1].split(",").map(key => key.trim()),
+                tableName: matches[2],
+                refKeys: matches[3].split(",").map(key => key.trim()),
+                action: matches[5] ? matches[5] : "NO ACTION"
+            };
+            return foreignKeyInfo;
+        }
+        else {
+            throw new Error("extractForeignKeyInfo: No FOREIGN KEY found");
+        }
+    }
+    extractColumnNames(whereClause) {
+        const regex = /\b(\w+)\s*(?=[=<>])|(?<=\()\s*(\w+),\s*(\w+)\s*(?=\))|(?<=\bIN\s*\(VALUES\s*\().*?(?=\))|(?<=\bIN\s*\().*?(?=\))|(?<=\bBETWEEN\s*).*?(?=\bAND\b)|(?<=\bLIKE\s*')\w+|\bAND\b/g;
+        const matches = whereClause.matchAll(regex);
+        const columnNames = [];
+        let andGroup = [];
+        for (const match of matches) {
+            if (match[0] === 'AND') {
+                columnNames.push(...andGroup);
+                andGroup = [];
+            }
+            else if (match[1]) {
+                andGroup.push(match[1]);
+            }
+            else if (match[2] && match[3]) {
+                andGroup.push(match[2]);
+                andGroup.push(match[3]);
+            }
+            else if (match[0]) {
+                const values = match[0]
+                    .replace(/[()']/g, '') // Remove parentheses and single quotes
+                    .split(',')
+                    .map(value => value.trim());
+                andGroup.push(...values);
+            }
+        }
+        columnNames.push(...andGroup);
+        return columnNames;
+    }
+    flattenMultilineString(input) {
+        const lines = input.split(/\r?\n/);
+        return lines.join(" ");
+    }
+    getStmtAndRetColNames(sqlStmt, retMode) {
+        const retWord = "RETURNING";
+        const retStmtNames = { stmt: sqlStmt, names: "" };
+        const retWordIndex = sqlStmt.toUpperCase().indexOf(retWord);
+        if (retWordIndex !== -1) {
+            const prefix = sqlStmt.substring(0, retWordIndex);
+            retStmtNames.stmt = `${prefix};`;
+            if (retMode.substring(0, 2) === "wA") {
+                const suffix = sqlStmt.substring(retWordIndex + retWord.length);
+                const names = suffix.trim();
+                if (names.endsWith(";")) {
+                    retStmtNames.names = names.substring(0, names.length - 1);
+                }
+                else {
+                    retStmtNames.names = names;
+                }
+            }
+        }
+        return retStmtNames;
+    }
+    extractCombinedPrimaryKey(whereClause) {
+        const pattern = /WHERE\s*\((.+?)\)\s*(?:=|IN)\s*\((.+?)\)/g;
+        const regex = new RegExp(pattern);
+        const matches = whereClause.matchAll(regex);
+        const primaryKeySets = [];
+        for (const match of matches) {
+            const keysString = match[1].trim();
+            const keys = keysString.split(",").map((key) => key.trim());
+            primaryKeySets.push(keys);
+        }
+        return primaryKeySets.length === 0 ? null : primaryKeySets;
+    }
+    getWhereStmtForCombinedPK(whStmt, withRefs, colNames, keys) {
+        let retWhere = whStmt;
+        for (const grpKeys of keys) {
+            const repKeys = grpKeys.join(",") === withRefs.join(",") ? colNames : withRefs;
+            for (const [index, key] of grpKeys.entries()) {
+                retWhere = this.replaceAllString(retWhere, key, repKeys[index]);
+            }
+        }
+        return retWhere;
+    }
+    replaceAllString(originalStr, searchStr, replaceStr) {
+        return originalStr.split(searchStr).join(replaceStr);
+    }
+    indicesOf(str, searchStr, fromIndex = 0) {
+        // Helper function to find indices of a substring within a string
+        const indices = [];
+        let currentIndex = str.indexOf(searchStr, fromIndex);
+        while (currentIndex !== -1) {
+            indices.push(currentIndex);
+            currentIndex = str.indexOf(searchStr, currentIndex + 1);
+        }
+        return indices;
+    }
+    getWhereStmtForNonCombinedPK(whStmt, withRefs, colNames) {
+        let whereStmt = "";
+        let stmt = whStmt.substring(6);
+        for (let idx = 0; idx < withRefs.length; idx++) {
+            let colType = "withRefsNames";
+            let idxs = this.indicesOf(stmt, withRefs[idx]);
+            if (idxs.length === 0) {
+                idxs = this.indicesOf(stmt, colNames[idx]);
+                colType = "colNames";
+            }
+            if (idxs.length > 0) {
+                let valStr = "";
+                const indicesEqual = this.indicesOf(stmt, "=", idxs[0]);
+                if (indicesEqual.length > 0) {
+                    const indicesAnd = this.indicesOf(stmt, "AND", indicesEqual[0]);
+                    if (indicesAnd.length > 0) {
+                        valStr = stmt.substring(indicesEqual[0] + 1, indicesAnd[0] - 1);
+                        stmt = stmt.substring(indicesAnd[0] + 3);
+                    }
+                    else {
+                        valStr = stmt.substring(indicesEqual[0] + 1);
+                    }
+                    if (idx > 0) {
+                        whereStmt += " AND ";
+                    }
+                    if (colType === "withRefsNames") {
+                        whereStmt += colNames[idx] + " = " + valStr;
+                    }
+                    else {
+                        whereStmt += withRefs[idx] + " = " + valStr;
+                    }
+                }
+            }
+        }
+        whereStmt = "WHERE " + whereStmt;
+        return whereStmt;
+    }
+    updateWhere(whStmt, withRefs, colNames) {
+        let whereStmt = "";
+        if (whStmt.length <= 0) {
+            return whereStmt;
+        }
+        if (whStmt.toUpperCase().substring(0, 5) !== "WHERE") {
+            return whereStmt;
+        }
+        if (withRefs.length === colNames.length) {
+            // get whereStmt for primary combined key
+            const keys = this.extractCombinedPrimaryKey(whStmt);
+            if (keys) {
+                whereStmt = this.getWhereStmtForCombinedPK(whStmt, withRefs, colNames, keys);
+            }
+            else {
+                // get for non primary combined key
+                whereStmt = this.getWhereStmtForNonCombinedPK(whStmt, withRefs, colNames);
+            }
+        }
+        return whereStmt;
+    }
+}
+utilsSqlstatement.UtilsSQLStatement = UtilsSQLStatement;
+
 Object.defineProperty(utilsSQLite, "__esModule", { value: true });
 utilsSQLite.UtilsSQLite = void 0;
+const utilsDelete_1 = utilsDelete;
 const utilsFile_1$4 = utilsFile;
+const utilsSqlstatement_1 = utilsSqlstatement;
 //const SQLITE_OPEN_READONLY = 1;
 class UtilsSQLite {
     constructor() {
         this.fileUtil = new utilsFile_1$4.UtilsFile();
-        this.BCSQLite3 = require$$1__default$1["default"];
+        this.statUtil = new utilsSqlstatement_1.UtilsSQLStatement();
+        this.delUtil = new utilsDelete_1.UtilsDelete();
+        this.BCSQLite3 = require$$3__default$1["default"];
     }
     /**
      * OpenOrCreateDatabase
@@ -1229,17 +1599,39 @@ class UtilsSQLite {
         try {
             const isLast = this.isLastModified(mDB, true);
             const isDel = this.isSqlDeleted(mDB, true);
-            if (isLast && isDel) {
-                // Replace DELETE by UPDATE and set sql_deleted to 1
-                const wIdx = statement.toUpperCase().indexOf('WHERE');
-                const preStmt = statement.substring(0, wIdx - 1);
-                const clauseStmt = statement.substring(wIdx, statement.length);
-                const tableName = preStmt
-                    .substring('DELETE FROM'.length)
-                    .trim();
-                sqlStmt = `UPDATE ${tableName} SET sql_deleted = 1 ${clauseStmt}`;
-                // Find REFERENCES if any and update the sql_deleted column
-                this.findReferencesAndUpdate(mDB, tableName, clauseStmt, values);
+            if (!isLast || !isDel) {
+                return sqlStmt;
+            }
+            // Replace DELETE by UPDATE
+            // set sql_deleted to 1 and the last_modified to
+            // timenow
+            const whereClause = this.statUtil.extractWhereClause(sqlStmt);
+            if (!whereClause) {
+                const msg = 'deleteSQL: cannot find a WHERE clause';
+                throw new Error(`${msg}`);
+            }
+            const tableName = this.statUtil.extractTableName(sqlStmt);
+            if (!tableName) {
+                const msg = 'deleteSQL: cannot find a WHERE clause';
+                throw new Error(`${msg}`);
+            }
+            const colNames = this.statUtil.extractColumnNames(whereClause);
+            if (colNames.length === 0) {
+                const msg = 'deleteSQL: Did not find column names in the WHERE Statement';
+                throw new Error(`${msg}`);
+            }
+            const setStmt = 'sql_deleted = 1';
+            // Find REFERENCES if any and update the sql_deleted
+            // column
+            const hasToUpdate = this.findReferencesAndUpdate(mDB, tableName, whereClause, colNames, values);
+            if (hasToUpdate) {
+                const whereStmt = whereClause.endsWith(';')
+                    ? whereClause.slice(0, -1)
+                    : whereClause;
+                sqlStmt = `UPDATE ${tableName} SET ${setStmt} WHERE ${whereStmt} AND sql_deleted = 0;`;
+            }
+            else {
+                sqlStmt = '';
             }
             return sqlStmt;
         }
@@ -1253,192 +1645,183 @@ class UtilsSQLite {
      * @param mDB
      * @param tableName
      * @param whereStmt
+     * @param initColNames
      * @param values
      * @returns
      */
-    findReferencesAndUpdate(mDB, tableName, whereStmt, values) {
-        const msg = 'FindReferencesAndUpdate';
+    findReferencesAndUpdate(mDB, tableName, whereStmt, initColNames, values) {
         try {
-            const references = this.getReferences(mDB, tableName);
+            const retBool = true;
+            const result = this.getReferences(mDB, tableName);
+            const references = result.retRefs;
+            const tableNameWithRefs = result.tableWithRefs;
             if (references.length <= 0) {
-                return;
-            }
-            const tableNameWithRefs = references.pop();
-            for (const refe of references) {
-                // get the tableName of the reference
-                const refTable = this.getReferenceTableName(refe);
-                if (refTable.length <= 0) {
-                    continue;
-                }
-                // get the with references columnName
-                const withRefsNames = this.getWithRefsColumnName(refe);
-                if (withRefsNames.length <= 0) {
+                return retBool;
+            }
+            if (tableName === tableNameWithRefs) {
+                return retBool;
+            }
+            // Loop through references
+            for (const ref of references) {
+                // Extract the FOREIGN KEY constraint info from the ref statement
+                const foreignKeyInfo = this.statUtil.extractForeignKeyInfo(ref);
+                // Get the tableName of the references
+                const refTable = foreignKeyInfo.tableName;
+                if (refTable === '' || refTable !== tableName) {
                     continue;
                 }
-                // get the referenced columnName
-                const colNames = this.getReferencedColumnName(refe);
-                if (colNames.length <= 0) {
-                    continue;
+                // Get the with ref column names
+                const withRefsNames = foreignKeyInfo.forKeys;
+                // Get the column names
+                const colNames = foreignKeyInfo.refKeys;
+                if (colNames.length !== withRefsNames.length) {
+                    const msg = "findReferencesAndUpdate: mismatch length";
+                    throw new Error(msg);
                 }
-                // update the where clause
-                const uWhereStmt = this.updateWhere(whereStmt, withRefsNames, colNames);
-                if (uWhereStmt.length <= 0) {
+                const action = foreignKeyInfo.action;
+                if (action === 'NO_ACTION') {
                     continue;
                 }
-                let updTableName = tableNameWithRefs;
-                let updColNames = colNames;
-                if (tableNameWithRefs === tableName) {
-                    updTableName = refTable;
-                    updColNames = withRefsNames;
-                }
-                //update sql_deleted for this reference
-                const stmt = 'UPDATE ' + updTableName + ' SET sql_deleted = 1 ' + uWhereStmt;
-                const selValues = [];
-                if (values.length > 0) {
-                    const mVal = this.replaceUndefinedByNull(values);
-                    let arrVal = whereStmt.split('?');
-                    if (arrVal[arrVal.length - 1] === ';')
-                        arrVal = arrVal.slice(0, -1);
-                    for (const [j, val] of arrVal.entries()) {
-                        for (const updVal of updColNames) {
-                            const idxVal = val.indexOf(updVal);
-                            if (idxVal > -1) {
-                                selValues.push(mVal[j]);
-                            }
+                const updTableName = tableNameWithRefs;
+                const updColNames = withRefsNames;
+                let results = {
+                    uWhereStmt: '',
+                    setStmt: '',
+                };
+                if (!this.delUtil.checkValuesMatch(withRefsNames, initColNames)) {
+                    // Case: no match
+                    // Search for related items in tableName
+                    const result = this.searchForRelatedItems(mDB, updTableName, tableName, whereStmt, withRefsNames, colNames, values);
+                    if (result.relatedItems.length === 0 && result.key.length <= 0) {
+                        continue;
+                    }
+                    if (updTableName !== tableName) {
+                        switch (action) {
+                            case 'RESTRICT':
+                                results = this.delUtil.upDateWhereForRestrict(result);
+                                break;
+                            case 'CASCADE':
+                                results = this.delUtil.upDateWhereForCascade(result);
+                                break;
+                            default:
+                                results = this.delUtil.upDateWhereForDefault(withRefsNames, result);
+                                break;
                         }
                     }
                 }
-                const ret = this.runExec(mDB, stmt, selValues, 'no');
-                const lastId = ret.lastInsertRowid;
-                if (lastId == -1) {
-                    const msg = `UPDATE sql_deleted failed for references table: ${refTable}`;
-                    throw new Error(`findReferencesAndUpdate: ${msg}`);
+                else {
+                    throw new Error('Not implemented. Please transfer your example to the maintener');
+                }
+                if (results.setStmt.length > 0 &&
+                    results.uWhereStmt.length > 0) {
+                    this.executeUpdateForDelete(mDB, updTableName, results.uWhereStmt, results.setStmt, updColNames, values);
                 }
             }
-            return;
+            return retBool;
         }
-        catch (err) {
-            const errmsg = err.message ? err.message : err;
-            throw new Error(`${msg} ${errmsg}`);
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw new Error(msg);
         }
     }
-    getReferenceTableName(refValue) {
-        let tableName = '';
-        if (refValue.length > 0) {
-            const arr = refValue.split(new RegExp('REFERENCES', 'i'));
-            if (arr.length === 2) {
-                const oPar = arr[1].indexOf('(');
-                tableName = arr[1].substring(0, oPar).trim();
+    /**
+     * getReferences
+     * @param db
+     * @param tableName
+     * @returns
+     */
+    getReferences(db, tableName) {
+        const sqlStmt = "SELECT sql FROM sqlite_master " +
+            "WHERE sql LIKE('%FOREIGN KEY%') AND sql LIKE('%REFERENCES%') AND " +
+            "sql LIKE('%" + tableName + "%') AND sql LIKE('%ON DELETE%');";
+        try {
+            const res = this.queryAll(db, sqlStmt, []);
+            // get the reference's string(s)
+            let retRefs = [];
+            let tableWithRefs = "";
+            if (res.length > 0) {
+                const result = this.getRefs(res[0].sql);
+                retRefs = result.foreignKeys;
+                tableWithRefs = result.tableName;
             }
+            return { tableWithRefs: tableWithRefs, retRefs: retRefs };
+        }
+        catch (err) {
+            const error = err.message ? err.message : err;
+            const msg = `getReferences: ${error}`;
+            throw new Error(msg);
         }
-        return tableName;
     }
-    getReferencedColumnName(refValue) {
-        let colNames = [];
-        if (refValue.length > 0) {
-            const arr = refValue.split(new RegExp('REFERENCES', 'i'));
-            if (arr.length === 2) {
-                const oPar = arr[1].indexOf('(');
-                const cPar = arr[1].indexOf(')');
-                const colStr = arr[1].substring(oPar + 1, cPar).trim();
-                colNames = colStr.split(',');
+    /**
+     * getRefs
+     * @param sqlStatement
+     * @returns
+     */
+    getRefs(sqlStatement) {
+        let tableName = '';
+        const foreignKeys = [];
+        const statement = this.statUtil.flattenMultilineString(sqlStatement);
+        try {
+            // Regular expression pattern to match the table name
+            const tableNamePattern = /CREATE\s+TABLE\s+(\w+)\s+\(/;
+            const tableNameMatch = statement.match(tableNamePattern);
+            if (tableNameMatch) {
+                tableName = tableNameMatch[1];
             }
+            // Regular expression pattern to match the FOREIGN KEY constraints
+            const foreignKeyPattern = /FOREIGN\s+KEY\s+\([^)]+\)\s+REFERENCES\s+(\w+)\s*\([^)]+\)\s+ON\s+DELETE\s+(CASCADE|RESTRICT|SET\s+DEFAULT|SET\s+NULL|NO\s+ACTION)/g;
+            const foreignKeyMatches = statement.matchAll(foreignKeyPattern);
+            for (const foreignKeyMatch of foreignKeyMatches) {
+                const foreignKey = foreignKeyMatch[0];
+                foreignKeys.push(foreignKey);
+            }
+        }
+        catch (error) {
+            const msg = `getRefs: Error creating regular expression: ${error}`;
+            throw new Error(msg);
         }
-        return colNames;
+        return { tableName, foreignKeys };
     }
-    getWithRefsColumnName(refValue) {
-        let colNames = [];
-        if (refValue.length > 0) {
-            const arr = refValue.split(new RegExp('REFERENCES', 'i'));
-            if (arr.length === 2) {
-                const oPar = arr[0].indexOf('(');
-                const cPar = arr[0].indexOf(')');
-                const colStr = arr[0].substring(oPar + 1, cPar).trim();
-                colNames = colStr.split(',');
-            }
-        }
-        return colNames;
-    }
-    updateWhere(whStmt, withRefsNames, colNames) {
-        let whereStmt = '';
-        if (whStmt.length > 0) {
-            const index = whStmt.toLowerCase().indexOf('WHERE'.toLowerCase());
-            const stmt = whStmt.substring(index + 6);
-            if (withRefsNames.length === colNames.length) {
-                for (let i = 0; i < withRefsNames.length; i++) {
-                    let colType = 'withRefsNames';
-                    let idx = stmt.indexOf(withRefsNames[i]);
-                    if (idx === -1) {
-                        idx = stmt.indexOf(colNames[i]);
-                        colType = 'colNames';
-                    }
-                    if (idx > -1) {
-                        let valStr = '';
-                        const fEqual = stmt.indexOf('=', idx);
-                        if (fEqual > -1) {
-                            const iAnd = stmt.indexOf('AND', fEqual);
-                            const ilAnd = stmt.indexOf('and', fEqual);
-                            if (iAnd > -1) {
-                                valStr = stmt.substring(fEqual + 1, iAnd - 1).trim();
-                            }
-                            else if (ilAnd > -1) {
-                                valStr = stmt.substring(fEqual + 1, ilAnd - 1).trim();
-                            }
-                            else {
-                                valStr = stmt.substring(fEqual + 1, stmt.length).trim();
-                            }
-                            if (i > 0) {
-                                whereStmt += ' AND ';
-                            }
-                            if (colType === 'withRefsNames') {
-                                whereStmt += `${colNames[i]} = ${valStr}`;
-                            }
-                            else {
-                                whereStmt += `${withRefsNames[i]} = ${valStr}`;
-                            }
+    /**
+     * executeUpdateForDelete
+     * @param mDB
+     * @param tableName
+     * @param whereStmt
+     * @param setStmt
+     * @param colNames
+     * @param values
+     */
+    executeUpdateForDelete(mDB, tableName, whereStmt, setStmt, colNames, values) {
+        try {
+            let lastId = -1;
+            // Update sql_deleted for this references
+            const stmt = `UPDATE ${tableName} SET ${setStmt} ${whereStmt}`;
+            const selValues = [];
+            if (values.length > 0) {
+                const arrVal = whereStmt.split('?');
+                if (arrVal[arrVal.length - 1] === ';') {
+                    arrVal.pop();
+                }
+                for (let jdx = 0; jdx < arrVal.length; jdx++) {
+                    for (const updVal of colNames) {
+                        const indices = this.statUtil.indicesOf(arrVal[jdx], updVal);
+                        if (indices.length > 0) {
+                            selValues.push(values[jdx]);
                         }
                     }
                 }
-                whereStmt = 'WHERE ' + whereStmt;
             }
-        }
-        return whereStmt;
-    }
-    getReferences(mDB, tableName) {
-        const msg = 'GetReferences';
-        const sqlStmt = 'SELECT sql FROM sqlite_master ' +
-            "WHERE sql LIKE('%FOREIGN KEY%') AND sql LIKE('%REFERENCES%') AND " +
-            "sql LIKE('%" +
-            tableName +
-            "%') AND sql LIKE('%ON DELETE%');";
-        try {
-            const res = this.queryAll(mDB, sqlStmt, []);
-            // get the reference's string(s)
-            let retRefs = [];
-            if (res.length > 0) {
-                retRefs = this.getRefs(res[0].sql);
+            const retObj = this.runExec(mDB, stmt, selValues, 'no');
+            lastId = retObj["lastInsertRowid"];
+            if (lastId === -1) {
+                const msg = `UPDATE sql_deleted failed for table: ${tableName}`;
+                throw new Error(msg);
             }
-            return retRefs;
-        }
-        catch (err) {
-            const errmsg = err.message ? err.message : err;
-            throw new Error(`${msg} ${errmsg}`);
-        }
-    }
-    getRefs(str) {
-        const retRefs = [];
-        const arrFor = str.split(new RegExp('FOREIGN KEY', 'i'));
-        // Loop through Foreign Keys
-        for (let i = 1; i < arrFor.length; i++) {
-            retRefs.push(arrFor[i].split(new RegExp('ON DELETE', 'i'))[0].trim());
         }
-        // find table name with references
-        if (str.substring(0, 12).toLowerCase() === 'CREATE TABLE'.toLowerCase()) {
-            const oPar = str.indexOf('(');
-            const tableName = str.substring(13, oPar).trim();
-            retRefs.push(tableName);
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw new Error(msg);
         }
-        return retRefs;
     }
     /**
      * QueryAll
@@ -1657,6 +2040,42 @@ class UtilsSQLite {
             throw new Error(`${msg} ${errmsg}`);
         }
     }
+    searchForRelatedItems(mDB, updTableName, tableName, whStmt, withRefsNames, colNames, values) {
+        const relatedItems = [];
+        let key = "";
+        const t1Names = withRefsNames.map((name) => `t1.${name}`);
+        const t2Names = colNames.map((name) => `t2.${name}`);
+        console.log(" whStmt ", whStmt);
+        console.log(" t1Names ", t1Names);
+        console.log(" t2Names ", t2Names);
+        try {
+            // addPrefix to the whereClause and swap colNames with  withRefsNames
+            let whereClause = this.statUtil
+                .addPrefixToWhereClause(whStmt, colNames, withRefsNames, "t2.");
+            // look at the whereclause and change colNames with  withRefsNames
+            if (whereClause.endsWith(";")) {
+                whereClause = whereClause.slice(0, -1);
+            }
+            console.log(" whereClause ", whereClause);
+            const resultString = t1Names
+                .map((t1, index) => `${t1} = ${t2Names[index]}`)
+                .join(" AND ");
+            const sql = `SELECT t1.rowid FROM ${updTableName} t1 ` +
+                `JOIN ${tableName} t2 ON ${resultString} ` +
+                `WHERE ${whereClause} AND t1.sql_deleted = 0;`;
+            console.log(" sql ", sql);
+            const vals = this.queryAll(mDB, sql, values);
+            if (vals.length > 0) {
+                key = (Object.keys(vals[0]))[0];
+                relatedItems.push(...vals);
+            }
+            return { key: key, relatedItems: relatedItems };
+        }
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw new Error(msg);
+        }
+    }
     cleanStatement(stmt) {
         let sql = '';
         if (stmt.toLowerCase().includes('INSERT INTO'.toLowerCase()) ||
@@ -3562,7 +3981,7 @@ class UtilsSecret {
         this.globalUtil = new GlobalSQLite_1$2.GlobalSQLite();
         this.sqliteUtil = new utilsSQLite_1$4.UtilsSQLite();
         this.fileUtil = new utilsFile_1$3.UtilsFile();
-        this.storage = require$$3__default$1["default"];
+        this.storage = require$$3__default$2["default"];
     }
     isSecretStored() {
         const secret = this.getPassphrase();
@@ -3689,7 +4108,7 @@ class UtilsJsonEncryption {
     constructor() {
         this.fileSecret = new utilsSecret_1$2.UtilsSecret();
         this.SALT = 'jeep_capacitor_sqlite';
-        this.Crypto = require$$1__default$2["default"];
+        this.Crypto = require$$1__default$1["default"];
         this.CryptoJS = require$$2__default$1["default"];
     }
     /**
@@ -4391,9 +4810,9 @@ class CapacitorSQLite {
         this.versionUpgrades = {};
         this.databases = {};
         this.fileUtil = new utilsFile_1.UtilsFile();
+        this.sqliteUtil = new utilsSQLite_1.UtilsSQLite();
         this.jsonUtil = new utilsJson_1.UtilsJson();
         this.jsonEncryptUtil = new utilsJsonEncryption_1.UtilsJsonEncryption();
-        this.sqliteUtil = new utilsSQLite_1.UtilsSQLite();
         this.secretUtil = new utilsSecret_1.UtilsSecret();
         this.globalUtil = new GlobalSQLite_1.GlobalSQLite();
         this.isEncryption = this.fileUtil.getIsEncryption();