@capacitor-community/sqlite 3.4.2 → 3.4.3-3

package/electron/dist/plugin.js

@@ -325,12 +325,33 @@ class UtilsSQLite {
      * @param mDB
      * @param sql
      */
-    async execute(mDB, sql) {
+    async execute(mDB, sql, fromJson) {
         let changes = -1;
         let initChanges = -1;
         try {
             initChanges = await this.dbChanges(mDB);
-            await this.execDB(mDB, sql);
+            let sqlStmt = sql;
+            // Check for DELETE FROM in sql string
+            if (!fromJson &&
+                sql.toLowerCase().includes('DELETE FROM'.toLowerCase())) {
+                sqlStmt = sql.replace(/\n/g, '');
+                const sqlStmts = sqlStmt.split(';');
+                const resArr = [];
+                for (const stmt of sqlStmts) {
+                    const trimStmt = stmt.trim().substring(0, 11).toUpperCase();
+                    if (trimStmt === 'DELETE FROM' &&
+                        stmt.toLowerCase().includes('WHERE'.toLowerCase())) {
+                        const whereStmt = `${stmt.trim()};`;
+                        const rStmt = await this.deleteSQL(mDB, whereStmt, []);
+                        resArr.push(rStmt);
+                    }
+                    else {
+                        resArr.push(stmt);
+                    }
+                }
+                sqlStmt = resArr.join(';');
+            }
+            await this.execDB(mDB, sqlStmt);
             changes = (await this.dbChanges(mDB)) - initChanges;
             return Promise.resolve(changes);
         }
@@ -358,7 +379,7 @@ class UtilsSQLite {
      * @param db
      * @param set
      */
-    async executeSet(db, set) {
+    async executeSet(db, set, fromJson) {
         let lastId = -1;
         for (let i = 0; i < set.length; i++) {
             const statement = 'statement' in set[i] ? set[i].statement : null;
@@ -371,11 +392,13 @@ class UtilsSQLite {
             try {
                 if (Array.isArray(values[0])) {
                     for (const val of values) {
-                        lastId = await this.prepareRun(db, statement, val);
+                        const mVal = await this.replaceUndefinedByNull(val);
+                        lastId = await this.prepareRun(db, statement, mVal, fromJson);
                     }
                 }
                 else {
-                    lastId = await this.prepareRun(db, statement, values);
+                    const mVal = await this.replaceUndefinedByNull(values);
+                    lastId = await this.prepareRun(db, statement, mVal, fromJson);
                 }
             }
             catch (err) {
@@ -390,24 +413,175 @@ class UtilsSQLite {
      * @param statement
      * @param values
      */
-    prepareRun(db, statement, values) {
-        return new Promise((resolve, reject) => {
-            let lastId = -1;
-            db.run(statement, values, async (err) => {
-                if (err) {
-                    reject(`PrepareRun: run ${err.message}`);
+    async prepareRun(db, statement, values, fromJson) {
+        const stmtType = statement
+            .replace(/\n/g, '')
+            .trim()
+            .substring(0, 6)
+            .toUpperCase();
+        let sqlStmt = statement;
+        let lastId = -1;
+        try {
+            if (!fromJson && stmtType === 'DELETE') {
+                sqlStmt = await this.deleteSQL(db, statement, values);
+            }
+            let mVal = [];
+            if (values != null && values.length > 0) {
+                mVal = await this.replaceUndefinedByNull(values);
+            }
+            if (mVal.length > 0) {
+                await db.run(sqlStmt, mVal);
+            }
+            else {
+                await db.exec(sqlStmt);
+            }
+            lastId = await this.getLastId(db);
+            return Promise.resolve(lastId);
+        }
+        catch (err) {
+            return Promise.reject(`PrepareRun: ${err}`);
+        }
+    }
+    /**
+     * replaceUndefinedByNull
+     * @param values
+     * @returns
+     */
+    async replaceUndefinedByNull(values) {
+        const retValues = [];
+        if (values.length > 0) {
+            for (const val of values) {
+                let mVal = val;
+                if (typeof val === 'undefined')
+                    mVal = null;
+                retValues.push(mVal);
+            }
+        }
+        return Promise.resolve(retValues);
+    }
+    /**
+     * deleteSQL
+     * @param db
+     * @param statement
+     * @param values
+     * @returns
+     */
+    async deleteSQL(db, statement, values) {
+        let sqlStmt = statement;
+        try {
+            const isLast = await this.isLastModified(db, true);
+            if (isLast) {
+                // 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
+                await this.findReferencesAndUpdate(db, tableName, clauseStmt, values);
+            }
+            return sqlStmt;
+        }
+        catch (err) {
+            return Promise.reject(`DeleteSL: ${err}`);
+        }
+    }
+    /**
+     * findReferencesAndUpdate
+     * @param db
+     * @param tableName
+     * @param whereStmt
+     * @param values
+     * @returns
+     */
+    async findReferencesAndUpdate(db, tableName, whereStmt, values) {
+        try {
+            const references = await this.getReferences(db, tableName);
+            for (const refe of references) {
+                // get the tableName of the reference
+                const refTable = await this.getReferenceTableName(refe.sql);
+                if (refTable.length <= 0) {
+                    continue;
+                }
+                // get the columnName
+                const colName = await this.getReferenceColumnName(refe.sql);
+                if (colName.length <= 0) {
+                    continue;
+                }
+                // update the where clause
+                const uWhereStmt = await this.updateWhere(whereStmt, colName);
+                if (uWhereStmt.length <= 0) {
+                    continue;
+                }
+                //update sql_deleted for this reference
+                const stmt = `UPDATE ${refTable} SET sql_deleted = 1 ${uWhereStmt}`;
+                if (values != null && values.length > 0) {
+                    const mVal = await this.replaceUndefinedByNull(values);
+                    await db.run(stmt, mVal);
                 }
                 else {
-                    try {
-                        lastId = await this.getLastId(db);
-                        resolve(lastId);
-                    }
-                    catch (err) {
-                        reject(`PrepareRun: lastId ${err}`);
-                    }
+                    await db.exec(stmt);
                 }
-            });
-        });
+                const lastId = await this.getLastId(db);
+                if (lastId == -1) {
+                    const msg = `UPDATE sql_deleted failed for references table: ${refTable}`;
+                    return Promise.reject(new Error(`findReferencesAndUpdate: ${msg}`));
+                }
+            }
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(new Error(`findReferencesAndUpdate: ${err.message}`));
+        }
+    }
+    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();
+        }
+        return tableName;
+    }
+    async getReferenceColumnName(refValue) {
+        let colName = '';
+        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();
+        }
+        return colName;
+    }
+    async updateWhere(whStmt, colName) {
+        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);
+        }
+        return whereStmt;
+    }
+    async getReferences(db, tableName) {
+        const sqlStmt = 'SELECT sql FROM sqlite_master ' +
+            "WHERE sql LIKE('%REFERENCES%') AND " +
+            "sql LIKE('%" +
+            tableName +
+            "%') AND sql LIKE('%ON DELETE%');";
+        try {
+            const res = await this.queryAll(db, sqlStmt, []);
+            return Promise.resolve(res);
+        }
+        catch (err) {
+            return Promise.reject(new Error(`getReferences: ${err.message}`));
+        }
     }
     /**
      * QueryAll
@@ -432,20 +606,6 @@ class UtilsSQLite {
             });
         });
     }
-}
-utilsSQLite.UtilsSQLite = UtilsSQLite;
-
-var utilsJson = {};
-
-var utilsDrop = {};
-
-Object.defineProperty(utilsDrop, "__esModule", { value: true });
-utilsDrop.UtilsDrop = void 0;
-const utilsSQLite_1$5 = utilsSQLite;
-class UtilsDrop {
-    constructor() {
-        this._uSQLite = new utilsSQLite_1$5.UtilsSQLite();
-    }
     /**
      * GetTablesNames
      * @param mDb
@@ -458,7 +618,7 @@ class UtilsDrop {
         sql += 'ORDER BY rootpage DESC;';
         const retArr = [];
         try {
-            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            const retQuery = await this.queryAll(mDb, sql, []);
             for (const query of retQuery) {
                 retArr.push(query.name);
             }
@@ -478,7 +638,7 @@ class UtilsDrop {
         sql += 'ORDER BY rootpage DESC;';
         const retArr = [];
         try {
-            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            const retQuery = await this.queryAll(mDb, sql, []);
             for (const query of retQuery) {
                 retArr.push(query.name);
             }
@@ -489,137 +649,63 @@ class UtilsDrop {
         }
     }
     /**
-     * DropElements
+     * isLastModified
      * @param db
-     * @param type ["table","index","trigger"]
+     * @param isOpen
      */
-    async dropElements(db, type) {
-        let msg = '';
-        let stmt1 = `AND name NOT LIKE ('sqlite_%')`;
-        switch (type) {
-            case 'index':
-                msg = 'DropIndexes';
-                break;
-            case 'trigger':
-                msg = 'DropTriggers';
-                break;
-            case 'table':
-                msg = 'DropTables';
-                stmt1 += ` AND name NOT IN ('sync_table')`;
-                break;
-            case 'view':
-                msg = 'DropViews';
-                break;
-            default:
-                return Promise.reject(`DropElements: ${type} ` + 'not found');
+    async isLastModified(db, isOpen) {
+        if (!isOpen) {
+            return Promise.reject('isLastModified: database not opened');
         }
-        // get the element's names
-        let stmt = 'SELECT name FROM sqlite_master WHERE ';
-        stmt += `type = '${type}' ${stmt1};`;
         try {
-            const elements = await this._uSQLite.queryAll(db, stmt, []);
-            if (elements.length > 0) {
-                const upType = type.toUpperCase();
-                const statements = [];
-                for (const elem of elements) {
-                    let stmt = `DROP ${upType} IF EXISTS `;
-                    stmt += `${elem.name};`;
-                    statements.push(stmt);
-                }
-                for (const stmt of statements) {
-                    const lastId = await this._uSQLite.prepareRun(db, stmt, []);
-                    if (lastId < 0) {
-                        return Promise.reject(`${msg}: lastId < 0`);
-                    }
+            const tableList = await this.getTablesNames(db);
+            for (const table of tableList) {
+                const tableNamesTypes = await this.getTableColumnNamesTypes(db, table);
+                const tableColumnNames = tableNamesTypes.names;
+                if (tableColumnNames.includes('last_modified')) {
+                    return Promise.resolve(true);
                 }
             }
-            return Promise.resolve();
-        }
-        catch (err) {
-            return Promise.reject(`${msg}: ${err}`);
-        }
-    }
-    /**
-     * DropAll
-     * Drop all database's elements
-     * @param db
-     */
-    async dropAll(db) {
-        try {
-            // drop tables
-            await this.dropElements(db, 'table');
-            // drop indexes
-            await this.dropElements(db, 'index');
-            // drop triggers
-            await this.dropElements(db, 'trigger');
-            // drop views
-            await this.dropElements(db, 'view');
-            // vacuum the database
-            await this._uSQLite.prepareRun(db, 'VACUUM;', []);
-            return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(`DropAll: ${err}`);
+            return Promise.reject(`isLastModified: ${err}`);
         }
     }
     /**
-     * DropTempTables
-     * @param db
-     * @param alterTables
+     * GetTableColumnNamesTypes
+     * @param mDB
+     * @param tableName
      */
-    async dropTempTables(db, alterTables) {
-        const tempTables = Object.keys(alterTables);
-        const statements = [];
-        for (const tTable of tempTables) {
-            let stmt = 'DROP TABLE IF EXISTS ';
-            stmt += `_temp_${tTable};`;
-            statements.push(stmt);
-        }
+    async getTableColumnNamesTypes(mDB, tableName) {
+        let resQuery = [];
+        const retNames = [];
+        const retTypes = [];
+        const query = `PRAGMA table_info('${tableName}');`;
         try {
-            const changes = await this._uSQLite.execute(db, statements.join('\n'));
-            if (changes < 0) {
-                return Promise.reject('DropTempTables: changes < 0');
+            resQuery = await this.queryAll(mDB, query, []);
+            if (resQuery.length > 0) {
+                for (const query of resQuery) {
+                    retNames.push(query.name);
+                    retTypes.push(query.type);
+                }
             }
-            return Promise.resolve();
+            return Promise.resolve({ names: retNames, types: retTypes });
         }
         catch (err) {
-            return Promise.reject(`DropTempTables: ${err}`);
+            return Promise.reject('GetTableColumnNamesTypes: ' + `${err}`);
         }
     }
 }
-utilsDrop.UtilsDrop = UtilsDrop;
+utilsSQLite.UtilsSQLite = UtilsSQLite;
+
+var utilsJson = {};
 
 Object.defineProperty(utilsJson, "__esModule", { value: true });
 utilsJson.UtilsJson = void 0;
-const utilsDrop_1$3 = utilsDrop;
-const utilsSQLite_1$4 = utilsSQLite;
+const utilsSQLite_1$5 = utilsSQLite;
 class UtilsJson {
     constructor() {
-        this._uSQLite = new utilsSQLite_1$4.UtilsSQLite();
-        this._uDrop = new utilsDrop_1$3.UtilsDrop();
-    }
-    /**
-     * isLastModified
-     * @param db
-     * @param isOpen
-     */
-    async isLastModified(db, isOpen) {
-        if (!isOpen) {
-            return Promise.reject('isLastModified: database not opened');
-        }
-        try {
-            const tableList = await this._uDrop.getTablesNames(db);
-            for (const table of tableList) {
-                const tableNamesTypes = await this.getTableColumnNamesTypes(db, table);
-                const tableColumnNames = tableNamesTypes.names;
-                if (tableColumnNames.includes('last_modified')) {
-                    return Promise.resolve(true);
-                }
-            }
-        }
-        catch (err) {
-            return Promise.reject(`isLastModified: ${err}`);
-        }
+        this.sqliteUtil = new utilsSQLite_1$5.UtilsSQLite();
     }
     /**
      * IsTableExists
@@ -689,7 +775,7 @@ class UtilsJson {
         let changes = 0;
         try {
             // start a transaction
-            await this._uSQLite.beginTransaction(mDB, true);
+            await this.sqliteUtil.beginTransaction(mDB, true);
         }
         catch (err) {
             return Promise.reject(`CreateDatabaseSchema: ${err}`);
@@ -698,10 +784,10 @@ class UtilsJson {
         if (stmts.length > 0) {
             const schemaStmt = stmts.join('\n');
             try {
-                changes = await this._uSQLite.execute(mDB, schemaStmt);
+                changes = await this.sqliteUtil.execute(mDB, schemaStmt, true);
                 if (changes < 0) {
                     try {
-                        await this._uSQLite.rollbackTransaction(mDB, true);
+                        await this.sqliteUtil.rollbackTransaction(mDB, true);
                     }
                     catch (err) {
                         return Promise.reject('CreateSchema: changes < 0 ' + `${err}`);
@@ -711,7 +797,7 @@ class UtilsJson {
             catch (err) {
                 const msg = err;
                 try {
-                    await this._uSQLite.rollbackTransaction(mDB, true);
+                    await this.sqliteUtil.rollbackTransaction(mDB, true);
                     return Promise.reject(`CreateSchema: ${msg}`);
                 }
                 catch (err) {
@@ -720,7 +806,7 @@ class UtilsJson {
             }
         }
         try {
-            await this._uSQLite.commitTransaction(mDB, true);
+            await this.sqliteUtil.commitTransaction(mDB, true);
             return Promise.resolve(changes);
         }
         catch (err) {
@@ -829,7 +915,7 @@ class UtilsJson {
                 return Promise.reject('CreateDataTable: Table ' + `${table.name} does not exist`);
             }
             // Get the column names and types
-            const tableNamesTypes = await this.getTableColumnNamesTypes(mDB, table.name);
+            const tableNamesTypes = await this.sqliteUtil.getTableColumnNamesTypes(mDB, table.name);
             const tableColumnTypes = tableNamesTypes.types;
             const tableColumnNames = tableNamesTypes.names;
             if (tableColumnTypes.length === 0) {
@@ -837,54 +923,15 @@ class UtilsJson {
             }
             // Loop on Table Values
             for (let j = 0; j < table.values.length; j++) {
-                // Check the row number of columns
-                if (table.values[j].length != tableColumnTypes.length) {
-                    return Promise.reject(`CreateDataTable: Table ${table.name} ` +
-                        `values row ${j} not correct length`);
-                }
-                // Check the column's type before proceeding
-                // remove type checking for allowing RDBMS Types
-                /*    const isColumnTypes: boolean = await this.checkColumnTypes(
-                  tableColumnTypes,
-                  table.values[j],
-                );
-                if (!isColumnTypes) {
-                  return Promise.reject(
-                    new Error(
-                      `CreateDataTable: Table ${table.name} ` +
-                        `values row ${j} not correct types`,
-                    ),
-                  );
-                }
-                */
-                const retisIdExists = await this.isIdExists(mDB, table.name, tableColumnNames[0], table.values[j][0]);
-                let stmt;
+                let row = table.values[j];
                 let isRun = true;
-                if (mode === 'full' || (mode === 'partial' && !retisIdExists)) {
-                    // Insert
-                    const nameString = tableColumnNames.join();
-                    const questionMarkString = await this.createQuestionMarkString(tableColumnNames.length);
-                    stmt = `INSERT INTO ${table.name} (${nameString}) VALUES (`;
-                    stmt += `${questionMarkString});`;
-                }
-                else {
-                    // Update
-                    const setString = await this.setNameForUpdate(tableColumnNames);
-                    if (setString.length === 0) {
-                        return Promise.reject(`CreateDataTable: Table ${table.name} ` +
-                            `values row ${j} not set to String`);
-                    }
-                    stmt = `UPDATE ${table.name} SET ${setString} WHERE `;
-                    if (typeof table.values[j][0] == 'string') {
-                        stmt += `${tableColumnNames[0]} = '${table.values[j][0]}';`;
-                    }
-                    else {
-                        stmt += `${tableColumnNames[0]} = ${table.values[j][0]};`;
-                    }
-                    isRun = await this.checkUpdate(mDB, table.values[j], table.name, tableColumnNames);
-                }
+                const stmt = await this.createRowStatement(mDB, tableColumnNames, row, j, table.name, mode);
+                isRun = await this.checkUpdate(mDB, stmt, row, table.name, tableColumnNames);
                 if (isRun) {
-                    lastId = await this._uSQLite.prepareRun(mDB, stmt, table.values[j]);
+                    if (stmt.substring(0, 6).toUpperCase() === 'DELETE') {
+                        row = [];
+                    }
+                    lastId = await this.sqliteUtil.prepareRun(mDB, stmt, row, true);
                     if (lastId < 0) {
                         return Promise.reject('CreateDataTable: lastId < 0');
                     }
@@ -900,65 +947,138 @@ class UtilsJson {
         }
     }
     /**
-     *
-     * @param db
-     * @param values
-     * @param tbName
+     * CreateRowStatement
+     * @param mDB
      * @param tColNames
+     * @param row
+     * @param j
+     * @param tableName
+     * @param mode
      * @returns
      */
-    async checkUpdate(db, values, tbName, tColNames) {
+    async createRowStatement(mDB, tColNames, row, j, tableName, mode) {
+        // Check the row number of columns
+        if (row.length != tColNames.length ||
+            row.length === 0 ||
+            tColNames.length === 0) {
+            return Promise.reject(new Error(`CreateRowStatement: Table ${tableName} ` +
+                `values row ${j} not correct length`));
+        }
         try {
-            let query = `SELECT * FROM ${tbName} WHERE `;
-            if (typeof values[0] == 'string') {
-                query += `${tColNames[0]} = '${values[0]}';`;
+            const retisIdExists = await this.isIdExists(mDB, tableName, tColNames[0], row[0]);
+            let stmt;
+            if (mode === 'full' || (mode === 'partial' && !retisIdExists)) {
+                // Insert
+                const nameString = tColNames.join();
+                const questionMarkString = await this.createQuestionMarkString(tColNames.length);
+                stmt = `INSERT INTO ${tableName} (${nameString}) VALUES (`;
+                stmt += `${questionMarkString});`;
             }
             else {
-                query += `${tColNames[0]} = ${values[0]};`;
-            }
-            const resQuery = await this.getValues(db, query, tbName);
-            let resValues = [];
-            if (resQuery.length > 0) {
-                resValues = resQuery[0];
-            }
-            if (values.length > 0 &&
-                resValues.length > 0 &&
-                values.length === resValues.length) {
-                for (let i = 0; i < values.length; i++) {
-                    if (values[i] !== resValues[i]) {
-                        return Promise.resolve(true);
+                // Update or Delete
+                let isUpdate = true;
+                const isColDeleted = (element) => element === `sql_deleted`;
+                const idxDelete = tColNames.findIndex(isColDeleted);
+                if (idxDelete >= 0) {
+                    if (row[idxDelete] === 1) {
+                        isUpdate = false;
+                        stmt = `DELETE FROM ${tableName} WHERE `;
+                        if (typeof row[0] == 'string') {
+                            stmt += `${tColNames[0]} = '${row[0]}';`;
+                        }
+                        else {
+                            stmt += `${tColNames[0]} = ${row[0]};`;
+                        }
+                    }
+                }
+                if (isUpdate) {
+                    // Update
+                    const setString = await this.setNameForUpdate(tColNames);
+                    if (setString.length === 0) {
+                        return Promise.reject(new Error(`CreateRowStatement: Table ${tableName} ` +
+                            `values row ${j} not set to String`));
+                    }
+                    stmt = `UPDATE ${tableName} SET ${setString} WHERE `;
+                    if (typeof row[0] == 'string') {
+                        stmt += `${tColNames[0]} = '${row[0]}';`;
+                    }
+                    else {
+                        stmt += `${tColNames[0]} = ${row[0]};`;
                     }
                 }
-                return Promise.resolve(false);
-            }
-            else {
-                const msg = 'Both arrays not the same length';
-                return Promise.reject(new Error(`CheckUpdate: ${msg}`));
             }
+            return Promise.resolve(stmt);
         }
         catch (err) {
-            return Promise.reject(new Error(`CheckUpdate: ${err.message}`));
+            return Promise.reject(new Error(`CreateRowStatement: ${err.message}`));
         }
     }
     /**
-     * GetValues
-     * @param mDb
-     * @param query
-     * @param tableName
+     *
+     * @param db
+     * @param values
+     * @param tbName
+     * @param tColNames
+     * @returns
      */
-    async getValues(mDb, query, tableName) {
-        const values = [];
-        try {
-            // get table column names and types
-            const tableNamesTypes = await this.getTableColumnNamesTypes(mDb, tableName);
-            let rowNames = [];
+    async checkUpdate(db, stmt, values, tbName, tColNames) {
+        const isRun = true;
+        if (stmt.substring(0, 6) === 'UPDATE') {
+            try {
+                let query = `SELECT * FROM ${tbName} WHERE `;
+                if (typeof values[0] == 'string') {
+                    query += `${tColNames[0]} = '${values[0]}';`;
+                }
+                else {
+                    query += `${tColNames[0]} = ${values[0]};`;
+                }
+                const resQuery = await this.getValues(db, query, tbName);
+                let resValues = [];
+                if (resQuery.length > 0) {
+                    resValues = resQuery[0];
+                }
+                if (values.length > 0 &&
+                    resValues.length > 0 &&
+                    values.length === resValues.length) {
+                    for (let i = 0; i < values.length; i++) {
+                        if (values[i] !== resValues[i]) {
+                            return Promise.resolve(true);
+                        }
+                    }
+                    return Promise.resolve(false);
+                }
+                else {
+                    const msg = 'Both arrays not the same length';
+                    return Promise.reject(new Error(`CheckUpdate: ${msg}`));
+                }
+            }
+            catch (err) {
+                return Promise.reject(new Error(`CheckUpdate: ${err.message}`));
+            }
+        }
+        else {
+            return Promise.resolve(isRun);
+        }
+    }
+    /**
+     * GetValues
+     * @param mDb
+     * @param query
+     * @param tableName
+     */
+    async getValues(mDb, query, tableName) {
+        const values = [];
+        try {
+            // get table column names and types
+            const tableNamesTypes = await this.sqliteUtil.getTableColumnNamesTypes(mDb, tableName);
+            let rowNames = [];
             if (Object.keys(tableNamesTypes).includes('names')) {
                 rowNames = tableNamesTypes.names;
             }
             else {
                 return Promise.reject(`GetValues: Table ${tableName} no names`);
             }
-            const retValues = await this._uSQLite.queryAll(mDb, query, []);
+            const retValues = await this.sqliteUtil.queryAll(mDb, query, []);
             for (const rValue of retValues) {
                 const row = [];
                 for (const rName of rowNames) {
@@ -977,30 +1097,6 @@ class UtilsJson {
             return Promise.reject(`GetValues: ${err}`);
         }
     }
-    /**
-     * GetTableColumnNamesTypes
-     * @param mDB
-     * @param tableName
-     */
-    async getTableColumnNamesTypes(mDB, tableName) {
-        let resQuery = [];
-        const retNames = [];
-        const retTypes = [];
-        const query = `PRAGMA table_info('${tableName}');`;
-        try {
-            resQuery = await this._uSQLite.queryAll(mDB, query, []);
-            if (resQuery.length > 0) {
-                for (const query of resQuery) {
-                    retNames.push(query.name);
-                    retTypes.push(query.type);
-                }
-            }
-            return Promise.resolve({ names: retNames, types: retTypes });
-        }
-        catch (err) {
-            return Promise.reject('GetTableColumnNamesTypes: ' + `${err}`);
-        }
-    }
     /**
      * CheckColumnTypes
      * @param tableTypes
@@ -1060,7 +1156,7 @@ class UtilsJson {
         if (typeof key === 'string')
             query += `'${key}';`;
         try {
-            const resQuery = await this._uSQLite.queryAll(db, query, []);
+            const resQuery = await this.sqliteUtil.queryAll(db, query, []);
             if (resQuery.length === 1)
                 ret = true;
             return Promise.resolve(ret);
@@ -1426,7 +1522,7 @@ class UtilsJson {
     async createView(mDB, view) {
         const stmt = `CREATE VIEW IF NOT EXISTS ${view.name} AS ${view.value};`;
         try {
-            const changes = await this._uSQLite.execute(mDB, stmt);
+            const changes = await this.sqliteUtil.execute(mDB, stmt, true);
             if (changes < 0) {
                 return Promise.reject(`CreateView: ${view.name} failed`);
             }
@@ -1441,12 +1537,12 @@ utilsJson.UtilsJson = UtilsJson;
 
 Object.defineProperty(exportToJson, "__esModule", { value: true });
 exportToJson.ExportToJson = void 0;
-const utilsSQLite_1$3 = utilsSQLite;
+const utilsSQLite_1$4 = utilsSQLite;
 const utilsJson_1$4 = utilsJson;
 class ExportToJson {
     constructor() {
-        this._uSQLite = new utilsSQLite_1$3.UtilsSQLite();
-        this._uJson = new utilsJson_1$4.UtilsJson();
+        this.sqliteUtil = new utilsSQLite_1$4.UtilsSQLite();
+        this.jsonUtil = new utilsJson_1$4.UtilsJson();
     }
     /**
      * CreateExportObject
@@ -1467,7 +1563,7 @@ class ExportToJson {
                 return Promise.reject("createExportObject: table's names failed");
             }
             else {
-                const isTable = await this._uJson.isTableExists(mDB, true, 'sync_table');
+                const isTable = await this.jsonUtil.isTableExists(mDB, true, 'sync_table');
                 if (!isTable && sqlObj.mode === 'partial') {
                     return Promise.reject('No sync_table available');
                 }
@@ -1517,13 +1613,102 @@ class ExportToJson {
         sql += "AND name NOT LIKE 'sqlite_%';";
         let retQuery = [];
         try {
-            retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            retQuery = await this.sqliteUtil.queryAll(mDb, sql, []);
             return Promise.resolve(retQuery);
         }
         catch (err) {
             return Promise.reject(`getTablesNameSQL: ${err}`);
         }
     }
+    async getLastExportDate(mDb) {
+        return new Promise((resolve, reject) => {
+            let retDate = -1;
+            // get the last sync date
+            const stmt = `SELECT sync_date FROM sync_table WHERE id = 2;`;
+            mDb.get(stmt, [], (err, row) => {
+                // process the row here
+                if (err) {
+                    reject(`getLastExportDate: ${err.message}`);
+                }
+                else {
+                    if (row != null) {
+                        const key = Object.keys(row)[0];
+                        retDate = row[key];
+                    }
+                    resolve(retDate);
+                }
+            });
+        });
+    }
+    /**
+     * SetLastExportDate
+     * @param mDb
+     * @param lastExportedDate
+     * @returns
+     */
+    async setLastExportDate(mDb, lastExportedDate) {
+        try {
+            const isTable = await this.jsonUtil.isTableExists(mDb, true, 'sync_table');
+            if (!isTable) {
+                return Promise.reject(new Error('setLastExportDate: No sync_table available'));
+            }
+            const sDate = Math.round(new Date(lastExportedDate).getTime() / 1000);
+            let stmt = '';
+            if ((await this.getLastExportDate(mDb)) > 0) {
+                stmt = `UPDATE sync_table SET sync_date = ${sDate} WHERE id = 2;`;
+            }
+            else {
+                stmt = `INSERT INTO sync_table (sync_date) VALUES (${sDate});`;
+            }
+            const changes = await this.sqliteUtil.execute(mDb, stmt, false);
+            if (changes < 0) {
+                return { result: false, message: 'setLastExportDate failed' };
+            }
+            else {
+                return { result: true };
+            }
+        }
+        catch (err) {
+            return {
+                result: false,
+                message: `setLastExportDate failed: ${err.message}`,
+            };
+        }
+    }
+    async delExportedRows(mDb) {
+        let lastExportDate;
+        try {
+            // check if synchronization table exists
+            const isTable = await this.jsonUtil.isTableExists(mDb, true, 'sync_table');
+            if (!isTable) {
+                return Promise.reject('DelExportedRows: No sync_table available');
+            }
+            // get the last export date
+            lastExportDate = await this.getLastExportDate(mDb);
+            if (lastExportDate < 0) {
+                return Promise.reject('DelExportedRows: no last exported date available');
+            }
+            // get the table' name list
+            const resTables = await this.sqliteUtil.getTablesNames(mDb);
+            if (resTables.length === 0) {
+                return Promise.reject("DelExportedRows: No table's names returned");
+            }
+            // Loop through the tables
+            for (const table of resTables) {
+                let lastId = -1;
+                // define the delete statement
+                const delStmt = `DELETE FROM ${table}
+              WHERE sql_deleted = 1 AND last_modified < ${lastExportDate};`;
+                lastId = await this.sqliteUtil.prepareRun(mDb, delStmt, [], true);
+                if (lastId < 0) {
+                    return Promise.reject('DelExportedRows: lastId < 0');
+                }
+            }
+        }
+        catch (err) {
+            return Promise.reject(`DelExportedRows failed: ${err.message}`);
+        }
+    }
     /**
      * GetViewsNameSQL
      * @param mDb
@@ -1534,7 +1719,7 @@ class ExportToJson {
         sql += "type='view' AND name NOT LIKE 'sqlite_%';";
         let retQuery = [];
         try {
-            retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            retQuery = await this.sqliteUtil.queryAll(mDb, sql, []);
             for (const query of retQuery) {
                 const view = {};
                 view.name = query.name;
@@ -1555,7 +1740,7 @@ class ExportToJson {
         return new Promise((resolve, reject) => {
             let retDate = -1;
             // get the last sync date
-            const stmt = `SELECT sync_date FROM sync_table;`;
+            const stmt = `SELECT sync_date FROM sync_table WHERE id = 1;`;
             mDb.get(stmt, [], (err, row) => {
                 // process the row here
                 if (err) {
@@ -1609,22 +1794,22 @@ class ExportToJson {
                     break;
                 }
                 // check schema validity
-                await this._uJson.checkSchemaValidity(schema);
+                await this.jsonUtil.checkSchemaValidity(schema);
                 // create Table's indexes if any
                 const indexes = await this.getIndexes(mDb, tableName);
                 if (indexes.length > 0) {
                     // check indexes validity
-                    await this._uJson.checkIndexesValidity(indexes);
+                    await this.jsonUtil.checkIndexesValidity(indexes);
                 }
                 // create Table's triggers if any
                 const triggers = await this.getTriggers(mDb, tableName);
                 if (triggers.length > 0) {
                     // check triggers validity
-                    await this._uJson.checkTriggersValidity(triggers);
+                    await this.jsonUtil.checkTriggersValidity(triggers);
                 }
                 // create Table's Data
                 const query = `SELECT * FROM ${tableName};`;
-                const values = await this._uJson.getValues(mDb, query, tableName);
+                const values = await this.jsonUtil.getValues(mDb, query, tableName);
                 table.name = tableName;
                 if (schema.length > 0) {
                     table.schema = schema;
@@ -1722,7 +1907,7 @@ class ExportToJson {
             let stmt = 'SELECT name,tbl_name,sql FROM sqlite_master WHERE ';
             stmt += `type = 'index' AND tbl_name = '${tableName}' `;
             stmt += `AND sql NOTNULL;`;
-            const retIndexes = await this._uSQLite.queryAll(mDb, stmt, []);
+            const retIndexes = await this.sqliteUtil.queryAll(mDb, stmt, []);
             if (retIndexes.length > 0) {
                 for (const rIndex of retIndexes) {
                     const keys = Object.keys(rIndex);
@@ -1771,7 +1956,7 @@ class ExportToJson {
             let stmt = 'SELECT name,tbl_name,sql FROM sqlite_master WHERE ';
             stmt += `type = 'trigger' AND tbl_name = '${tableName}' `;
             stmt += `AND sql NOT NULL;`;
-            const retTriggers = await this._uSQLite.queryAll(mDb, stmt, []);
+            const retTriggers = await this.sqliteUtil.queryAll(mDb, stmt, []);
             if (retTriggers.length > 0) {
                 for (const rTrg of retTriggers) {
                     const keys = Object.keys(rTrg);
@@ -1881,19 +2066,19 @@ class ExportToJson {
                     schema = await this.getSchema(sqlStmt);
                     if (schema.length > 0) {
                         // check schema validity
-                        await this._uJson.checkSchemaValidity(schema);
+                        await this.jsonUtil.checkSchemaValidity(schema);
                     }
                     // create Table's indexes if any
                     indexes = await this.getIndexes(mDb, tableName);
                     if (indexes.length > 0) {
                         // check indexes validity
-                        await this._uJson.checkIndexesValidity(indexes);
+                        await this.jsonUtil.checkIndexesValidity(indexes);
                     }
                     // create Table's triggers if any
                     triggers = await this.getTriggers(mDb, tableName);
                     if (triggers.length > 0) {
                         // check triggers validity
-                        await this._uJson.checkTriggersValidity(triggers);
+                        await this.jsonUtil.checkTriggersValidity(triggers);
                     }
                 }
                 // create Table's Data
@@ -1906,7 +2091,7 @@ class ExportToJson {
                         `SELECT * FROM ${tableName} ` +
                             `WHERE last_modified > ${syncDate};`;
                 }
-                const values = await this._uJson.getValues(mDb, query, tableName);
+                const values = await this.jsonUtil.getValues(mDb, query, tableName);
                 // check the table object validity
                 table.name = tableName;
                 if (schema.length > 0) {
@@ -1972,7 +2157,7 @@ class ExportToJson {
                 // get total count of the table
                 let stmt = 'SELECT count(*) AS tcount  ';
                 stmt += `FROM ${rTable.name};`;
-                let retQuery = await this._uSQLite.queryAll(db, stmt, []);
+                let retQuery = await this.sqliteUtil.queryAll(db, stmt, []);
                 if (retQuery.length != 1) {
                     errmsg = 'GetTableModified: total ' + 'count not returned';
                     break;
@@ -1982,7 +2167,7 @@ class ExportToJson {
                 stmt = 'SELECT count(*) AS mcount FROM ';
                 stmt += `${rTable.name} WHERE last_modified > `;
                 stmt += `${syncDate};`;
-                retQuery = await this._uSQLite.queryAll(db, stmt, []);
+                retQuery = await this.sqliteUtil.queryAll(db, stmt, []);
                 if (retQuery.length != 1)
                     break;
                 const totalModifiedCount = retQuery[0]['mcount'];
@@ -2050,16 +2235,126 @@ exportToJson.ExportToJson = ExportToJson;
 
 var importFromJson = {};
 
+var utilsDrop = {};
+
+Object.defineProperty(utilsDrop, "__esModule", { value: true });
+utilsDrop.UtilsDrop = void 0;
+const utilsSQLite_1$3 = utilsSQLite;
+class UtilsDrop {
+    constructor() {
+        this.sqliteUtil = new utilsSQLite_1$3.UtilsSQLite();
+    }
+    /**
+     * DropElements
+     * @param db
+     * @param type ["table","index","trigger"]
+     */
+    async dropElements(db, type) {
+        let msg = '';
+        let stmt1 = `AND name NOT LIKE ('sqlite_%')`;
+        switch (type) {
+            case 'index':
+                msg = 'DropIndexes';
+                break;
+            case 'trigger':
+                msg = 'DropTriggers';
+                break;
+            case 'table':
+                msg = 'DropTables';
+                stmt1 += ` AND name NOT IN ('sync_table')`;
+                break;
+            case 'view':
+                msg = 'DropViews';
+                break;
+            default:
+                return Promise.reject(`DropElements: ${type} ` + 'not found');
+        }
+        // get the element's names
+        let stmt = 'SELECT name FROM sqlite_master WHERE ';
+        stmt += `type = '${type}' ${stmt1};`;
+        try {
+            const elements = await this.sqliteUtil.queryAll(db, stmt, []);
+            if (elements.length > 0) {
+                const upType = type.toUpperCase();
+                const statements = [];
+                for (const elem of elements) {
+                    let stmt = `DROP ${upType} IF EXISTS `;
+                    stmt += `${elem.name};`;
+                    statements.push(stmt);
+                }
+                for (const stmt of statements) {
+                    const lastId = await this.sqliteUtil.prepareRun(db, stmt, [], false);
+                    if (lastId < 0) {
+                        return Promise.reject(`${msg}: lastId < 0`);
+                    }
+                }
+            }
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(`${msg}: ${err}`);
+        }
+    }
+    /**
+     * DropAll
+     * Drop all database's elements
+     * @param db
+     */
+    async dropAll(db) {
+        try {
+            // drop tables
+            await this.dropElements(db, 'table');
+            // drop indexes
+            await this.dropElements(db, 'index');
+            // drop triggers
+            await this.dropElements(db, 'trigger');
+            // drop views
+            await this.dropElements(db, 'view');
+            // vacuum the database
+            await this.sqliteUtil.prepareRun(db, 'VACUUM;', [], false);
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(`DropAll: ${err}`);
+        }
+    }
+    /**
+     * DropTempTables
+     * @param db
+     * @param alterTables
+     */
+    async dropTempTables(db, alterTables) {
+        const tempTables = Object.keys(alterTables);
+        const statements = [];
+        for (const tTable of tempTables) {
+            let stmt = 'DROP TABLE IF EXISTS ';
+            stmt += `_temp_${tTable};`;
+            statements.push(stmt);
+        }
+        try {
+            const changes = await this.sqliteUtil.execute(db, statements.join('\n'), false);
+            if (changes < 0) {
+                return Promise.reject('DropTempTables: changes < 0');
+            }
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(`DropTempTables: ${err}`);
+        }
+    }
+}
+utilsDrop.UtilsDrop = UtilsDrop;
+
 Object.defineProperty(importFromJson, "__esModule", { value: true });
 importFromJson.ImportFromJson = void 0;
-const utilsDrop_1$2 = utilsDrop;
+const utilsDrop_1$1 = utilsDrop;
 const utilsSQLite_1$2 = utilsSQLite;
 const utilsJson_1$3 = utilsJson;
 class ImportFromJson {
     constructor() {
-        this._uJson = new utilsJson_1$3.UtilsJson();
-        this._uSQLite = new utilsSQLite_1$2.UtilsSQLite();
-        this._uDrop = new utilsDrop_1$2.UtilsDrop();
+        this.jsonUtil = new utilsJson_1$3.UtilsJson();
+        this.sqliteUtil = new utilsSQLite_1$2.UtilsSQLite();
+        this.dropUtil = new utilsDrop_1$1.UtilsDrop();
     }
     /**
      * CreateDatabaseSchema
@@ -2071,17 +2366,13 @@ class ImportFromJson {
         const version = jsonData.version;
         try {
             // set User Version PRAGMA
-            await this._uSQLite.setVersion(mDB, version);
+            await this.sqliteUtil.setVersion(mDB, version);
             // DROP ALL when mode="full"
             if (jsonData.mode === 'full') {
-                // set Foreign Keys Off
-                await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, false);
-                await this._uDrop.dropAll(mDB);
+                await this.dropUtil.dropAll(mDB);
             }
-            // set Foreign Keys On
-            await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, true);
             // create database schema
-            changes = await this._uJson.createSchema(mDB, jsonData);
+            changes = await this.jsonUtil.createSchema(mDB, jsonData);
             return Promise.resolve(changes);
         }
         catch (err) {
@@ -2095,9 +2386,9 @@ class ImportFromJson {
         let msg = '';
         let initChanges = -1;
         try {
-            initChanges = await this._uSQLite.dbChanges(mDB);
+            initChanges = await this.sqliteUtil.dbChanges(mDB);
             // start a transaction
-            await this._uSQLite.beginTransaction(mDB, true);
+            await this.sqliteUtil.beginTransaction(mDB, true);
         }
         catch (err) {
             return Promise.reject(`createTablesData: ${err}`);
@@ -2106,7 +2397,7 @@ class ImportFromJson {
             if (jTable.values != null && jTable.values.length >= 1) {
                 // Create the table's data
                 try {
-                    lastId = await this._uJson.createDataTable(mDB, jTable, jsonData.mode);
+                    lastId = await this.jsonUtil.createDataTable(mDB, jTable, jsonData.mode);
                     if (lastId < 0)
                         break;
                     isValue = true;
@@ -2120,8 +2411,8 @@ class ImportFromJson {
         }
         if (isValue) {
             try {
-                await this._uSQLite.commitTransaction(mDB, true);
-                changes = (await this._uSQLite.dbChanges(mDB)) - initChanges;
+                await this.sqliteUtil.commitTransaction(mDB, true);
+                changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
                 return Promise.resolve(changes);
             }
             catch (err) {
@@ -2131,7 +2422,7 @@ class ImportFromJson {
         else {
             if (msg.length > 0) {
                 try {
-                    await this._uSQLite.rollbackTransaction(mDB, true);
+                    await this.sqliteUtil.rollbackTransaction(mDB, true);
                     return Promise.reject(new Error(`createTablesData: ${msg}`));
                 }
                 catch (err) {
@@ -2155,9 +2446,9 @@ class ImportFromJson {
         let initChanges = -1;
         let changes = -1;
         try {
-            initChanges = await this._uSQLite.dbChanges(mDB);
+            initChanges = await this.sqliteUtil.dbChanges(mDB);
             // start a transaction
-            await this._uSQLite.beginTransaction(mDB, true);
+            await this.sqliteUtil.beginTransaction(mDB, true);
         }
         catch (err) {
             return Promise.reject(`createViews: ${err}`);
@@ -2166,7 +2457,7 @@ class ImportFromJson {
             if (jView.value != null) {
                 // Create the view
                 try {
-                    await this._uJson.createView(mDB, jView);
+                    await this.jsonUtil.createView(mDB, jView);
                     isView = true;
                 }
                 catch (err) {
@@ -2178,8 +2469,8 @@ class ImportFromJson {
         }
         if (isView) {
             try {
-                await this._uSQLite.commitTransaction(mDB, true);
-                changes = (await this._uSQLite.dbChanges(mDB)) - initChanges;
+                await this.sqliteUtil.commitTransaction(mDB, true);
+                changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
                 return Promise.resolve(changes);
             }
             catch (err) {
@@ -2189,7 +2480,7 @@ class ImportFromJson {
         else {
             if (msg.length > 0) {
                 try {
-                    await this._uSQLite.rollbackTransaction(mDB, true);
+                    await this.sqliteUtil.rollbackTransaction(mDB, true);
                     return Promise.reject(new Error(`createViews: ${msg}`));
                 }
                 catch (err) {
@@ -2635,15 +2926,15 @@ var utilsUpgrade = {};
 Object.defineProperty(utilsUpgrade, "__esModule", { value: true });
 utilsUpgrade.UtilsUpgrade = void 0;
 const utilsJson_1$2 = utilsJson;
-const utilsDrop_1$1 = utilsDrop;
+const utilsDrop_1 = utilsDrop;
 const utilsFile_1$2 = utilsFile;
 const utilsSQLite_1$1 = utilsSQLite;
 class UtilsUpgrade {
     constructor() {
-        this._uSQLite = new utilsSQLite_1$1.UtilsSQLite();
-        this._uFile = new utilsFile_1$2.UtilsFile();
-        this._uDrop = new utilsDrop_1$1.UtilsDrop();
-        this._uJson = new utilsJson_1$2.UtilsJson();
+        this.sqliteUtil = new utilsSQLite_1$1.UtilsSQLite();
+        this.fileUtil = new utilsFile_1$2.UtilsFile();
+        this.dropUtil = new utilsDrop_1.UtilsDrop();
+        this.jsonUtil = new utilsJson_1$2.UtilsJson();
         this._alterTables = {};
         this._commonColumns = {};
     }
@@ -2681,9 +2972,9 @@ class UtilsUpgrade {
             }
             try {
                 // set Foreign Keys Off
-                await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, false);
-                await this._uFile.copyFileName(dbName, `backup-${dbName}`);
-                const initChanges = await this._uSQLite.dbChanges(mDB);
+                await this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB, false);
+                await this.fileUtil.copyFileName(dbName, `backup-${dbName}`);
+                const initChanges = await this.sqliteUtil.dbChanges(mDB);
                 // Here we assume that all table schemas are given
                 // in the upgrade statement
                 if (statement.length > 0) {
@@ -2698,8 +2989,8 @@ class UtilsUpgrade {
                     }
                 }
                 // set Foreign Keys On
-                await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, true);
-                const changes = (await this._uSQLite.dbChanges(mDB)) - initChanges;
+                await this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB, true);
+                const changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
                 return Promise.resolve(changes);
             }
             catch (err) {
@@ -2721,11 +3012,11 @@ class UtilsUpgrade {
             //    "temp_tableName"
             await this.backupTables(mDB);
             // -> Drop all Indexes
-            await this._uDrop.dropElements(mDB, 'index');
+            await this.dropUtil.dropElements(mDB, 'index');
             // -> Drop all Triggers
-            await this._uDrop.dropElements(mDB, 'trigger');
+            await this.dropUtil.dropElements(mDB, 'trigger');
             // -> Create new tables from upgrade.statement
-            const changes = await this._uSQLite.execute(mDB, statement);
+            const changes = await this.sqliteUtil.execute(mDB, statement, false);
             if (changes < 0) {
                 return Promise.reject('ExecuteStatementProcess: ' + 'changes < 0');
             }
@@ -2735,16 +3026,18 @@ class UtilsUpgrade {
             if (Object.keys(this._commonColumns).length > 0) {
                 await this.updateNewTablesData(mDB);
             }
-            // -> Drop _temp_tables
-            await this._uDrop.dropTempTables(mDB, this._alterTables);
-            // -> Do some cleanup
-            this._alterTables = {};
-            this._commonColumns = {};
             return Promise.resolve();
         }
         catch (err) {
             return Promise.reject(`ExecuteStatementProcess: ${err}`);
         }
+        finally {
+            // -> Drop _temp_tables
+            await this.dropUtil.dropTempTables(mDB, this._alterTables);
+            // -> Do some cleanup
+            this._alterTables = {};
+            this._commonColumns = {};
+        }
     }
     /**
      * ExecuteSetProcess
@@ -2755,19 +3048,19 @@ class UtilsUpgrade {
     async executeSetProcess(mDB, set, toVersion) {
         try {
             // -> load new data
-            const lastId = await this._uSQLite.executeSet(mDB, set);
+            const lastId = await this.sqliteUtil.executeSet(mDB, set, false);
             if (lastId < 0) {
                 return Promise.reject('ExecuteSetProcess: lastId ' + '< 0');
             }
             // -> update database version
-            await this._uSQLite.setVersion(mDB, toVersion);
+            await this.sqliteUtil.setVersion(mDB, toVersion);
             // -> update syncDate if any
-            const retB = await this._uJson.isTableExists(mDB, true, 'sync_table');
+            const retB = await this.jsonUtil.isTableExists(mDB, true, 'sync_table');
             if (retB) {
                 const sDate = Math.round(new Date().getTime() / 1000);
                 let stmt = 'UPDATE sync_table SET ';
                 stmt += `sync_date = ${sDate} WHERE id = 1;`;
-                const changes = await this._uSQLite.execute(mDB, stmt);
+                const changes = await this.sqliteUtil.execute(mDB, stmt, false);
                 if (changes < 0) {
                     return Promise.reject('ExecuteSetProcess: changes ' + '< 0');
                 }
@@ -2785,7 +3078,7 @@ class UtilsUpgrade {
     async backupTables(mDB) {
         const msg = 'BackupTables: ';
         try {
-            const tables = await this._uDrop.getTablesNames(mDB);
+            const tables = await this.sqliteUtil.getTablesNames(mDB);
             for (const table of tables) {
                 try {
                     await this.backupTable(mDB, table);
@@ -2808,18 +3101,22 @@ class UtilsUpgrade {
     async backupTable(mDB, table) {
         try {
             // start a transaction
-            await this._uSQLite.beginTransaction(mDB, true);
+            await this.sqliteUtil.beginTransaction(mDB, true);
             // get the table's column names
             const colNames = await this.getTableColumnNames(mDB, table);
             this._alterTables[`${table}`] = colNames;
+            const tmpTable = `_temp_${table}`;
+            // Drop the tmpTable if exists
+            const delStmt = `DROP TABLE IF EXISTS ${tmpTable};`;
+            await this.sqliteUtil.prepareRun(mDB, delStmt, [], false);
             // prefix the table with _temp_
             let stmt = `ALTER TABLE ${table} RENAME `;
-            stmt += `TO _temp_${table};`;
-            const lastId = await this._uSQLite.prepareRun(mDB, stmt, []);
+            stmt += `TO ${tmpTable};`;
+            const lastId = await this.sqliteUtil.prepareRun(mDB, stmt, [], false);
             if (lastId < 0) {
                 let msg = 'BackupTable: lastId < 0';
                 try {
-                    await this._uSQLite.rollbackTransaction(mDB, true);
+                    await this.sqliteUtil.rollbackTransaction(mDB, true);
                 }
                 catch (err) {
                     msg += `: ${err}`;
@@ -2828,7 +3125,7 @@ class UtilsUpgrade {
             }
             else {
                 try {
-                    await this._uSQLite.commitTransaction(mDB, true);
+                    await this.sqliteUtil.commitTransaction(mDB, true);
                 }
                 catch (err) {
                     return Promise.reject('BackupTable: ' + `${err}`);
@@ -2850,7 +3147,7 @@ class UtilsUpgrade {
         const retNames = [];
         const query = `PRAGMA table_info('${tableName}');`;
         try {
-            resQuery = await this._uSQLite.queryAll(mDB, query, []);
+            resQuery = await this.sqliteUtil.queryAll(mDB, query, []);
             if (resQuery.length > 0) {
                 for (const query of resQuery) {
                     retNames.push(query.name);
@@ -2869,7 +3166,7 @@ class UtilsUpgrade {
     async findCommonColumns(mDB) {
         try {
             // Get new table list
-            const tables = await this._uDrop.getTablesNames(mDB);
+            const tables = await this.sqliteUtil.getTablesNames(mDB);
             if (tables.length === 0) {
                 return Promise.reject('FindCommonColumns: get ' + "table's names failed");
             }
@@ -2910,7 +3207,7 @@ class UtilsUpgrade {
     async updateNewTablesData(mDB) {
         try {
             // start a transaction
-            await this._uSQLite.beginTransaction(mDB, true);
+            await this.sqliteUtil.beginTransaction(mDB, true);
             const statements = [];
             const keys = Object.keys(this._commonColumns);
             keys.forEach(key => {
@@ -2920,11 +3217,11 @@ class UtilsUpgrade {
                 stmt += `SELECT ${columns} FROM _temp_${key};`;
                 statements.push(stmt);
             });
-            const changes = await this._uSQLite.execute(mDB, statements.join('\n'));
+            const changes = await this.sqliteUtil.execute(mDB, statements.join('\n'), false);
             if (changes < 0) {
                 let msg = 'updateNewTablesData: ' + 'changes < 0';
                 try {
-                    await this._uSQLite.rollbackTransaction(mDB, true);
+                    await this.sqliteUtil.rollbackTransaction(mDB, true);
                 }
                 catch (err) {
                     msg += `: ${err}`;
@@ -2933,7 +3230,7 @@ class UtilsUpgrade {
             }
             else {
                 try {
-                    await this._uSQLite.commitTransaction(mDB, true);
+                    await this.sqliteUtil.commitTransaction(mDB, true);
                     return Promise.resolve();
                 }
                 catch (err) {
@@ -2954,7 +3251,6 @@ const exportToJson_1 = exportToJson;
 const importFromJson_1 = importFromJson;
 const utilsJson_1$1 = utilsJson;
 //import { UtilsEncryption } from './utilsEncryption';
-const utilsDrop_1 = utilsDrop;
 const utilsFile_1$1 = utilsFile;
 const utilsSQLite_1 = utilsSQLite;
 const utilsUpgrade_1 = utilsUpgrade;
@@ -2963,24 +3259,23 @@ class Database {
     //    encrypted: boolean,
     //    mode: string,
     version, upgDict) {
-        this._uFile = new utilsFile_1$1.UtilsFile();
-        this._uSQLite = new utilsSQLite_1.UtilsSQLite();
-        this._uJson = new utilsJson_1$1.UtilsJson();
-        this._uDrop = new utilsDrop_1.UtilsDrop();
+        this.fileUtil = new utilsFile_1$1.UtilsFile();
+        this.sqliteUtil = new utilsSQLite_1.UtilsSQLite();
+        this.jsonUtil = new utilsJson_1$1.UtilsJson();
         //  private _uGlobal: GlobalSQLite = new GlobalSQLite();
         //  private _uEncrypt: UtilsEncryption = new UtilsEncryption();
-        this._uUpg = new utilsUpgrade_1.UtilsUpgrade();
-        this._iFJson = new importFromJson_1.ImportFromJson();
-        this._eTJson = new exportToJson_1.ExportToJson();
-        this._vUpgDict = {};
-        this._dbName = dbName;
+        this.upgradeUtil = new utilsUpgrade_1.UtilsUpgrade();
+        this.importFromJsonUtil = new importFromJson_1.ImportFromJson();
+        this.exportToJsonUtil = new exportToJson_1.ExportToJson();
+        this.upgradeVersionDict = {};
+        this.dbName = dbName;
         //    this._encrypted = encrypted;
         //    this._mode = mode;
-        this._version = version;
-        this._vUpgDict = upgDict;
-        this._pathDB = this._uFile.getFilePath(dbName);
-        this._isDBOpen = false;
-        if (this._pathDB.length === 0)
+        this.version = version;
+        this.upgradeVersionDict = upgDict;
+        this.pathDB = this.fileUtil.getFilePath(dbName);
+        this._isDbOpen = false;
+        if (this.pathDB.length === 0)
             throw new Error('Could not generate a path to ' + dbName);
     }
     /**
@@ -2991,7 +3286,7 @@ class Database {
      * @since 0.0.1
      */
     isDBOpen() {
-        return this._isDBOpen;
+        return this._isDbOpen;
     }
     /**
      * Open
@@ -2999,7 +3294,7 @@ class Database {
      * @returns Promise<boolean>
      */
     async open() {
-        this._isDBOpen = false;
+        this._isDbOpen = false;
         //    let password = '';
         try {
             /*
@@ -3021,34 +3316,34 @@ class Database {
               await this._uEncrypt.encryptDatabase(this._pathDB, password);
             }
       */
-            this._mDB = await this._uSQLite.openOrCreateDatabase(this._pathDB /*,
+            this.database = await this.sqliteUtil.openOrCreateDatabase(this.pathDB /*,
             password,*/);
-            const curVersion = await this._uSQLite.getVersion(this._mDB);
-            this._isDBOpen = true;
-            if (this._version > curVersion &&
-                Object.keys(this._vUpgDict).length > 0) {
+            const curVersion = await this.sqliteUtil.getVersion(this.database);
+            this._isDbOpen = true;
+            if (this.version > curVersion &&
+                Object.keys(this.upgradeVersionDict).length > 0) {
                 try {
                     // execute the upgrade flow process
-                    await this._uUpg.onUpgrade(this._mDB, this._vUpgDict, this._dbName, curVersion, this._version);
+                    await this.upgradeUtil.onUpgrade(this.database, this.upgradeVersionDict, this.dbName, curVersion, this.version);
                     // delete the backup database
-                    await this._uFile.deleteFileName(`backup-${this._dbName}`);
+                    await this.fileUtil.deleteFileName(`backup-${this.dbName}`);
                 }
                 catch (err) {
                     // restore the database from backup
                     try {
-                        await this._uFile.restoreFileName(this._dbName, 'backup');
+                        await this.fileUtil.restoreFileName(this.dbName, 'backup');
                     }
                     catch (err) {
-                        return Promise.reject(`Open: ${err}`);
+                        throw new Error(`Open: ${err}`);
                     }
                 }
             }
-            return Promise.resolve();
+            return;
         }
         catch (err) {
-            if (this._isDBOpen)
+            if (this._isDbOpen)
                 this.close();
-            return Promise.reject(`Open: ${err}`);
+            throw new Error(`Open: ${err}`);
         }
     }
     /**
@@ -3057,18 +3352,13 @@ class Database {
      * @returns Promise<boolean>
      */
     async close() {
-        if (this._mDB != null && this._isDBOpen) {
-            this._mDB.close((err) => {
-                if (err) {
-                    let msg = 'Close: Failed in closing: ';
-                    msg += `${this._dbName}  ${err}`;
-                    return Promise.reject(msg);
-                }
-                this._isDBOpen = false;
-                return Promise.resolve();
-            });
-        }
-        return Promise.resolve();
+        this.ensureDatabaseIsOpen();
+        this.database.close((err) => {
+            if (err) {
+                throw new Error('Close failed: ${this.dbName}  ${err}');
+            }
+            this._isDbOpen = false;
+        });
     }
     /**
      * GetVersion
@@ -3076,21 +3366,15 @@ class Database {
      * @returns Promise<number>
      */
     async getVersion() {
-        if (this._mDB != null && this._isDBOpen) {
-            try {
-                const curVersion = await this._uSQLite.getVersion(this._mDB);
-                return Promise.resolve(curVersion);
-            }
-            catch (err) {
-                if (this._isDBOpen)
-                    this.close();
-                return Promise.reject(`getVersion: ${err}`);
-            }
+        this.ensureDatabaseIsOpen();
+        try {
+            const currentVersion = await this.sqliteUtil.getVersion(this.database);
+            return currentVersion;
         }
-        else {
-            let msg = `getVersion: Database ${this._dbName} `;
-            msg += `not opened`;
-            return Promise.reject(msg);
+        catch (err) {
+            if (this._isDbOpen)
+                this.close();
+            throw new Error(`getVersion: ${err}`);
         }
     }
     /**
@@ -3101,14 +3385,14 @@ class Database {
      */
     async deleteDB(dbName) {
         // test if file exists
-        const isExists = this._uFile.isFileExists(dbName);
-        if (isExists && !this._isDBOpen) {
+        const isExists = this.fileUtil.isFileExists(dbName);
+        if (isExists && !this._isDbOpen) {
             // open the database
             try {
                 await this.open();
             }
             catch (err) {
-                return Promise.reject(`DeleteDB: ${err}`);
+                throw new Error(`DeleteDB: ${err}`);
             }
         }
         // close the database
@@ -3116,20 +3400,18 @@ class Database {
             await this.close();
         }
         catch (err) {
-            return Promise.reject('DeleteDB: Close failed');
+            throw new Error('DeleteDB: Close failed');
         }
         // delete the database
         if (isExists) {
             try {
-                await this._uFile.deleteFileName(dbName);
+                await this.fileUtil.deleteFileName(dbName);
             }
             catch (err) {
-                let msg = `DeleteDB: deleteFile ${dbName}`;
-                msg += ` failed ${err}`;
-                return Promise.reject(msg);
+                throw new Error(`DeleteDB: deleteFile ${dbName} failed ${err}`);
             }
         }
-        return Promise.resolve();
+        return;
     }
     /**
      * IsTableExists
@@ -3137,20 +3419,14 @@ class Database {
      * @returns
      */
     async isTableExists(tableName) {
-        if (this._mDB != null && this._isDBOpen) {
-            const isOpen = this._isDBOpen;
-            try {
-                const retB = await this._uJson.isTableExists(this._mDB, isOpen, tableName);
-                return Promise.resolve(retB);
-            }
-            catch (err) {
-                return Promise.reject(`IsTableExists: ${err}`);
-            }
+        this.ensureDatabaseIsOpen();
+        const isOpen = this._isDbOpen;
+        try {
+            const tableExistsResult = await this.jsonUtil.isTableExists(this.database, isOpen, tableName);
+            return tableExistsResult;
         }
-        else {
-            let msg = `isTableExists: Database ${this._dbName} `;
-            msg += `not opened`;
-            return Promise.reject(msg);
+        catch (err) {
+            throw new Error(`IsTableExists: ${err}`);
         }
     }
     /**
@@ -3159,18 +3435,14 @@ class Database {
      * @returns Promise<number>
      */
     async createSyncTable() {
-        if (!this._isDBOpen) {
-            let msg = `CreateSyncTable: Database ${this._dbName} `;
-            msg += `not opened`;
-            return Promise.reject(msg);
-        }
+        this.ensureDatabaseIsOpen();
         let changes = -1;
-        const isOpen = this._isDBOpen;
+        const isOpen = this._isDbOpen;
         // check if the table has already being created
         try {
-            const retB = await this._uJson.isTableExists(this._mDB, isOpen, 'sync_table');
+            const retB = await this.jsonUtil.isTableExists(this.database, isOpen, 'sync_table');
             if (!retB) {
-                const isLastModified = await this._uJson.isLastModified(this._mDB, isOpen);
+                const isLastModified = await this.sqliteUtil.isLastModified(this.database, isOpen);
                 if (isLastModified) {
                     const date = Math.round(new Date().getTime() / 1000);
                     let stmts = `
@@ -3180,23 +3452,22 @@ class Database {
                               );`;
                     stmts += `INSERT INTO sync_table (sync_date) VALUES (
                               "${date}");`;
-                    changes = await this._uSQLite.execute(this._mDB, stmts);
+                    changes = await this.sqliteUtil.execute(this.database, stmts, false);
                     if (changes < 0) {
-                        return Promise.reject(`CreateSyncTable: failed changes < 0`);
+                        throw new Error(`CreateSyncTable: failed changes < 0`);
                     }
                 }
                 else {
-                    return Promise.reject('No last_modified column in tables');
+                    throw new Error('No last_modified column in tables');
                 }
             }
             else {
                 changes = 0;
             }
-            console.log(`>>> CreateSyncTable changes: ${changes}`);
-            return Promise.resolve(changes);
+            return changes;
         }
         catch (err) {
-            return Promise.reject(`CreateSyncTable: ${err}`);
+            throw new Error(`CreateSyncTable: ${err}`);
         }
     }
     /**
@@ -3206,20 +3477,16 @@ class Database {
      * @returns Promise<{result: boolean, message: string}>
      */
     async setSyncDate(syncDate) {
-        if (!this._isDBOpen) {
-            let msg = `SetSyncDate: Database ${this._dbName} `;
-            msg += `not opened`;
-            return { result: false, message: msg };
-        }
+        this.ensureDatabaseIsOpen();
         try {
-            const isTable = await this._uJson.isTableExists(this._mDB, this._isDBOpen, 'sync_table');
+            const isTable = await this.jsonUtil.isTableExists(this.database, this._isDbOpen, 'sync_table');
             if (!isTable) {
-                return Promise.reject('No sync_table available');
+                throw new Error('No sync_table available');
             }
-            const sDate = Math.round(new Date(syncDate).getTime() / 1000);
+            const syncDateUnixTimestamp = Math.round(new Date(syncDate).getTime() / 1000);
             let stmt = `UPDATE sync_table SET sync_date = `;
-            stmt += `${sDate} WHERE id = 1;`;
-            const changes = await this._uSQLite.execute(this._mDB, stmt);
+            stmt += `${syncDateUnixTimestamp} WHERE id = 1;`;
+            const changes = await this.sqliteUtil.execute(this.database, stmt, false);
             if (changes < 0) {
                 return { result: false, message: 'setSyncDate failed' };
             }
@@ -3237,19 +3504,15 @@ class Database {
      * @returns Promise<{syncDate: number, message: string}>
      */
     async getSyncDate() {
-        if (!this._isDBOpen) {
-            let msg = `GetSyncDate: Database ${this._dbName} `;
-            msg += `not opened`;
-            return { syncDate: 0, message: msg };
-        }
+        this.ensureDatabaseIsOpen();
         try {
-            const isTable = await this._uJson.isTableExists(this._mDB, this._isDBOpen, 'sync_table');
+            const isTable = await this.jsonUtil.isTableExists(this.database, this._isDbOpen, 'sync_table');
             if (!isTable) {
-                return Promise.reject('No sync_table available');
+                throw new Error('No sync_table available');
             }
-            const syncDate = await this._eTJson.getSyncDate(this._mDB);
+            const syncDate = await this.exportToJsonUtil.getSyncDate(this.database);
             if (syncDate > 0) {
-                return { syncDate: syncDate };
+                return { syncDate };
             }
             else {
                 return { syncDate: 0, message: `setSyncDate failed` };
@@ -3266,32 +3529,31 @@ class Database {
      * @returns Promise<number>
      */
     async executeSQL(sql, transaction) {
-        if (!this._isDBOpen) {
-            let msg = `ExecuteSQL: Database ${this._dbName} `;
-            msg += `not opened`;
-            return Promise.reject(msg);
-        }
+        this.ensureDatabaseIsOpen();
         try {
-            if (transaction)
-                await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
-            const changes = await this._uSQLite.execute(this._mDB, sql);
+            if (transaction) {
+                await this.sqliteUtil.beginTransaction(this.database, this._isDbOpen);
+            }
+            const changes = await this.sqliteUtil.execute(this.database, sql, false);
             if (changes < 0) {
-                return Promise.reject('ExecuteSQL: changes < 0');
+                throw new Error('ExecuteSQL: changes < 0');
             }
-            if (transaction)
-                await this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
-            return Promise.resolve(changes);
+            if (transaction) {
+                await this.sqliteUtil.commitTransaction(this.database, this._isDbOpen);
+            }
+            return changes;
         }
-        catch (err) {
-            let msg = `ExecuteSQL: ${err}`;
+        catch (executeError) {
+            let message = `${executeError}`;
             try {
-                if (transaction)
-                    await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
+                if (transaction) {
+                    await this.sqliteUtil.rollbackTransaction(this.database, this._isDbOpen);
+                }
             }
-            catch (err) {
-                msg += ` : ${err}`;
+            catch (rollbackErr) {
+                message += ` : ${rollbackErr}`;
             }
-            return Promise.reject(`ExecuteSQL: ${msg}`);
+            throw new Error(`ExecuteSQL: ${message}`);
         }
     }
     /**
@@ -3302,17 +3564,13 @@ class Database {
      * @returns Promise<any[]>
      */
     async selectSQL(sql, values) {
-        if (!this._isDBOpen) {
-            let msg = `SelectSQL: Database ${this._dbName} `;
-            msg += `not opened`;
-            return Promise.reject(msg);
-        }
+        this.ensureDatabaseIsOpen();
         try {
-            const retArr = await this._uSQLite.queryAll(this._mDB, sql, values);
-            return Promise.resolve(retArr);
+            const selectResult = await this.sqliteUtil.queryAll(this.database, sql, values);
+            return selectResult;
         }
         catch (err) {
-            return Promise.reject(`SelectSQL: ${err}`);
+            throw new Error(`SelectSQL: ${err}`);
         }
     }
     /**
@@ -3323,39 +3581,40 @@ class Database {
      * @returns Promise<{changes:number, lastId:number}>
      */
     async runSQL(statement, values, transaction) {
-        if (!this._isDBOpen) {
-            let msg = `RunSQL: Database ${this._dbName} `;
-            msg += `not opened`;
-            return Promise.reject(msg);
-        }
-        const retRes = { changes: -1, lastId: -1 };
+        this.ensureDatabaseIsOpen();
+        const result = { changes: -1, lastId: -1 };
         let initChanges = -1;
         try {
-            initChanges = await this._uSQLite.dbChanges(this._mDB);
+            initChanges = await this.sqliteUtil.dbChanges(this.database);
             // start a transaction
-            if (transaction)
-                await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
+            if (transaction) {
+                await this.sqliteUtil.beginTransaction(this.database, this._isDbOpen);
+            }
         }
         catch (err) {
-            return Promise.reject(`ExecSet: ${err}`);
+            throw new Error(`RunSQL: ${err}`);
         }
         try {
-            const lastId = await this._uSQLite.prepareRun(this._mDB, statement, values);
+            const lastId = await this.sqliteUtil.prepareRun(this.database, statement, values, false);
             if (lastId < 0) {
-                if (transaction)
-                    await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
-                return Promise.reject(`RunSQL: return LastId < 0`);
+                if (transaction) {
+                    await this.sqliteUtil.rollbackTransaction(this.database, this._isDbOpen);
+                }
+                throw new Error(`RunSQL: return LastId < 0`);
+            }
+            if (transaction) {
+                await this.sqliteUtil.commitTransaction(this.database, this._isDbOpen);
             }
-            if (transaction)
-                await this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
-            retRes.changes = (await this._uSQLite.dbChanges(this._mDB)) - initChanges;
-            retRes.lastId = lastId;
-            return Promise.resolve(retRes);
+            result.changes =
+                (await this.sqliteUtil.dbChanges(this.database)) - initChanges;
+            result.lastId = lastId;
+            return result;
         }
         catch (err) {
-            if (transaction)
-                await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
-            return Promise.reject(`RunSQL: ${err}`);
+            if (transaction) {
+                await this.sqliteUtil.rollbackTransaction(this.database, this._isDbOpen);
+            }
+            throw new Error(`RunSQL: ${err}`);
         }
     }
     /**
@@ -3365,103 +3624,124 @@ class Database {
      * @returns Promise<{changes:number, lastId:number}>
      */
     async execSet(set, transaction) {
-        if (!this._isDBOpen) {
-            let msg = `ExecSet: Database ${this._dbName} `;
-            msg += `not opened`;
-            return Promise.reject(msg);
-        }
-        const retRes = { changes: -1, lastId: -1 };
+        this.ensureDatabaseIsOpen();
+        const result = { changes: -1, lastId: -1 };
         let initChanges = -1;
         try {
-            initChanges = await this._uSQLite.dbChanges(this._mDB);
+            initChanges = await this.sqliteUtil.dbChanges(this.database);
             // start a transaction
-            if (transaction)
-                await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
+            if (transaction) {
+                await this.sqliteUtil.beginTransaction(this.database, this._isDbOpen);
+            }
         }
         catch (err) {
-            return Promise.reject(`ExecSet: ${err}`);
+            throw new Error(`ExecSet: ${err}`);
         }
         try {
-            retRes.lastId = await this._uSQLite.executeSet(this._mDB, set);
-            if (transaction)
-                await this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
-            retRes.changes = (await this._uSQLite.dbChanges(this._mDB)) - initChanges;
-            return Promise.resolve(retRes);
+            result.lastId = await this.sqliteUtil.executeSet(this.database, set, false);
+            if (transaction) {
+                await this.sqliteUtil.commitTransaction(this.database, this._isDbOpen);
+            }
+            result.changes =
+                (await this.sqliteUtil.dbChanges(this.database)) - initChanges;
+            return result;
         }
         catch (err) {
-            const msg = err;
+            const message = err;
             try {
-                if (transaction)
-                    await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
+                if (transaction) {
+                    await this.sqliteUtil.rollbackTransaction(this.database, this._isDbOpen);
+                }
             }
             catch (err) {
-                return Promise.reject(`ExecSet: ${msg}: ` + `${err}`);
+                throw new Error(`ExecSet: ${message}: ` + `${err}`);
             }
         }
     }
-    async getTableList() {
-        if (!this._isDBOpen) {
-            let msg = `GetTableList: Database ${this._dbName} `;
-            msg += `not opened`;
-            return Promise.reject(msg);
+    async deleteExportedRows() {
+        this.ensureDatabaseIsOpen();
+        try {
+            await this.exportToJsonUtil.delExportedRows(this.database);
+            return;
+        }
+        catch (err) {
+            throw new Error(`DeleteExportedRows: ${err}`);
         }
+    }
+    /**
+     * GetTableList
+     * get the table's list
+     * @returns
+     */
+    async getTableList() {
+        this.ensureDatabaseIsOpen();
         try {
-            const retArr = await this._uDrop.getTablesNames(this._mDB);
-            return Promise.resolve(retArr);
+            const tableNames = await this.sqliteUtil.getTablesNames(this.database);
+            return tableNames;
         }
         catch (err) {
-            return Promise.reject(`GetTableList: ${err}`);
+            throw new Error(`GetTableList: ${err}`);
         }
     }
     async importJson(jsonData) {
         let changes = 0;
-        if (this._isDBOpen) {
-            try {
-                if (jsonData.tables && jsonData.tables.length > 0) {
-                    // create the database schema
-                    changes = await this._iFJson.createDatabaseSchema(this._mDB, jsonData);
-                    if (changes != -1) {
-                        // create the tables data
-                        changes += await this._iFJson.createTablesData(this._mDB, jsonData);
-                    }
-                }
-                if (jsonData.views && jsonData.views.length > 0) {
-                    // create the views
-                    changes += await this._iFJson.createViews(this._mDB, jsonData);
+        this.ensureDatabaseIsOpen();
+        try {
+            // set Foreign Keys Off
+            await this.sqliteUtil.setForeignKeyConstraintsEnabled(this.database, false);
+            if (jsonData.tables && jsonData.tables.length > 0) {
+                // create the database schema
+                changes = await this.importFromJsonUtil.createDatabaseSchema(this.database, jsonData);
+                if (changes != -1) {
+                    // create the tables data
+                    changes += await this.importFromJsonUtil.createTablesData(this.database, jsonData);
                 }
-                return Promise.resolve(changes);
             }
-            catch (err) {
-                return Promise.reject(`ImportJson: ${err}`);
+            if (jsonData.views && jsonData.views.length > 0) {
+                // create the views
+                changes += await this.importFromJsonUtil.createViews(this.database, jsonData);
             }
+            // set Foreign Keys On
+            await this.sqliteUtil.setForeignKeyConstraintsEnabled(this.database, true);
+            return changes;
         }
-        else {
-            return Promise.reject(`ImportJson: database is closed`);
+        catch (err) {
+            throw new Error(`ImportJson: ${err}`);
         }
     }
     async exportJson(mode) {
         const inJson = {};
-        inJson.database = this._dbName.slice(0, -9);
-        inJson.version = this._version;
+        inJson.database = this.dbName.slice(0, -9);
+        inJson.version = this.version;
         inJson.encrypted = false;
         inJson.mode = mode;
-        if (this._isDBOpen) {
-            try {
-                const retJson = await this._eTJson.createExportObject(this._mDB, inJson);
-                const isValid = this._uJson.isJsonSQLite(retJson);
-                if (isValid) {
-                    return Promise.resolve(retJson);
-                }
-                else {
-                    return Promise.reject(`ExportJson: retJson not valid`);
-                }
+        this.ensureDatabaseIsOpen();
+        try {
+            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) {
+                const msg = `ExportJson: return Object is empty ` + `No data to synchronize`;
+                throw new Error(msg);
             }
-            catch (err) {
-                return Promise.reject(`ExportJson: ${err}`);
+            const isValid = this.jsonUtil.isJsonSQLite(jsonResult);
+            if (isValid) {
+                return jsonResult;
+            }
+            else {
+                throw new Error(`ExportJson: retJson not valid`);
             }
         }
-        else {
-            return Promise.reject(`ExportJson: database is closed`);
+        catch (err) {
+            throw new Error(`ExportJson: ${err}`);
+        }
+    }
+    /**
+     * Throws an error if `this._isDbOpen` is `false`.
+     */
+    ensureDatabaseIsOpen() {
+        if (!this._isDbOpen || !this.database) {
+            throw new Error(`getVersion: Database ${this.dbName} is not open yet. You should open it first.`);
         }
     }
 }
@@ -3474,49 +3754,15 @@ const utilsJson_1 = utilsJson;
 const utilsFile_1 = utilsFile;
 class CapacitorSQLite {
     constructor() {
-        this._versionUpgrades = {};
-        this._dbDict = {};
-        this._uFile = new utilsFile_1.UtilsFile();
-        this._uJson = new utilsJson_1.UtilsJson();
-    }
-    async initWebStore() {
-        return Promise.reject('Method not implemented.');
-    }
-    async saveToStore(options) {
-        console.log(`${JSON.stringify(options)}`);
-        return Promise.reject('Method not implemented.');
-    }
-    async isSecretStored() {
-        return Promise.reject('Method not implemented.');
-    }
-    async setEncryptionSecret(options) {
-        console.log(`${JSON.stringify(options)}`);
-        return Promise.reject('Method not implemented.');
-    }
-    async changeEncryptionSecret(options) {
-        console.log(`${JSON.stringify(options)}`);
-        return Promise.reject('Method not implemented.');
-    }
-    async getNCDatabasePath(options) {
-        console.log('getNCDatabasePath', options);
-        return Promise.reject('Method not implemented.');
-    }
-    async createNCConnection(options) {
-        console.log('createNCConnection', options);
-        return Promise.reject('Method not implemented.');
-    }
-    async closeNCConnection(options) {
-        console.log('closeNCConnection', options);
-        return Promise.reject('Method not implemented.');
-    }
-    async isNCDatabase(options) {
-        console.log('isNCDatabase', options);
-        return Promise.reject('Method not implemented.');
+        this.versionUpgrades = {};
+        this.databases = {};
+        this.fileUtil = new utilsFile_1.UtilsFile();
+        this.jsonUtil = new utilsJson_1.UtilsJson();
     }
     async createConnection(options) {
-        const keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
+        const optionKeys = Object.keys(options);
+        if (!optionKeys.includes('database')) {
+            throw new Error('Must provide a database name');
         }
         const dbName = options.database;
         const version = options.version ? options.version : 1;
@@ -3532,612 +3778,393 @@ class CapacitorSQLite {
             ? options.mode
             : 'no-encryption';
         */
-        let upgDict = {};
-        const vUpgKeys = Object.keys(this._versionUpgrades);
-        if (vUpgKeys.length !== 0 && vUpgKeys.includes(dbName)) {
-            upgDict = this._versionUpgrades[dbName];
-        }
-        try {
-            const mDb = new Database_1.Database(dbName + 'SQLite.db', 
-            /*        encrypted,
-            inMode,
-    */
-            version, upgDict);
-            this._dbDict[dbName] = mDb;
-            return Promise.resolve();
-        }
-        catch (err) {
-            return Promise.reject(err);
-        }
+        let upgrades = {};
+        const versionUpgradeKeys = Object.keys(this.versionUpgrades);
+        if (versionUpgradeKeys.length !== 0 &&
+            versionUpgradeKeys.includes(dbName)) {
+            upgrades = this.versionUpgrades[dbName];
+        }
+        const databaseConnection = new Database_1.Database(dbName + 'SQLite.db', 
+        /*        encrypted,
+        inMode,
+        */
+        version, upgrades);
+        this.databases[dbName] = databaseConnection;
+        return;
     }
     async closeConnection(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.resolve();
-        }
-        const mDB = this._dbDict[dbName];
-        if (mDB.isDBOpen()) {
+        const dbName = this.getOptionValue(options, 'database');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
+        if (database.isDBOpen()) {
             // close the database
             try {
-                await mDB.close();
+                await database.close();
             }
             catch (err) {
-                return Promise.reject('CloseConnection command failed: ' +
-                    'close ' +
-                    dbName +
-                    ' failed ' +
-                    err);
+                throw new Error(`CloseConnection command failed:  close ${dbName} failed ${err.message}`);
             }
         }
         // remove the connection from dictionary
-        delete this._dbDict[dbName];
-        return Promise.resolve();
+        delete this.databases[dbName];
     }
     async echo(options) {
-        const keys = Object.keys(options);
-        if (!keys.includes('value')) {
-            return Promise.reject('Must provide a value to echo');
-        }
-        const ret = {};
-        ret.value = options.value;
-        return Promise.resolve(ret);
+        const echoValue = this.getOptionValue(options, 'value');
+        const echoResult = {};
+        echoResult.value = echoValue;
+        return echoResult;
     }
     async open(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject(`Open: No available connection for ${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            await mDB.open();
-            return Promise.resolve();
+            await database.open();
+            return;
         }
         catch (err) {
-            return Promise.reject(`Open: ${err}`);
+            throw new Error(`Open: ${err}`);
         }
     }
     async close(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject(`Close: No available connection for ${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            await mDB.close();
-            return Promise.resolve();
+            await database.close();
+            return;
         }
         catch (err) {
-            return Promise.reject(`Close: ${err}`);
+            throw new Error(`Close: ${err}`);
         }
     }
-    async getUrl() {
-        return Promise.reject('Method not implemented.');
-    }
     async getVersion(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject(`Open: No available connection for ${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            const version = await mDB.getVersion();
-            const ret = {};
-            ret.version = version;
-            return Promise.resolve(ret);
+            const version = await database.getVersion();
+            const versionResult = {};
+            versionResult.version = version;
+            return versionResult;
         }
         catch (err) {
-            return Promise.reject(`GetVersion: ${err}`);
+            throw new Error(`GetVersion: ${err}`);
         }
     }
     async getTableList(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject(`Open: No available connection for ${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            const tableList = await mDB.getTableList();
-            const ret = {};
-            ret.values = tableList;
-            return Promise.resolve(ret);
+            const tableList = await database.getTableList();
+            const tableListResult = {};
+            tableListResult.values = tableList;
+            return tableListResult;
         }
         catch (err) {
-            return Promise.reject(`GetTableList: ${err}`);
+            throw new Error(`GetTableList: ${err}`);
         }
     }
     async execute(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        if (!keys.includes('statements') || options.statements.length === 0) {
-            return Promise.reject('Must provide raw SQL statements');
-        }
-        const dbName = options.database;
-        const statements = options.statements;
-        let transaction;
-        if (!keys.includes('transaction')) {
-            transaction = true;
-        }
-        else {
-            transaction = options.transaction;
-        }
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject(`Execute: No available connection for ${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const statements = this.getOptionValue(options, 'statements');
+        const transaction = this.getOptionValue(options, 'transaction', true);
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            const ret = await mDB.executeSQL(statements, transaction);
-            if (ret < 0) {
-                return Promise.reject('Execute failed changes < 0');
+            const executeResult = await database.executeSQL(statements, transaction);
+            if (executeResult < 0) {
+                throw new Error('Execute failed changes < 0');
             }
             else {
-                return Promise.resolve({ changes: { changes: ret } });
+                return { changes: { changes: executeResult } };
             }
         }
         catch (err) {
-            return Promise.reject(`Execute failed: ${err}`);
+            throw new Error(`Execute failed: ${err}`);
         }
     }
     async executeSet(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        if (!keys.includes('set') || options.set.length === 0) {
-            return Promise.reject('Must provide a non-empty set of SQL statements');
-        }
-        const dbName = options.database;
-        const setOfStatements = options.set;
-        let transaction;
-        if (!keys.includes('transaction')) {
-            transaction = true;
-        }
-        else {
-            transaction = options.transaction;
-        }
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject(`ExecuteSet: No available connection for ${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const setOfStatements = this.getOptionValue(options, 'set');
+        const transaction = this.getOptionValue(options, 'transaction', true);
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         for (const sStmt of setOfStatements) {
             if (!('statement' in sStmt) || !('values' in sStmt)) {
-                return Promise.reject('ExecuteSet: Must provide a set as ' + 'Array of {statement,values}');
+                throw new Error('ExecuteSet: Must provide a set as ' + 'Array of {statement,values}');
             }
         }
         try {
-            const ret = await mDB.execSet(setOfStatements, transaction);
-            if (ret < 0) {
-                return Promise.reject(`ExecuteSet failed changes <0`);
+            const execSetResult = await database.execSet(setOfStatements, transaction);
+            if (execSetResult < 0) {
+                throw new Error(`ExecuteSet failed changes <0`);
             }
             else {
-                return Promise.resolve({ changes: ret });
+                return { changes: execSetResult };
             }
         }
         catch (err) {
-            return Promise.reject(`ExecuteSet failed: ${err}`);
+            throw new Error(`ExecuteSet failed: ${err}`);
         }
     }
     async run(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        if (!keys.includes('statement') || options.statement.length === 0) {
-            return Promise.reject('Must provide a query statement');
-        }
-        if (!keys.includes('values')) {
-            return Promise.reject('Must provide an Array of values');
-        }
-        const dbName = options.database;
-        const statement = options.statement;
-        const values = options.values.length > 0 ? options.values : [];
-        let transaction;
-        if (!keys.includes('transaction')) {
-            transaction = true;
-        }
-        else {
-            transaction = options.transaction;
-        }
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject(`Run: No available connection for ${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const statement = this.getOptionValue(options, 'statement');
+        const values = this.getOptionValue(options, 'values', []);
+        const transaction = this.getOptionValue(options, 'transaction', true);
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            const ret = await mDB.runSQL(statement, values, transaction);
-            return Promise.resolve({ changes: ret });
+            const runResult = await database.runSQL(statement, values, transaction);
+            return { changes: runResult };
         }
         catch (err) {
-            return Promise.reject(`RUN failed: ${err} `);
+            throw new Error(`RUN failed: ${err} `);
         }
     }
     async query(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        if (!keys.includes('statement') || options.statement.length === 0) {
-            return Promise.reject('Must provide a query statement');
+        const dbName = this.getOptionValue(options, 'database');
+        const statement = this.getOptionValue(options, 'statement');
+        const values = this.getOptionValue(options, 'values', []);
+        if (statement.length === 0) {
+            throw new Error('Statement may not be an empty string.');
         }
-        if (!keys.includes('values')) {
-            return Promise.reject('Must provide an Array of any');
-        }
-        const dbName = options.database;
-        const statement = options.statement;
-        const values = options.values.length > 0 ? options.values : [];
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject(`Query: No available connection for ${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
-        let ret = [];
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            ret = await mDB.selectSQL(statement, values);
-            return Promise.resolve({ values: ret });
+            const queryResult = await database.selectSQL(statement, values);
+            return { values: queryResult };
         }
         catch (err) {
-            return Promise.reject(`Query failed: ${err}`);
+            throw new Error(`Query failed: ${err}`);
         }
     }
     async isDBExists(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject('IsDBExists command failed: No available ' + 'connection for ' + dbName);
-        }
-        const isExists = this._uFile.isFileExists(dbName + 'SQLite.db');
-        return Promise.resolve({
-            result: isExists,
-        });
+        const dbName = this.getOptionValue(options, 'database');
+        // Throw an error, if db connection is not opened yet:
+        this.getDatabaseConnectionOrThrowError(dbName);
+        const isExists = this.fileUtil.isFileExists(dbName + 'SQLite.db');
+        return { result: isExists };
     }
     async isDBOpen(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject('isDBOpen command failed: No available ' + 'connection for ' + dbName);
-        }
-        const mDB = this._dbDict[dbName];
-        const isOpen = await mDB.isDBOpen();
-        return Promise.resolve({ result: isOpen });
+        const dbName = this.getOptionValue(options, 'database');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
+        const isOpen = await database.isDBOpen();
+        return { result: isOpen };
     }
     async isDatabase(options) {
-        const keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        const isExists = this._uFile.isFileExists(dbName + 'SQLite.db');
-        return Promise.resolve({
-            result: isExists,
-        });
+        const dbName = this.getOptionValue(options, 'database');
+        const isExists = this.fileUtil.isFileExists(dbName + 'SQLite.db');
+        return { result: isExists };
     }
     async isTableExists(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        if (!keys.includes('table')) {
-            return Promise.reject('Must provide a table name');
-        }
-        const tableName = options.table;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject('isTableExists command failed: No available ' +
-                'connection for ' +
-                dbName);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const tableName = this.getOptionValue(options, 'table');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            const res = await mDB.isTableExists(tableName);
-            return Promise.resolve({ result: res });
+            const isTableExistsResult = await database.isTableExists(tableName);
+            return { result: isTableExistsResult };
         }
         catch (err) {
-            return Promise.reject(`isTableExists: ${err}`);
+            throw new Error(`isTableExists: ${err}`);
         }
     }
     async deleteDatabase(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject('deleteDatabase: No available connection for ' + `${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            await mDB.deleteDB(dbName + 'SQLite.db');
-            return Promise.resolve();
+            await database.deleteDB(dbName + 'SQLite.db');
+            return;
         }
         catch (err) {
-            return Promise.reject(`Delete: ${err}`);
+            throw new Error(`Delete: ${err}`);
         }
     }
     async isJsonValid(options) {
-        const keys = Object.keys(options);
-        if (!keys.includes('jsonstring')) {
-            return Promise.reject('Must provide a json object');
-        }
-        const jsonStrObj = options.jsonstring;
-        const jsonObj = JSON.parse(jsonStrObj);
-        const isValid = this._uJson.isJsonSQLite(jsonObj);
+        const jsonString = this.getOptionValue(options, 'jsonstring');
+        const jsonObj = JSON.parse(jsonString);
+        const isValid = this.jsonUtil.isJsonSQLite(jsonObj);
         if (!isValid) {
-            return Promise.reject('Stringify Json Object not Valid');
+            throw new Error('Stringify Json Object not Valid');
         }
         else {
-            return Promise.resolve({ result: true });
+            return { result: true };
         }
     }
     async importFromJson(options) {
         var _a, _b;
-        const keys = Object.keys(options);
-        if (!keys.includes('jsonstring')) {
-            return Promise.reject('Must provide a json object');
-        }
-        const jsonStrObj = options.jsonstring;
-        const jsonObj = JSON.parse(jsonStrObj);
-        const isValid = this._uJson.isJsonSQLite(jsonObj);
+        const jsonString = this.getOptionValue(options, 'jsonstring');
+        const jsonObj = JSON.parse(jsonString);
+        const isValid = this.jsonUtil.isJsonSQLite(jsonObj);
         if (!isValid) {
-            return Promise.reject('Must provide a valid JsonSQLite Object');
+            throw new Error('Must provide a valid JsonSQLite Object');
         }
         const vJsonObj = jsonObj;
         const dbName = `${vJsonObj.database}SQLite.db`;
-        const dbVersion = (_a = vJsonObj.version) !== null && _a !== void 0 ? _a : 1;
+        const targetDbVersion = (_a = vJsonObj.version) !== null && _a !== void 0 ? _a : 1;
         const mode = vJsonObj.mode;
         const overwrite = (_b = vJsonObj.overwrite) !== null && _b !== void 0 ? _b : false;
         //    const encrypted: boolean = vJsonObj.encrypted ?? false;
         //    const mode: string = encrypted ? 'secret' : 'no-encryption';
         // Create the database
-        const mDb = new Database_1.Database(dbName, 
-        /*encrypted, mode, */ dbVersion, {});
+        const database = new Database_1.Database(dbName, 
+        /*encrypted, mode, */
+        targetDbVersion, {});
         try {
             if (overwrite && mode === 'full') {
-                const isExists = this._uFile.isFileExists(dbName);
+                const isExists = this.fileUtil.isFileExists(dbName);
                 if (isExists) {
-                    await this._uFile.deleteFileName(dbName);
+                    await this.fileUtil.deleteFileName(dbName);
                 }
             }
             // Open the database
-            await mDb.open();
-            const tableList = await mDb.getTableList();
+            await database.open();
+            const tableList = await database.getTableList();
             if (mode === 'full' && tableList.length > 0) {
-                const curVersion = await mDb.getVersion();
-                if (dbVersion < curVersion) {
-                    return Promise.reject(`ImportFromJson: Cannot import a version lower than ${curVersion}`);
+                const currentVersion = await database.getVersion();
+                if (targetDbVersion < currentVersion) {
+                    throw new Error(`ImportFromJson: Cannot import a version lower than ${currentVersion}`);
                 }
-                if (curVersion === dbVersion) {
-                    return Promise.resolve({ changes: { changes: 0 } });
+                if (currentVersion === targetDbVersion) {
+                    return { changes: { changes: 0 } };
                 }
             }
             // Import the JsonSQLite Object
-            const changes = await mDb.importJson(vJsonObj);
+            const changes = await database.importJson(vJsonObj);
             // Close the database
-            await mDb.close();
-            return Promise.resolve({ changes: { changes: changes } });
+            await database.close();
+            return { changes: { changes: changes } };
         }
         catch (err) {
-            return Promise.reject(`ImportFromJson: ${err}`);
+            throw new Error(`ImportFromJson: ${err}`);
         }
     }
     async exportToJson(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        if (!keys.includes('jsonexportmode')) {
-            return Promise.reject('Must provide a json export mode');
-        }
-        const dbName = options.database;
-        const exportMode = options.jsonexportmode;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject('exportToJson: No available connection for ' + `${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const exportMode = this.getOptionValue(options, 'jsonexportmode');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            const ret = await mDB.exportJson(exportMode);
-            const keys = Object.keys(ret);
-            if (keys.includes('message')) {
-                return Promise.reject(`exportToJson: ${ret.message}`);
+            const exportJsonResult = await database.exportJson(exportMode);
+            const resultKeys = Object.keys(exportJsonResult);
+            if (resultKeys.includes('message')) {
+                throw new Error(`exportToJson: ${exportJsonResult.message}`);
             }
             else {
-                return Promise.resolve({ export: ret });
+                return { export: exportJsonResult };
             }
         }
         catch (err) {
-            return Promise.reject(`exportToJson: ${err}`);
+            throw new Error(`exportToJson: ${err}`);
         }
     }
     async createSyncTable(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject('CreateSyncTable: No available connection for ' + `${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            const ret = await mDB.createSyncTable();
-            return Promise.resolve({ changes: { changes: ret } });
+            const createTableSyncResult = await database.createSyncTable();
+            return {
+                changes: { changes: createTableSyncResult },
+            };
         }
         catch (err) {
-            return Promise.reject(`createSyncTable: ${err}`);
+            throw new Error(`createSyncTable: ${err}`);
         }
     }
     async setSyncDate(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        if (!keys.includes('syncdate')) {
-            return Promise.reject('Must provide a synchronization date');
-        }
-        const dbName = options.database;
-        const syncDate = options.syncdate;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject(`SetSyncDate: No available connection for ${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const syncDate = this.getOptionValue(options, 'syncdate');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            await mDB.setSyncDate(syncDate);
-            return Promise.resolve();
+            await database.setSyncDate(syncDate);
+            return;
         }
         catch (err) {
-            return Promise.reject(`SetSyncDate: ${err}`);
+            throw new Error(`SetSyncDate: ${err}`);
         }
     }
     async getSyncDate(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
-        }
-        const dbName = options.database;
-        keys = Object.keys(this._dbDict);
-        if (!keys.includes(dbName)) {
-            return Promise.reject(`GetSyncDate: No available connection for ${dbName}`);
-        }
-        const mDB = this._dbDict[dbName];
+        const dbName = this.getOptionValue(options, 'database');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
         try {
-            const ret = await mDB.getSyncDate();
+            const ret = await database.getSyncDate();
             return Promise.resolve(ret);
         }
         catch (err) {
-            return Promise.reject(`GetSyncDate: ${err}`);
+            throw new Error(`GetSyncDate: ${err}`);
         }
     }
-    async addUpgradeStatement(options) {
-        let keys = Object.keys(options);
-        if (!keys.includes('database')) {
-            return Promise.reject('Must provide a database name');
+    async deleteExportedRows(options) {
+        const dbName = this.getOptionValue(options, 'database');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
+        try {
+            await database.deleteExportedRows();
+            return Promise.resolve();
         }
-        if (!keys.includes('upgrade')) {
-            return Promise.reject('Must provide an upgrade statement');
+        catch (err) {
+            throw new Error(`DeleteExportedRows: ${err}`);
         }
-        const dbName = options.database;
-        const upgrade = options.upgrade[0];
-        keys = Object.keys(upgrade);
-        if (!keys.includes('fromVersion') ||
-            !keys.includes('toVersion') ||
-            !keys.includes('statement')) {
-            return Promise.reject('Must provide an upgrade capSQLiteVersionUpgrade Object');
-        }
-        if (typeof upgrade.fromVersion != 'number') {
-            return Promise.reject('ugrade.fromVersion must be a number');
-        }
-        const upgVDict = {};
-        upgVDict[upgrade.fromVersion] = upgrade;
-        this._versionUpgrades[dbName] = upgVDict;
-        return Promise.resolve();
+    }
+    async addUpgradeStatement(options) {
+        const dbName = this.getOptionValue(options, 'database');
+        const upgrades = this.getOptionValue(options, 'upgrade');
+        const firstUpgrade = upgrades[0];
+        const versionUpgradeKeys = Object.keys(firstUpgrade);
+        if (!versionUpgradeKeys.includes('fromVersion') ||
+            !versionUpgradeKeys.includes('toVersion') ||
+            !versionUpgradeKeys.includes('statement')) {
+            throw new Error('Must provide an upgrade capSQLiteVersionUpgrade Object');
+        }
+        if (typeof firstUpgrade.fromVersion != 'number') {
+            throw new Error('upgrade.fromVersion must be a number');
+        }
+        const upgradeVersionDict = {};
+        upgradeVersionDict[firstUpgrade.fromVersion] = firstUpgrade;
+        this.versionUpgrades[dbName] = upgradeVersionDict;
+        return;
     }
     async copyFromAssets(options) {
-        const keys = Object.keys(options);
-        const mOverwrite = keys.includes('overwrite') ? options.overwrite : true;
+        const overwrite = this.getOptionValue(options, 'overwrite', false);
         // check if the assets/database folder exists
-        const assetsDbPath = this._uFile.getAssetsDatabasesPath();
-        const res = this._uFile.isPathExists(assetsDbPath);
-        if (res) {
+        const assetsDbPath = this.fileUtil.getAssetsDatabasesPath();
+        const pathExists = this.fileUtil.isPathExists(assetsDbPath);
+        if (pathExists) {
             // get the database files
-            const dbList = await this._uFile.getFileList(assetsDbPath);
+            const dbList = await this.fileUtil.getFileList(assetsDbPath);
             // loop through the database files
             dbList.forEach(async (db) => {
                 if (db.substring(db.length - 3) === '.db') {
                     // for each copy the file to the Application database folder
-                    await this._uFile.copyFromAssetToDatabase(db, mOverwrite);
+                    await this.fileUtil.copyFromAssetToDatabase(db, overwrite);
                 }
                 if (db.substring(db.length - 4) === '.zip') {
-                    await this._uFile.unzipDatabase(db, mOverwrite);
+                    await this.fileUtil.unzipDatabase(db, overwrite);
                 }
             });
-            return Promise.resolve();
+            return;
         }
         else {
-            return Promise.reject('CopyFromAssets: assets/databases folder does not exist');
+            throw new Error('CopyFromAssets: assets/databases folder does not exist');
         }
     }
     async getDatabaseList() {
         // get the database folder
-        const pathDatabase = this._uFile.getDatabasesPath();
+        const pathDatabase = this.fileUtil.getDatabasesPath();
         // get the list of databases
-        const files = await this._uFile.getFileList(pathDatabase);
+        const files = await this.fileUtil.getFileList(pathDatabase);
         if (files.length > 0) {
-            return Promise.resolve({ values: files });
+            return { values: files };
         }
         else {
-            return Promise.reject(`isTableExists: No databases found`);
+            throw new Error(`isTableExists: No databases found`);
         }
     }
-    async getMigratableDbList(options) {
-        console.log('getCordovaDbList', options);
-        return Promise.reject('Method not implemented.');
-    }
-    async addSQLiteSuffix(options) {
-        console.log(`${JSON.stringify(options)}`);
-        throw new Error('Method not implemented.');
-    }
-    async deleteOldDatabases(options) {
-        console.log(`${JSON.stringify(options)}`);
-        throw new Error('Method not implemented.');
-    }
     async checkConnectionsConsistency(options) {
-        const keys = Object.keys(options);
-        if (!keys.includes('dbNames')) {
-            return Promise.reject(`Must provide a list of connection's name`);
-        }
-        const dbNames = options.dbNames;
-        const ret = {};
-        ret.result = false;
+        const dbNames = this.getOptionValue(options, 'dbNames');
+        const checkConsistencyResult = {};
+        checkConsistencyResult.result = false;
         try {
-            let inConnectionsSet = new Set(Object.keys(this._dbDict));
+            let inConnectionsSet = new Set(Object.keys(this.databases));
             const outConnectionSet = new Set(dbNames);
             if (outConnectionSet.size === 0) {
-                await this.resetDbDict(Object.keys(this._dbDict));
-                return Promise.resolve(ret);
+                await this.resetDbDict(Object.keys(this.databases));
+                return Promise.resolve(checkConsistencyResult);
             }
             if (inConnectionsSet.size < outConnectionSet.size) {
-                await this.resetDbDict(Object.keys(this._dbDict));
-                return Promise.resolve(ret);
+                await this.resetDbDict(Object.keys(this.databases));
+                return Promise.resolve(checkConsistencyResult);
             }
             if (inConnectionsSet.size > outConnectionSet.size) {
                 for (const key of inConnectionsSet) {
@@ -4148,25 +4175,25 @@ class CapacitorSQLite {
                     }
                 }
             }
-            inConnectionsSet = new Set(Object.keys(this._dbDict));
+            inConnectionsSet = new Set(Object.keys(this.databases));
             if (inConnectionsSet.size === outConnectionSet.size) {
-                const symDiffSet = await this.symmetricDifference(inConnectionsSet, outConnectionSet);
-                if (symDiffSet.size === 0) {
-                    ret.result = true;
-                    return Promise.resolve(ret);
+                const symmetricDifferenceSet = await this.symmetricDifference(inConnectionsSet, outConnectionSet);
+                if (symmetricDifferenceSet.size === 0) {
+                    checkConsistencyResult.result = true;
+                    return checkConsistencyResult;
                 }
                 else {
-                    await this.resetDbDict(Object.keys(this._dbDict));
-                    return Promise.resolve(ret);
+                    await this.resetDbDict(Object.keys(this.databases));
+                    return checkConsistencyResult;
                 }
             }
             else {
-                await this.resetDbDict(Object.keys(this._dbDict));
-                return Promise.resolve(ret);
+                await this.resetDbDict(Object.keys(this.databases));
+                return checkConsistencyResult;
             }
         }
         catch (err) {
-            return Promise.reject(`CheckConnectionsConsistency: ${err}`);
+            throw new Error(`CheckConnectionsConsistency: ${err}`);
         }
     }
     async resetDbDict(keys) {
@@ -4178,7 +4205,7 @@ class CapacitorSQLite {
             }
         }
         catch (err) {
-            return Promise.reject(`ResetDbDict: ${err}`);
+            throw new Error(`ResetDbDict: ${err}`);
         }
     }
     async symmetricDifference(setA, setB) {
@@ -4191,7 +4218,95 @@ class CapacitorSQLite {
                 difference.add(elem);
             }
         }
-        return Promise.resolve(difference);
+        return difference;
+    }
+    /**
+     * Returns a database connection, if it already exists.
+     * If the conneciton does not exist yet, it throws an error.
+     *
+     * @param dbName
+     * @returns
+     */
+    getDatabaseConnectionOrThrowError(dbName) {
+        const databaseNames = Object.keys(this.databases);
+        if (!databaseNames.includes(dbName)) {
+            throw new Error(`No connection available for database "${dbName}"`);
+        }
+        return this.databases[dbName];
+    }
+    /**
+     * Gets the value of an option from the options object.
+     * If the `optionKey` does not exist and there is no `defaultValue` defined, an exception is thrown.
+     * If the `optionKey` does not exist but there is a `defaultValue`, the `defaultValue` is returned.
+     *
+     * @param options
+     * @param optionKey
+     * @param defaultValue
+     * @returns
+     */
+    getOptionValue(options, optionKey, defaultValue = undefined) {
+        const optionKeys = Object.keys(options);
+        if (!optionKeys.includes(optionKey)) {
+            if (defaultValue === undefined) {
+                throw new Error(`Must provide "${optionKey}" in options.`);
+            }
+            else {
+                return defaultValue;
+            }
+        }
+        return options[optionKey];
+    }
+    ////////////////////////////////
+    //// UNIMPLEMENTED MTEHODS
+    ////////////////////////////////
+    async getMigratableDbList(options) {
+        console.log('getCordovaDbList', options);
+        throw new Error('Method not implemented.');
+    }
+    async addSQLiteSuffix(options) {
+        console.log(`${JSON.stringify(options)}`);
+        throw new Error('Method not implemented.');
+    }
+    async deleteOldDatabases(options) {
+        console.log(`${JSON.stringify(options)}`);
+        throw new Error('Method not implemented.');
+    }
+    async getUrl() {
+        throw new Error('Method not implemented.');
+    }
+    async initWebStore() {
+        throw new Error('Method not implemented.');
+    }
+    async saveToStore(options) {
+        console.log(`${JSON.stringify(options)}`);
+        throw new Error('Method not implemented.');
+    }
+    async isSecretStored() {
+        throw new Error('Method not implemented.');
+    }
+    async setEncryptionSecret(options) {
+        console.log(`${JSON.stringify(options)}`);
+        throw new Error('Method not implemented.');
+    }
+    async changeEncryptionSecret(options) {
+        console.log(`${JSON.stringify(options)}`);
+        throw new Error('Method not implemented.');
+    }
+    async getNCDatabasePath(options) {
+        console.log('getNCDatabasePath', options);
+        throw new Error('Method not implemented.');
+    }
+    async createNCConnection(options) {
+        console.log('createNCConnection', options);
+        throw new Error('Method not implemented.');
+    }
+    async closeNCConnection(options) {
+        console.log('closeNCConnection', options);
+        throw new Error('Method not implemented.');
+    }
+    async isNCDatabase(options) {
+        console.log('isNCDatabase', options);
+        throw new Error('Method not implemented.');
     }
 }
 exports.CapacitorSQLite = src.CapacitorSQLite = CapacitorSQLite;