@capacitor-community/sqlite 3.5.2-dev1 → 4.0.0-0

package/electron/dist/plugin.js

@@ -342,7 +342,9 @@ class UtilsSQLite {
                     if (trimStmt === 'DELETE FROM' &&
                         stmt.toLowerCase().includes('WHERE'.toLowerCase())) {
                         const whereStmt = `${stmt.trim()};`;
+                        console.log(`in utilsSQLite execute whereStmt ${whereStmt}`);
                         const rStmt = await this.deleteSQL(mDB, whereStmt, []);
+                        console.log(`in utilsSQLite execute rStmt ${rStmt}`);
                         resArr.push(rStmt);
                     }
                     else {
@@ -351,12 +353,14 @@ class UtilsSQLite {
                 }
                 sqlStmt = resArr.join(';');
             }
+            console.log(`in utilsSQLite execute sqlStmt ${sqlStmt}`);
             await this.execDB(mDB, sqlStmt);
             changes = (await this.dbChanges(mDB)) - initChanges;
             return Promise.resolve(changes);
         }
         catch (err) {
-            return Promise.reject(`Execute: ${err.message}`);
+            const msg = err.message ? err.message : err;
+            return Promise.reject(`Execute: ${msg}`);
         }
     }
     /**
@@ -368,7 +372,8 @@ class UtilsSQLite {
         return new Promise((resolve, reject) => {
             mDB.exec(sql, async (err) => {
                 if (err) {
-                    reject(`Execute: ${err.message}: `);
+                    console.log(`in execDB err: ${JSON.stringify(err)}`);
+                    reject(`Execute: ${err}: `);
                 }
                 resolve();
             });
@@ -440,9 +445,12 @@ class UtilsSQLite {
     async runExec(db, stmt, values = []) {
         return new Promise((resolve, reject) => {
             if (values != null && values.length > 0) {
+                console.log(`in runExec stmt: ${stmt} values: ${values}`);
                 db.run(stmt, values, (err) => {
                     if (err) {
-                        reject(err.message);
+                        console.log(`in runExec err1: ${JSON.stringify(err)}`);
+                        const msg = err.message ? err.message : err;
+                        reject(msg);
                     }
                     else {
                         resolve();
@@ -452,7 +460,9 @@ class UtilsSQLite {
             else {
                 db.exec(stmt, (err) => {
                     if (err) {
-                        reject(err.message);
+                        console.log(`in runExec err2: ${JSON.stringify(err)}`);
+                        const msg = err.message ? err.message : err;
+                        reject(msg);
                     }
                     else {
                         resolve();
@@ -499,13 +509,14 @@ class UtilsSQLite {
                     .substring('DELETE FROM'.length)
                     .trim();
                 sqlStmt = `UPDATE ${tableName} SET sql_deleted = 1 ${clauseStmt}`;
+                console.log(`in deleteSQL sqlStmt: ${sqlStmt}`);
                 // Find REFERENCES if any and update the sql_deleted column
                 await this.findReferencesAndUpdate(db, tableName, clauseStmt, values);
             }
             return sqlStmt;
         }
         catch (err) {
-            return Promise.reject(`DeleteSL: ${err}`);
+            return Promise.reject(`DeleteSQL: ${err}`);
         }
     }
     /**
@@ -519,27 +530,70 @@ class UtilsSQLite {
     async findReferencesAndUpdate(db, tableName, whereStmt, values) {
         try {
             const references = await this.getReferences(db, tableName);
+            if (references.length <= 0) {
+                return;
+            }
+            const tableNameWithRefs = references.pop();
+            console.log(`references: ${references}`);
+            console.log(`tableNameWithRefs: ${tableNameWithRefs}`);
             for (const refe of references) {
                 // get the tableName of the reference
-                const refTable = await this.getReferenceTableName(refe.sql);
+                const refTable = await this.getReferenceTableName(refe);
                 if (refTable.length <= 0) {
                     continue;
                 }
-                // get the columnName
-                const colName = await this.getReferenceColumnName(refe.sql);
-                if (colName.length <= 0) {
+                console.log(`refTable: ${refTable}`);
+                // get the with references columnName
+                const withRefsNames = await this.getWithRefsColumnName(refe);
+                console.log(`withRefsNames: ${withRefsNames}`);
+                if (withRefsNames.length <= 0) {
+                    continue;
+                }
+                // get the referenced columnName
+                const colNames = await this.getReferencedColumnName(refe);
+                console.log(`colNames: ${colNames}`);
+                if (colNames.length <= 0) {
                     continue;
                 }
                 // update the where clause
-                const uWhereStmt = await this.updateWhere(whereStmt, colName);
+                const uWhereStmt = await this.updateWhere(whereStmt, withRefsNames, colNames);
+                console.log(`whereStmt: ${whereStmt}`);
+                console.log(`uWhereStmt: ${uWhereStmt}`);
                 if (uWhereStmt.length <= 0) {
                     continue;
                 }
+                let updTableName = tableNameWithRefs;
+                let updColNames = colNames;
+                if (tableNameWithRefs === tableName) {
+                    updTableName = refTable;
+                    updColNames = withRefsNames;
+                }
+                console.log(`updTableName: ${updTableName}`);
+                console.log(`updColNames: ${updColNames}`);
                 //update sql_deleted for this reference
-                const stmt = `UPDATE ${refTable} SET sql_deleted = 1 ${uWhereStmt}`;
+                const stmt = 'UPDATE ' + updTableName + ' SET sql_deleted = 1 ' + uWhereStmt;
+                console.log(`stmt: ${stmt}`);
+                console.log(`values: ${values}`);
                 if (values != null && values.length > 0) {
                     const mVal = await this.replaceUndefinedByNull(values);
-                    await db.run(stmt, mVal);
+                    let arrVal = whereStmt.split('?');
+                    if (arrVal[arrVal.length - 1] === ';')
+                        arrVal = arrVal.slice(0, -1);
+                    console.log(`arrVal: ${arrVal}`);
+                    const selValues = [];
+                    for (const [j, val] of arrVal.entries()) {
+                        console.log(`j: ${j} val: ${val}`);
+                        for (const updVal of updColNames) {
+                            const idxVal = val.indexOf(updVal);
+                            console.log(`updVal: ${updVal} idxVal ${idxVal}`);
+                            if (idxVal > -1) {
+                                selValues.push(mVal[j]);
+                            }
+                        }
+                    }
+                    console.log(`*** stmt: ${selValues}`);
+                    console.log(`*** selValues: ${selValues}`);
+                    await db.run(stmt, selValues);
                 }
                 else {
                     await db.exec(stmt);
@@ -558,51 +612,120 @@ class UtilsSQLite {
     }
     async getReferenceTableName(refValue) {
         let tableName = '';
-        if (refValue.length > 0 &&
-            refValue.substring(0, 12).toLowerCase() === 'CREATE TABLE'.toLowerCase()) {
-            const oPar = refValue.indexOf('(');
-            tableName = refValue.substring(13, oPar).trim();
+        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;
     }
-    async getReferenceColumnName(refValue) {
-        let colName = '';
+    async getReferencedColumnName(refValue) {
+        let colNames = [];
         if (refValue.length > 0) {
-            const index = refValue
-                .toLowerCase()
-                .indexOf('FOREIGN KEY'.toLowerCase());
-            const stmt = refValue.substring(index + 12);
-            const oPar = stmt.indexOf('(');
-            const cPar = stmt.indexOf(')');
-            colName = stmt.substring(oPar + 1, cPar).trim();
+            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(',');
+            }
+        }
+        return colNames;
+    }
+    async 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 colName;
+        return colNames;
     }
-    async updateWhere(whStmt, colName) {
+    async updateWhere(whStmt, withRefsNames, colNames) {
         let whereStmt = '';
         if (whStmt.length > 0) {
             const index = whStmt.toLowerCase().indexOf('WHERE'.toLowerCase());
             const stmt = whStmt.substring(index + 6);
-            const fEqual = stmt.indexOf('=');
-            const whereColName = stmt.substring(0, fEqual).trim();
-            whereStmt = whStmt.replace(whereColName, colName);
+            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}`;
+                            }
+                        }
+                    }
+                }
+                whereStmt = 'WHERE ' + whereStmt;
+            }
         }
         return whereStmt;
     }
     async getReferences(db, tableName) {
         const sqlStmt = 'SELECT sql FROM sqlite_master ' +
-            "WHERE sql LIKE('%REFERENCES%') AND " +
+            "WHERE sql LIKE('%FOREIGN KEY%') AND sql LIKE('%REFERENCES%') AND " +
             "sql LIKE('%" +
             tableName +
             "%') AND sql LIKE('%ON DELETE%');";
         try {
             const res = await this.queryAll(db, sqlStmt, []);
-            return Promise.resolve(res);
+            // get the reference's string(s)
+            let retRefs = [];
+            if (res.length > 0) {
+                retRefs = await this.getRefs(res[0].sql);
+            }
+            return Promise.resolve(retRefs);
         }
         catch (err) {
             return Promise.reject(new Error(`getReferences: ${err.message}`));
         }
     }
+    async 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);
+        }
+        return retRefs;
+    }
     /**
      * QueryAll
      * @param mDB
@@ -3509,7 +3632,7 @@ class Database {
                     }
                 }
                 else {
-                    throw new Error('No last_modified column in tables');
+                    throw new Error('No last_modified/sql_deleted columns in tables');
                 }
             }
             else {
@@ -3768,7 +3891,10 @@ class Database {
         inJson.mode = mode;
         this.ensureDatabaseIsOpen();
         try {
-            await this.exportToJsonUtil.setLastExportDate(this.database, new Date().toISOString());
+            const isTable = await this.jsonUtil.isTableExists(this.database, this._isDbOpen, 'sync_table');
+            if (isTable) {
+                await this.exportToJsonUtil.setLastExportDate(this.database, new Date().toISOString());
+            }
             const jsonResult = await this.exportToJsonUtil.createExportObject(this.database, inJson);
             const keys = Object.keys(jsonResult);
             if (keys.length === 0) {