@capacitor-community/sqlite 5.0.4-alphabetter.1 → 5.0.4-alphabetter.3

package/electron/dist/plugin.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var require$$0 = require('better-sqlite3');
+var require$$0 = require('better-sqlite3-multiple-ciphers');
 var require$$0$1 = require('node:fs/promises');
 var require$$1 = require('path');
 var require$$2 = require('fs');
@@ -60,7 +60,7 @@ class UtilsSQLite {
               this.mSQLite = require('sqlite3');
             }
         */
-        this.mSQLite = require$$0__default["default"];
+        this.BCSQLite3 = require$$0__default["default"];
     }
     /**
      * OpenOrCreateDatabase
@@ -72,13 +72,16 @@ class UtilsSQLite {
         // open sqlite3 database
         let mDB;
         if (!readonly) {
-            mDB = new this.mSQLite.Database(pathDB, {
+            mDB = new this.BCSQLite3(pathDB, {
                 verbose: console.log,
+                fileMustExist: false,
             });
         }
         else {
-            mDB = new this.mSQLite.Database(pathDB, SQLITE_OPEN_READONLY, {
+            mDB = new this.BCSQLite3(pathDB, {
                 verbose: console.log,
+                readonly: SQLITE_OPEN_READONLY,
+                fileMustExist: true,
             });
         }
         if (mDB != null) {
@@ -86,7 +89,8 @@ class UtilsSQLite {
                 await this.dbChanges(mDB);
             }
             catch (err) {
-                return Promise.reject(msg + `dbChanges ${err}`);
+                const errmsg = err.message ? err.message : err;
+                return Promise.reject(`${msg} ${errmsg}`);
             }
             try {
                 // set the password
@@ -97,7 +101,8 @@ class UtilsSQLite {
                 await this.setForeignKeyConstraintsEnabled(mDB, true);
             }
             catch (err) {
-                return Promise.reject(msg + `${err}`);
+                const errmsg = err.message ? err.message : err;
+                return Promise.reject(`${msg} ${errmsg}`);
             }
             return Promise.resolve(mDB);
         }
@@ -110,19 +115,18 @@ class UtilsSQLite {
      * @param mDB
      * @param password
      */
-    async setCipherPragma(mDB, password) {
-        console.log('setCipherPragma');
-        return new Promise((resolve, reject) => {
-            mDB.serialize(() => {
-                mDB.run('PRAGMA cipher_compatibility = 4');
-                mDB.run(`PRAGMA key = '${password}'`, (err) => {
-                    if (err) {
-                        reject(new Error('SetForeignKey: ' + `${err.message}`));
-                    }
-                    resolve();
-                });
-            });
-        });
+    async setCipherPragma(mDB, passphrase) {
+        const msg = 'setCipherPragma: ';
+        try {
+            mDB.pragma(`cipher='sqlcipher'`);
+            mDB.pragma(`legacy=4`);
+            mDB.pragma(`key='${passphrase}'`);
+            return Promise.resolve();
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * SetForeignKeyConstraintsEnabled
@@ -130,44 +134,34 @@ class UtilsSQLite {
      * @param toggle
      */
     async setForeignKeyConstraintsEnabled(mDB, toggle) {
-        return new Promise((resolve, reject) => {
-            let key = 'OFF';
-            if (toggle) {
-                key = 'ON';
-            }
-            mDB.run(`PRAGMA foreign_keys = '${key}'`, (err) => {
-                if (err) {
-                    reject(`SetForeignKey: ${err.message}`);
-                }
-                resolve();
-            });
-        });
+        const msg = 'SetForeignKeyConstraintsEnabled: ';
+        let key = 'OFF';
+        if (toggle) {
+            key = 'ON';
+        }
+        try {
+            mDB.pragma(`foreign_keys = '${key}'`);
+            return Promise.resolve();
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * GetVersion
      * @param mDB
      */
     async getVersion(mDB) {
-        return new Promise((resolve, reject) => {
-            let version = 0;
-            const SELECT_VERSION = 'PRAGMA user_version;';
-            mDB.get(SELECT_VERSION, [], (err, row) => {
-                // process the row here
-                if (err) {
-                    reject('getVersion failed: ' + `${err.message}`);
-                }
-                else {
-                    if (row == null) {
-                        version = 0;
-                    }
-                    else {
-                        const key = Object.keys(row)[0];
-                        version = row[key];
-                    }
-                    resolve(version);
-                }
-            });
-        });
+        const msg = 'GetVersion: ';
+        try {
+            const version = mDB.pragma('user_version');
+            return Promise.resolve(version);
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * SetVersion
@@ -175,14 +169,15 @@ class UtilsSQLite {
      * @param version
      */
     async setVersion(mDB, version) {
-        return new Promise((resolve, reject) => {
-            mDB.run(`PRAGMA user_version = ${version}`, (err) => {
-                if (err) {
-                    reject('setVersion failed: ' + `${err.message}`);
-                }
-                resolve();
-            });
-        });
+        const msg = 'SetVersion: ';
+        try {
+            mDB.pragma(`user_version = '${version}'`);
+            return;
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * ChangePassword
@@ -192,12 +187,14 @@ class UtilsSQLite {
      */
     async changePassword(pathDB, password, newpassword) {
         let mDB;
+        const msg = "ChangePassword";
         try {
             mDB = await this.openOrCreateDatabase(pathDB, password, false);
             await this.pragmaReKey(mDB, password, newpassword);
         }
         catch (err) {
-            return Promise.reject(err);
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
         finally {
             mDB.close();
@@ -209,19 +206,19 @@ class UtilsSQLite {
      * @param password
      * @param newpassword
      */
-    async pragmaReKey(mDB, password, newpassword) {
-        return new Promise((resolve, reject) => {
-            mDB.serialize(() => {
-                mDB.run('PRAGMA cipher_compatibility = 4');
-                mDB.run(`PRAGMA key = '${password}'`);
-                mDB.run(`PRAGMA rekey = '${newpassword}'`, (err) => {
-                    if (err) {
-                        reject(new Error('ChangePassword: ' + `${err.message}`));
-                    }
-                    resolve();
-                });
-            });
-        });
+    async pragmaReKey(mDB, passphrase, newpassphrase) {
+        const msg = 'PragmaReKey: ';
+        try {
+            mDB.pragma(`cipher='sqlcipher'`);
+            mDB.pragma(`legacy=4`);
+            mDB.pragma(`key='${passphrase}'`);
+            mDB.pragma(`rekey='${newpassphrase}'`);
+            return;
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * BeginTransaction
@@ -230,19 +227,19 @@ class UtilsSQLite {
      */
     async beginTransaction(db, isOpen) {
         // eslint-disable-next-line no-async-promise-executor
-        return new Promise((resolve, reject) => {
-            const msg = 'BeginTransaction: ';
-            if (!isOpen) {
-                return Promise.reject(`${msg}database not opened`);
-            }
-            const sql = 'BEGIN TRANSACTION;';
-            db.run(sql, (err) => {
-                if (err) {
-                    reject(`${msg}${err.message}`);
-                }
-                resolve();
-            });
-        });
+        const msg = 'BeginTransaction: ';
+        if (!isOpen) {
+            return Promise.reject(`${msg} database not opened`);
+        }
+        const sql = 'BEGIN TRANSACTION;';
+        try {
+            db.exec(sql);
+            return Promise.resolve();
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * RollbackTransaction
@@ -250,19 +247,19 @@ class UtilsSQLite {
      * @param isOpen
      */
     async rollbackTransaction(db, isOpen) {
-        return new Promise((resolve, reject) => {
-            const msg = 'RollbackTransaction: ';
-            if (!isOpen) {
-                reject(`${msg}database not opened`);
-            }
-            const sql = 'ROLLBACK TRANSACTION;';
-            db.run(sql, (err) => {
-                if (err) {
-                    reject(`${msg}${err.message}`);
-                }
-                resolve();
-            });
-        });
+        const msg = 'RollbackTransaction: ';
+        if (!isOpen) {
+            return Promise.reject(`${msg} database not opened`);
+        }
+        const sql = 'ROLLBACK TRANSACTION;';
+        try {
+            db.exec(sql);
+            return Promise.resolve();
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * CommitTransaction
@@ -270,19 +267,19 @@ class UtilsSQLite {
      * @param isOpen
      */
     async commitTransaction(db, isOpen) {
-        return new Promise((resolve, reject) => {
-            const msg = 'CommitTransaction: ';
-            if (!isOpen) {
-                reject(`${msg}database not opened`);
-            }
-            const sql = 'COMMIT TRANSACTION;';
-            db.run(sql, (err) => {
-                if (err) {
-                    reject(`${msg}${err.message}`);
-                }
-                resolve();
-            });
-        });
+        const msg = 'CommitTransaction: ';
+        if (!isOpen) {
+            return Promise.reject(`${msg} database not opened`);
+        }
+        const sql = 'COMMIT TRANSACTION;';
+        try {
+            db.exec(sql);
+            return Promise.resolve();
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * DbChanges
@@ -290,49 +287,42 @@ class UtilsSQLite {
      * @param db
      */
     async dbChanges(db) {
-        return new Promise((resolve, reject) => {
-            const SELECT_CHANGE = 'SELECT total_changes()';
-            let changes = 0;
-            db.get(SELECT_CHANGE, [], (err, row) => {
-                // process the row here
-                if (err) {
-                    reject(`DbChanges failed: ${err.message}`);
-                }
-                else {
-                    if (row == null) {
-                        changes = 0;
-                    }
-                    else {
-                        const key = Object.keys(row)[0];
-                        changes = row[key];
-                    }
-                    resolve(changes);
-                }
-            });
-        });
+        const msg = 'DbChanges: ';
+        let changes = 0;
+        try {
+            const statement = db.prepare('SELECT total_changes()');
+            const firstRow = statement.get();
+            if (firstRow != null) {
+                const key = Object.keys(firstRow)[0];
+                changes = firstRow[key];
+            }
+            return Promise.resolve(changes);
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * GetLastId
      * @param db
      */
     getLastId(db) {
-        return new Promise((resolve, reject) => {
-            const SELECT_LAST_ID = 'SELECT last_insert_rowid()';
-            let lastId = -1;
-            db.get(SELECT_LAST_ID, [], (err, row) => {
-                // process the row here
-                if (err) {
-                    reject(`GetLastId failed: ${err.message}`);
-                }
-                else {
-                    if (row == null)
-                        resolve(lastId);
-                    const key = Object.keys(row)[0];
-                    lastId = row[key];
-                    resolve(lastId);
-                }
-            });
-        });
+        const msg = 'GetLastId: ';
+        let lastId = -1;
+        try {
+            const statement = db.prepare('SELECT last_insert_rowid()');
+            const firstRow = statement.get();
+            if (firstRow != null) {
+                const key = Object.keys(firstRow)[0];
+                lastId = firstRow[key];
+            }
+            return Promise.resolve(lastId);
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * Execute
@@ -340,10 +330,9 @@ class UtilsSQLite {
      * @param sql
      */
     async execute(mDB, sql, fromJson) {
-        let changes = -1;
-        let initChanges = -1;
+        const result = { changes: 0, lastId: -1 };
+        const msg = "Execute";
         try {
-            initChanges = await this.dbChanges(mDB);
             let sqlStmt = sql;
             // Check for DELETE FROM in sql string
             if (!fromJson &&
@@ -368,13 +357,14 @@ class UtilsSQLite {
                 }
                 sqlStmt = resArr.join(';');
             }
-            await this.execDB(mDB, sqlStmt);
-            changes = (await this.dbChanges(mDB)) - initChanges;
-            return Promise.resolve(changes);
+            const ret = await this.execDB(mDB, sqlStmt);
+            result.changes = ret.changes;
+            result.lastId = ret.lastInsertRowId;
+            return Promise.resolve(result);
         }
         catch (err) {
-            const msg = err.message ? err.message : err;
-            return Promise.reject(`Execute: ${msg}`);
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
     }
     /**
@@ -383,23 +373,26 @@ class UtilsSQLite {
      * @param sql
      */
     async execDB(mDB, sql) {
-        return new Promise((resolve, reject) => {
-            mDB.exec(sql, async (err) => {
-                if (err) {
-                    console.log(`in execDB err: ${JSON.stringify(err)}`);
-                    reject(`Execute: ${err}: `);
-                }
-                resolve();
-            });
-        });
+        const msg = 'execDB: ';
+        try {
+            const statement = mDB.prepare(sql);
+            const result = statement.run();
+            return Promise.resolve(result);
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * ExecuteSet
-     * @param db
+     * @param mDB
      * @param set
+     * @param fromJson
      */
-    async executeSet(db, set, fromJson) {
-        let lastId = -1;
+    async executeSet(mDB, set, fromJson) {
+        let result = { changes: 0, lastId: -1 };
+        const msg = "ExecuteSet";
         for (let i = 0; i < set.length; i++) {
             const statement = 'statement' in set[i] ? set[i].statement : null;
             const values = 'values' in set[i] && set[i].values.length > 0 ? set[i].values : [];
@@ -412,77 +405,72 @@ class UtilsSQLite {
                 if (Array.isArray(values[0])) {
                     for (const val of values) {
                         const mVal = await this.replaceUndefinedByNull(val);
-                        lastId = await this.prepareRun(db, statement, mVal, fromJson);
+                        result = await this.prepareRun(mDB, statement, mVal, fromJson);
                     }
                 }
                 else {
                     const mVal = await this.replaceUndefinedByNull(values);
-                    lastId = await this.prepareRun(db, statement, mVal, fromJson);
+                    result = await this.prepareRun(mDB, statement, mVal, fromJson);
                 }
             }
             catch (err) {
-                return Promise.reject(`ExecuteSet: ${err}`);
+                const errmsg = err.message ? err.message : err;
+                return Promise.reject(`${msg} ${errmsg}`);
             }
         }
-        return Promise.resolve(lastId);
+        return Promise.resolve(result);
     }
     /**
      * PrepareRun
-     * @param db
+     * @param mDB
      * @param statement
      * @param values
+     * @param fromJson
      */
-    async prepareRun(db, statement, values, fromJson) {
+    async prepareRun(mDB, statement, values, fromJson) {
+        const result = { changes: 0, lastId: -1 };
+        const msg = "PrepareRun";
         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);
+                sqlStmt = await this.deleteSQL(mDB, statement, values);
             }
             let mVal = [];
             if (values != null && values.length > 0) {
                 mVal = await this.replaceUndefinedByNull(values);
             }
-            await this.runExec(db, sqlStmt, mVal);
-            lastId = await this.getLastId(db);
-            return Promise.resolve(lastId);
+            const ret = await this.runExec(mDB, sqlStmt, mVal);
+            result.changes = ret.changes;
+            result.lastId = ret.lastInsertRowId;
+            return Promise.resolve(result);
         }
         catch (err) {
-            return Promise.reject(`PrepareRun: ${err}`);
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
     }
-    async runExec(db, stmt, values = []) {
-        return new Promise((resolve, reject) => {
+    async runExec(mDB, stmt, values = []) {
+        const msg = 'runExec: ';
+        try {
+            const statement = mDB.prepare(stmt);
+            let result;
             if (values != null && values.length > 0) {
-                db.run(stmt, values, (err) => {
-                    if (err) {
-                        console.log(`in runExec err1: ${JSON.stringify(err)}`);
-                        const msg = err.message ? err.message : err;
-                        reject(msg);
-                    }
-                    else {
-                        resolve();
-                    }
-                });
+                result = statement.run(values);
             }
             else {
-                db.exec(stmt, (err) => {
-                    if (err) {
-                        console.log(`in runExec err2: ${JSON.stringify(err)}`);
-                        const msg = err.message ? err.message : err;
-                        reject(msg);
-                    }
-                    else {
-                        resolve();
-                    }
-                });
+                result = statement.run();
             }
-        });
+            return Promise.resolve(result);
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * replaceUndefinedByNull
@@ -503,16 +491,17 @@ class UtilsSQLite {
     }
     /**
      * deleteSQL
-     * @param db
+     * @param mDB
      * @param statement
      * @param values
      * @returns
      */
-    async deleteSQL(db, statement, values) {
+    async deleteSQL(mDB, statement, values) {
         let sqlStmt = statement;
+        const msg = "DeleteSQL";
         try {
-            const isLast = await this.isLastModified(db, true);
-            const isDel = await this.isSqlDeleted(db, true);
+            const isLast = await this.isLastModified(mDB, true);
+            const isDel = await this.isSqlDeleted(mDB, true);
             if (isLast && isDel) {
                 // Replace DELETE by UPDATE and set sql_deleted to 1
                 const wIdx = statement.toUpperCase().indexOf('WHERE');
@@ -523,25 +512,27 @@ class UtilsSQLite {
                     .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);
+                await this.findReferencesAndUpdate(mDB, tableName, clauseStmt, values);
             }
             return sqlStmt;
         }
         catch (err) {
-            return Promise.reject(`DeleteSQL: ${err}`);
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
     }
     /**
      * findReferencesAndUpdate
-     * @param db
+     * @param mDB
      * @param tableName
      * @param whereStmt
      * @param values
      * @returns
      */
-    async findReferencesAndUpdate(db, tableName, whereStmt, values) {
+    async findReferencesAndUpdate(mDB, tableName, whereStmt, values) {
+        const msg = "FindReferencesAndUpdate";
         try {
-            const references = await this.getReferences(db, tableName);
+            const references = await this.getReferences(mDB, tableName);
             if (references.length <= 0) {
                 return;
             }
@@ -575,12 +566,12 @@ class UtilsSQLite {
                 }
                 //update sql_deleted for this reference
                 const stmt = 'UPDATE ' + updTableName + ' SET sql_deleted = 1 ' + uWhereStmt;
+                const selValues = [];
                 if (values != null && values.length > 0) {
                     const mVal = await this.replaceUndefinedByNull(values);
                     let arrVal = whereStmt.split('?');
                     if (arrVal[arrVal.length - 1] === ';')
                         arrVal = arrVal.slice(0, -1);
-                    const selValues = [];
                     for (const [j, val] of arrVal.entries()) {
                         for (const updVal of updColNames) {
                             const idxVal = val.indexOf(updVal);
@@ -589,12 +580,9 @@ class UtilsSQLite {
                             }
                         }
                     }
-                    await db.run(stmt, selValues);
                 }
-                else {
-                    await db.exec(stmt);
-                }
-                const lastId = await this.getLastId(db);
+                const ret = await this.runExec(mDB, stmt, selValues);
+                const lastId = ret.lastInsertRowId;
                 if (lastId == -1) {
                     const msg = `UPDATE sql_deleted failed for references table: ${refTable}`;
                     return Promise.reject(new Error(`findReferencesAndUpdate: ${msg}`));
@@ -603,7 +591,8 @@ class UtilsSQLite {
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(new Error(`findReferencesAndUpdate: ${err.message}`));
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
     }
     async getReferenceTableName(refValue) {
@@ -688,14 +677,15 @@ class UtilsSQLite {
         }
         return whereStmt;
     }
-    async getReferences(db, tableName) {
+    async getReferences(mDB, tableName) {
+        const msg = "GetReferences";
         const sqlStmt = 'SELECT sql FROM sqlite_master ' +
             "WHERE sql LIKE('%FOREIGN KEY%') AND sql LIKE('%REFERENCES%') AND " +
             "sql LIKE('%" +
             tableName +
             "%') AND sql LIKE('%ON DELETE%');";
         try {
-            const res = await this.queryAll(db, sqlStmt, []);
+            const res = await this.queryAll(mDB, sqlStmt, []);
             // get the reference's string(s)
             let retRefs = [];
             if (res.length > 0) {
@@ -704,7 +694,8 @@ class UtilsSQLite {
             return Promise.resolve(retRefs);
         }
         catch (err) {
-            return Promise.reject(new Error(`getReferences: ${err.message}`));
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
     }
     async getRefs(str) {
@@ -729,27 +720,56 @@ class UtilsSQLite {
      * @param values
      */
     queryAll(mDB, sql, values) {
-        return new Promise((resolve, reject) => {
-            mDB.serialize(() => {
-                mDB.all(sql, values, (err, rows) => {
-                    if (err) {
-                        reject(`QueryAll: ${err.message}`);
-                    }
-                    else {
-                        if (rows == null) {
-                            rows = [];
-                        }
-                        resolve(rows);
-                    }
-                });
-            });
-        });
+        const msg = "QueryAll";
+        try {
+            const stmt = mDB.prepare(sql);
+            let rows;
+            if (values != null && values.length > 0) {
+                rows = stmt.all(values);
+            }
+            else {
+                rows = stmt.all();
+            }
+            if (rows == null) {
+                rows = [];
+            }
+            Promise.resolve(rows);
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
+    }
+    /**
+     * QueryAll
+     * @param mDB
+     * @param sql
+     * @param values
+     */
+    queryOne(mDB, sql, values) {
+        const msg = "QueryOne";
+        try {
+            const stmt = mDB.prepare(sql);
+            let row;
+            if (values != null && values.length > 0) {
+                row = stmt.get(values);
+            }
+            else {
+                row = stmt.get();
+            }
+            Promise.resolve(row);
+        }
+        catch (err) {
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
+        }
     }
     /**
      * GetTablesNames
      * @param mDb
      */
     async getTablesNames(mDb) {
+        const msg = "getTablesNames";
         let sql = 'SELECT name FROM sqlite_master WHERE ';
         sql += "type='table' AND name NOT LIKE 'sync_table' ";
         sql += "AND name NOT LIKE '_temp_%' ";
@@ -764,7 +784,8 @@ class UtilsSQLite {
             return Promise.resolve(retArr);
         }
         catch (err) {
-            return Promise.reject(`getTablesNames: ${err}`);
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
     }
     /**
@@ -772,6 +793,7 @@ class UtilsSQLite {
      * @param mDb
      */
     async getViewsNames(mDb) {
+        const msg = "GetViewsNames";
         let sql = 'SELECT name FROM sqlite_master WHERE ';
         sql += "type='view' AND name NOT LIKE 'sqlite_%' ";
         sql += 'ORDER BY rootpage DESC;';
@@ -784,22 +806,24 @@ class UtilsSQLite {
             return Promise.resolve(retArr);
         }
         catch (err) {
-            return Promise.reject(`getViewsNames: ${err}`);
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
     }
     /**
      * isLastModified
-     * @param db
+     * @param mDB
      * @param isOpen
      */
-    async isLastModified(db, isOpen) {
+    async isLastModified(mDB, isOpen) {
+        const msg = "IsLastModified";
         if (!isOpen) {
-            return Promise.reject('isLastModified: database not opened');
+            return Promise.reject(`${msg} database not opened`);
         }
         try {
-            const tableList = await this.getTablesNames(db);
+            const tableList = await this.getTablesNames(mDB);
             for (const table of tableList) {
-                const tableNamesTypes = await this.getTableColumnNamesTypes(db, table);
+                const tableNamesTypes = await this.getTableColumnNamesTypes(mDB, table);
                 const tableColumnNames = tableNamesTypes.names;
                 if (tableColumnNames.includes('last_modified')) {
                     return Promise.resolve(true);
@@ -807,22 +831,24 @@ class UtilsSQLite {
             }
         }
         catch (err) {
-            return Promise.reject(`isLastModified: ${err}`);
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
     }
     /**
      * isSqlDeleted
-     * @param db
+     * @param mDB
      * @param isOpen
      */
-    async isSqlDeleted(db, isOpen) {
+    async isSqlDeleted(mDB, isOpen) {
+        const msg = "IsSqlDeleted";
         if (!isOpen) {
-            return Promise.reject('isSqlDeleted: database not opened');
+            return Promise.reject(`${msg} database not opened`);
         }
         try {
-            const tableList = await this.getTablesNames(db);
+            const tableList = await this.getTablesNames(mDB);
             for (const table of tableList) {
-                const tableNamesTypes = await this.getTableColumnNamesTypes(db, table);
+                const tableNamesTypes = await this.getTableColumnNamesTypes(mDB, table);
                 const tableColumnNames = tableNamesTypes.names;
                 if (tableColumnNames.includes('sql_deleted')) {
                     return Promise.resolve(true);
@@ -830,24 +856,19 @@ class UtilsSQLite {
             }
         }
         catch (err) {
-            return Promise.reject(`isSqlDeleted: ${err}`);
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
     }
     async getJournalMode(mDB) {
-        let resQuery = [];
-        let retMode = 'delete';
-        const query = `PRAGMA journal_mode;`;
+        const msg = "getJournalMode";
         try {
-            resQuery = await this.queryAll(mDB, query, []);
-            if (resQuery.length === 1) {
-                for (const query of resQuery) {
-                    retMode = query.journal_mode;
-                }
-            }
+            const retMode = mDB.pragma('journal_mode');
             return retMode;
         }
         catch (err) {
-            return Promise.reject('GetJournalMode: ' + `${err}`);
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
     }
     /**
@@ -856,22 +877,20 @@ class UtilsSQLite {
      * @param tableName
      */
     async getTableColumnNamesTypes(mDB, tableName) {
-        let resQuery = [];
-        const retNames = [];
-        const retTypes = [];
-        const query = `PRAGMA table_info('${tableName}');`;
+        const msg = "getTableColumnNamesTypes";
         try {
-            resQuery = await this.queryAll(mDB, query, []);
-            if (resQuery.length > 0) {
-                for (const query of resQuery) {
-                    retNames.push(query.name);
-                    retTypes.push(query.type);
-                }
+            const infos = mDB.pragma(`table_info('${tableName}')`);
+            const retNames = [];
+            const retTypes = [];
+            for (const info of infos) {
+                retNames.push(info.name);
+                retTypes.push(info.type);
             }
             return Promise.resolve({ names: retNames, types: retTypes });
         }
         catch (err) {
-            return Promise.reject('GetTableColumnNamesTypes: ' + `${err}`);
+            const errmsg = err.message ? err.message : err;
+            return Promise.reject(`${msg} ${errmsg}`);
         }
     }
 }
@@ -888,32 +907,23 @@ class UtilsJson {
     }
     /**
      * IsTableExists
-     * @param db
+     * @param mDB
      * @param isOpen
      * @param tableName
      */
-    async isTableExists(db, isOpen, tableName) {
-        return new Promise((resolve, reject) => {
-            if (!isOpen) {
-                reject('isTableExists: database not opened');
-            }
-            let query = 'SELECT name FROM sqlite_master WHERE ';
-            query += `type='table' AND name='${tableName}';`;
-            db.all(query, [], (err, rows) => {
-                // process the row here
-                if (err) {
-                    reject(`isTableExists: failed: ${err.message}`);
-                }
-                else {
-                    if (rows.length === 0) {
-                        resolve(false);
-                    }
-                    else {
-                        resolve(true);
-                    }
-                }
-            });
-        });
+    async isTableExists(mDB, isOpen, tableName) {
+        const msg = 'IsTableExists';
+        let ret = false;
+        if (!isOpen) {
+            return Promise.reject(`${msg} database not opened`);
+        }
+        let query = 'SELECT name FROM sqlite_master WHERE ';
+        query += `type='table' AND name='${tableName}';`;
+        const rows = await this.sqliteUtil.queryAll(mDB, query, []);
+        if (rows.length > 0) {
+            ret = true;
+        }
+        return Promise.resolve(ret);
     }
     /**
      * IsViewExists
@@ -921,28 +931,19 @@ class UtilsJson {
      * @param isOpen
      * @param viewName
      */
-    async isViewExists(db, isOpen, viewName) {
-        return new Promise((resolve, reject) => {
-            if (!isOpen) {
-                reject('isViewExists: database not opened');
-            }
-            let query = 'SELECT name FROM sqlite_master WHERE ';
-            query += `type='view' AND name='${viewName}';`;
-            db.all(query, [], (err, rows) => {
-                // process the row here
-                if (err) {
-                    reject(`isViewExists: failed: ${err.message}`);
-                }
-                else {
-                    if (rows.length === 0) {
-                        resolve(false);
-                    }
-                    else {
-                        resolve(true);
-                    }
-                }
-            });
-        });
+    async isViewExists(mDB, isOpen, viewName) {
+        const msg = 'IsViewExists';
+        let ret = false;
+        if (!isOpen) {
+            return Promise.reject(`${msg} database not opened`);
+        }
+        let query = 'SELECT name FROM sqlite_master WHERE ';
+        query += `type='view' AND name='${viewName}';`;
+        const rows = await this.sqliteUtil.queryAll(mDB, query, []);
+        if (rows.length > 0) {
+            ret = true;
+        }
+        return Promise.resolve(ret);
     }
     /**
      * CreateSchema
@@ -951,25 +952,26 @@ class UtilsJson {
      */
     async createSchema(mDB, jsonData) {
         // create the database schema
-        let changes = 0;
+        const msg = 'CreateSchema';
+        let results;
         try {
             // start a transaction
             await this.sqliteUtil.beginTransaction(mDB, true);
         }
         catch (err) {
-            return Promise.reject(`CreateDatabaseSchema: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
         const stmts = await this.createSchemaStatement(jsonData);
         if (stmts.length > 0) {
             const schemaStmt = stmts.join('\n');
             try {
-                changes = await this.sqliteUtil.execute(mDB, schemaStmt, true);
-                if (changes < 0) {
+                results = await this.sqliteUtil.execute(mDB, schemaStmt, true);
+                if (results.changes < 0) {
                     try {
                         await this.sqliteUtil.rollbackTransaction(mDB, true);
                     }
                     catch (err) {
-                        return Promise.reject('CreateSchema: changes < 0 ' + `${err}`);
+                        return Promise.reject(`${msg} changes < 0 ${err}`);
                     }
                 }
             }
@@ -980,16 +982,16 @@ class UtilsJson {
                     return Promise.reject(`CreateSchema: ${msg}`);
                 }
                 catch (err) {
-                    return Promise.reject('CreateSchema: changes < 0 ' + `${err}: ${msg}`);
+                    return Promise.reject(`${msg} changes < 0${err}: ${msg}`);
                 }
             }
         }
         try {
             await this.sqliteUtil.commitTransaction(mDB, true);
-            return Promise.resolve(changes);
+            return Promise.resolve(results.changes);
         }
         catch (err) {
-            return Promise.reject('CreateSchema: commit ' + `${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     /**
@@ -997,6 +999,7 @@ class UtilsJson {
      * @param jsonData
      */
     async createSchemaStatement(jsonData) {
+        const msg = 'CreateSchemaStatement';
         const statements = [];
         let isLastModified = false;
         let isSqlDeleted = false;
@@ -1083,7 +1086,7 @@ class UtilsJson {
             return Promise.resolve(statements);
         }
         catch (err) {
-            return Promise.reject(err);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     /**
@@ -1094,18 +1097,20 @@ class UtilsJson {
      */
     async createDataTable(mDB, table, mode) {
         let lastId = -1;
+        const msg = 'CreateDataTable';
+        let results;
         try {
             // Check if the table exists
             const tableExists = await this.isTableExists(mDB, true, table.name);
             if (!tableExists) {
-                return Promise.reject('CreateDataTable: Table ' + `${table.name} does not exist`);
+                return Promise.reject(`${msg} ${table.name} does not exist`);
             }
             // Get the column names and types
             const tableNamesTypes = await this.sqliteUtil.getTableColumnNamesTypes(mDB, table.name);
             const tableColumnTypes = tableNamesTypes.types;
             const tableColumnNames = tableNamesTypes.names;
             if (tableColumnTypes.length === 0) {
-                return Promise.reject('CreateDataTable: Table ' + `${table.name} info does not exist`);
+                return Promise.reject(`${msg} ${table.name} info does not exist`);
             }
             // Loop on Table Values
             for (let j = 0; j < table.values.length; j++) {
@@ -1117,19 +1122,20 @@ class UtilsJson {
                     if (stmt.substring(0, 6).toUpperCase() === 'DELETE') {
                         row = [];
                     }
-                    lastId = await this.sqliteUtil.prepareRun(mDB, stmt, row, true);
+                    results = await this.sqliteUtil.prepareRun(mDB, stmt, row, true);
+                    lastId = results.lastId;
                     if (lastId < 0) {
-                        return Promise.reject('CreateDataTable: lastId < 0');
+                        return Promise.reject(`${msg} lastId < 0`);
                     }
                 }
                 else {
                     lastId = 0;
                 }
             }
-            return Promise.resolve(lastId);
+            return Promise.resolve(results);
         }
         catch (err) {
-            return Promise.reject(`CreateDataTable: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     /**
@@ -1144,10 +1150,11 @@ class UtilsJson {
      */
     async createRowStatement(mDB, tColNames, row, j, tableName, mode) {
         // Check the row number of columns
+        const msg = 'CreateRowStatement';
         if (row.length != tColNames.length ||
             row.length === 0 ||
             tColNames.length === 0) {
-            return Promise.reject(new Error(`CreateRowStatement: Table ${tableName} ` +
+            return Promise.reject(new Error(`${msg} Table ${tableName} ` +
                 `values row ${j} not correct length`));
         }
         try {
@@ -1181,7 +1188,7 @@ class UtilsJson {
                     // Update
                     const setString = await this.setNameForUpdate(tColNames);
                     if (setString.length === 0) {
-                        return Promise.reject(new Error(`CreateRowStatement: Table ${tableName} ` +
+                        return Promise.reject(new Error(`${msg} Table ${tableName} ` +
                             `values row ${j} not set to String`));
                     }
                     stmt = `UPDATE ${tableName} SET ${setString} WHERE `;
@@ -1196,18 +1203,19 @@ class UtilsJson {
             return Promise.resolve(stmt);
         }
         catch (err) {
-            return Promise.reject(new Error(`CreateRowStatement: ${err.message}`));
+            return Promise.reject(new Error(`${msg} ${err.message}`));
         }
     }
     /**
      *
-     * @param db
+     * @param mDB
      * @param values
      * @param tbName
      * @param tColNames
      * @returns
      */
-    async checkUpdate(db, stmt, values, tbName, tColNames) {
+    async checkUpdate(mDB, stmt, values, tbName, tColNames) {
+        const msg = 'CheckUpdate';
         const isRun = true;
         if (stmt.substring(0, 6) === 'UPDATE') {
             try {
@@ -1218,7 +1226,7 @@ class UtilsJson {
                 else {
                     query += `${tColNames[0]} = ${values[0]};`;
                 }
-                const resQuery = await this.getValues(db, query, tbName);
+                const resQuery = await this.getValues(mDB, query, tbName);
                 let resValues = [];
                 if (resQuery.length > 0) {
                     resValues = resQuery[0];
@@ -1234,12 +1242,12 @@ class UtilsJson {
                     return Promise.resolve(false);
                 }
                 else {
-                    const msg = 'Both arrays not the same length';
-                    return Promise.reject(new Error(`CheckUpdate: ${msg}`));
+                    const msg1 = 'Both arrays not the same length';
+                    return Promise.reject(new Error(`${msg} ${msg1}`));
                 }
             }
             catch (err) {
-                return Promise.reject(new Error(`CheckUpdate: ${err.message}`));
+                return Promise.reject(new Error(`${msg} ${err.message}`));
             }
         }
         else {
@@ -1253,6 +1261,7 @@ class UtilsJson {
      * @param tableName
      */
     async getValues(mDb, query, tableName) {
+        const msg = 'GetValues';
         const values = [];
         try {
             // get table column names and types
@@ -1262,7 +1271,7 @@ class UtilsJson {
                 rowNames = tableNamesTypes.names;
             }
             else {
-                return Promise.reject(`GetValues: Table ${tableName} no names`);
+                return Promise.reject(`${msg} Table ${tableName} no names`);
             }
             const retValues = await this.sqliteUtil.queryAll(mDb, query, []);
             for (const rValue of retValues) {
@@ -1280,7 +1289,7 @@ class UtilsJson {
             return Promise.resolve(values);
         }
         catch (err) {
-            return Promise.reject(`GetValues: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     /**
@@ -1328,12 +1337,13 @@ class UtilsJson {
   */
     /**
      * IsIdExists
-     * @param db
+     * @param mDB
      * @param dbName
      * @param firstColumnName
      * @param key
      */
-    async isIdExists(db, dbName, firstColumnName, key) {
+    async isIdExists(mDB, dbName, firstColumnName, key) {
+        const msg = 'IsIdExists';
         let ret = false;
         let query = `SELECT ${firstColumnName} FROM ` +
             `${dbName} WHERE ${firstColumnName} = `;
@@ -1342,13 +1352,13 @@ class UtilsJson {
         if (typeof key === 'string')
             query += `'${key}';`;
         try {
-            const resQuery = await this.sqliteUtil.queryAll(db, query, []);
+            const resQuery = await this.sqliteUtil.queryAll(mDB, query, []);
             if (resQuery.length === 1)
                 ret = true;
             return Promise.resolve(ret);
         }
         catch (err) {
-            return Promise.reject(`IsIdExists: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     /**
@@ -1356,25 +1366,25 @@ class UtilsJson {
      * @param length
      */
     createQuestionMarkString(length) {
-        return new Promise((resolve, reject) => {
-            let retString = '';
-            for (let i = 0; i < length; i++) {
-                retString += '?,';
-            }
-            if (retString.length > 1) {
-                retString = retString.slice(0, -1);
-                resolve(retString);
-            }
-            else {
-                reject('CreateQuestionMarkString: length = 0');
-            }
-        });
+        const msg = 'CreateQuestionMarkString';
+        let retString = '';
+        for (let i = 0; i < length; i++) {
+            retString += '?,';
+        }
+        if (retString.length > 1) {
+            retString = retString.slice(0, -1);
+            return Promise.resolve(retString);
+        }
+        else {
+            return Promise.reject(`${msg} length = 0`);
+        }
     }
     /**
      * SetNameForUpdate
      * @param names
      */
     async setNameForUpdate(names) {
+        const msg = 'SetNameForUpdate';
         let retString = '';
         for (const name of names) {
             retString += `${name} = ? ,`;
@@ -1384,7 +1394,7 @@ class UtilsJson {
             return Promise.resolve(retString);
         }
         else {
-            return Promise.reject('SetNameForUpdate: length = 0');
+            return Promise.reject(`${msg} length = 0`);
         }
     }
     /**
@@ -1609,6 +1619,7 @@ class UtilsJson {
      * @param schema
      */
     async checkSchemaValidity(schema) {
+        const msg = 'CheckSchemaValidity';
         for (let i = 0; i < schema.length; i++) {
             const sch = {};
             const keys = Object.keys(schema[i]);
@@ -1626,7 +1637,7 @@ class UtilsJson {
             }
             const isValid = this.isSchema(sch);
             if (!isValid) {
-                return Promise.reject(`CheckSchemaValidity: schema[${i}] not valid`);
+                return Promise.reject(`${msg} schema[${i}] not valid`);
             }
         }
         return Promise.resolve();
@@ -1636,6 +1647,7 @@ class UtilsJson {
      * @param indexes
      */
     async checkIndexesValidity(indexes) {
+        const msg = 'CheckIndexesValidity';
         for (let i = 0; i < indexes.length; i++) {
             const index = {};
             const keys = Object.keys(indexes[i]);
@@ -1650,7 +1662,7 @@ class UtilsJson {
             }
             const isValid = this.isIndexes(index);
             if (!isValid) {
-                return Promise.reject(`CheckIndexesValidity: indexes[${i}] not valid`);
+                return Promise.reject(`${msg} indexes[${i}] not valid`);
             }
         }
         return Promise.resolve();
@@ -1660,6 +1672,7 @@ class UtilsJson {
      * @param triggers
      */
     async checkTriggersValidity(triggers) {
+        const msg = 'CheckTriggersValidity';
         for (let i = 0; i < triggers.length; i++) {
             const trigger = {};
             const keys = Object.keys(triggers[i]);
@@ -1677,7 +1690,7 @@ class UtilsJson {
             }
             const isValid = this.isTriggers(trigger);
             if (!isValid) {
-                return Promise.reject(`CheckTriggersValidity: triggers[${i}] not valid`);
+                return Promise.reject(`${msg} triggers[${i}] not valid`);
             }
         }
         return Promise.resolve();
@@ -1687,6 +1700,7 @@ class UtilsJson {
      * @param views
      */
     async checkViewsValidity(views) {
+        const msg = 'CheckViewsValidity';
         for (let i = 0; i < views.length; i++) {
             const view = {};
             const keys = Object.keys(views[i]);
@@ -1698,7 +1712,7 @@ class UtilsJson {
             }
             const isValid = this.isView(view);
             if (!isValid) {
-                return Promise.reject(`CheckViewsValidity: views[${i}] not valid`);
+                return Promise.reject(`${msg} views[${i}] not valid`);
             }
         }
         return Promise.resolve();
@@ -1709,16 +1723,17 @@ class UtilsJson {
      * @param table
      */
     async createView(mDB, view) {
+        const msg = 'CreateView';
         const stmt = `CREATE VIEW IF NOT EXISTS ${view.name} AS ${view.value};`;
         try {
-            const changes = await this.sqliteUtil.execute(mDB, stmt, true);
-            if (changes < 0) {
-                return Promise.reject(`CreateView: ${view.name} failed`);
+            const results = await this.sqliteUtil.execute(mDB, stmt, true);
+            if (results.changes < 0) {
+                return Promise.reject(`${msg} ${view.name} failed`);
             }
-            return Promise.resolve();
+            return Promise.resolve(results);
         }
         catch (err) {
-            return Promise.reject(`CreateView: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
 }
@@ -1739,6 +1754,7 @@ class ExportToJson {
      * @param sqlObj
      */
     async createExportObject(mDB, sqlObj) {
+        const msg = 'CreateExportObject';
         const retObj = {};
         let tables = [];
         let views = [];
@@ -1749,12 +1765,12 @@ class ExportToJson {
             // get Table's name
             const resTables = await this.getTablesNameSQL(mDB);
             if (resTables.length === 0) {
-                return Promise.reject("createExportObject: table's names failed");
+                return Promise.reject(`${msg} table's names failed`);
             }
             else {
                 const isTable = await this.jsonUtil.isTableExists(mDB, true, 'sync_table');
                 if (!isTable && sqlObj.mode === 'partial') {
-                    return Promise.reject('No sync_table available');
+                    return Promise.reject(`${msg} No sync_table available`);
                 }
                 switch (sqlObj.mode) {
                     case 'partial': {
@@ -1767,7 +1783,7 @@ class ExportToJson {
                     }
                     default: {
                         errmsg =
-                            'createExportObject: expMode ' + sqlObj.mode + ' not defined';
+                            `${msg} expMode ${sqlObj.mode} not defined`;
                         break;
                     }
                 }
@@ -1788,7 +1804,7 @@ class ExportToJson {
             }
         }
         catch (err) {
-            return Promise.reject('createExportObject: ' + err);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     /**
@@ -1796,6 +1812,7 @@ class ExportToJson {
      * @param mDb
      */
     async getTablesNameSQL(mDb) {
+        const msg = 'GetTablesNameSQL';
         let sql = 'SELECT name,sql FROM sqlite_master WHERE ';
         sql += "type='table' AND name NOT LIKE 'sync_table' ";
         sql += "AND name NOT LIKE '_temp_%' ";
@@ -1806,28 +1823,25 @@ class ExportToJson {
             return Promise.resolve(retQuery);
         }
         catch (err) {
-            return Promise.reject(`getTablesNameSQL: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     async getLastExportDate(mDb) {
-        return new Promise((resolve, reject) => {
-            let retDate = -1;
+        const msg = "GetLastExportDate";
+        let retDate = -1;
+        try {
             // 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);
-                }
-            });
-        });
+            const stmt = `SELECT sync_date FROM sync_table WHERE id = ?;`;
+            const row = await this.sqliteUtil.queryOne(mDb, stmt, [2]);
+            if (row != null) {
+                const key = Object.keys(row)[0];
+                retDate = row[key];
+            }
+            return Promise.resolve(retDate);
+        }
+        catch (err) {
+            return Promise.reject(`${msg} ${err}`);
+        }
     }
     /**
      * SetLastExportDate
@@ -1836,10 +1850,11 @@ class ExportToJson {
      * @returns
      */
     async setLastExportDate(mDb, lastExportedDate) {
+        const msg = "SetLastExportDate";
         try {
             const isTable = await this.jsonUtil.isTableExists(mDb, true, 'sync_table');
             if (!isTable) {
-                return Promise.reject(new Error('setLastExportDate: No sync_table available'));
+                return Promise.reject(new Error(`${msg} No sync_table available`));
             }
             const sDate = Math.round(new Date(lastExportedDate).getTime() / 1000);
             let stmt = '';
@@ -1849,9 +1864,9 @@ class ExportToJson {
             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' };
+            const results = await this.sqliteUtil.execute(mDb, stmt, false);
+            if (results.changes < 0) {
+                return { result: false, message: `${msg} failed` };
             }
             else {
                 return { result: true };
@@ -1860,42 +1875,42 @@ class ExportToJson {
         catch (err) {
             return {
                 result: false,
-                message: `setLastExportDate failed: ${err.message}`,
+                message: `${msg} ${err.message}`,
             };
         }
     }
     async delExportedRows(mDb) {
+        const msg = "DelExportedRows";
         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');
+                return Promise.reject(`${msg} 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');
+                return Promise.reject(`${msg} 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");
+                return Promise.reject(`${msg} 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');
+                const results = await this.sqliteUtil.prepareRun(mDb, delStmt, [], true);
+                if (results.lastId < 0) {
+                    return Promise.reject(`${msg} lastId < 0`);
                 }
             }
         }
         catch (err) {
-            return Promise.reject(`DelExportedRows failed: ${err.message}`);
+            return Promise.reject(`${msg} failed: ${err.message}`);
         }
     }
     /**
@@ -1926,27 +1941,19 @@ class ExportToJson {
      * @param mDb
      */
     async getSyncDate(mDb) {
-        return new Promise((resolve, reject) => {
-            let retDate = -1;
-            // get the last sync date
-            const stmt = `SELECT sync_date FROM sync_table WHERE id = 1;`;
-            mDb.get(stmt, [], (err, row) => {
-                // process the row here
-                if (err) {
-                    reject(`GetSyncDate: ${err.message}`);
-                }
-                else {
-                    if (row != null) {
-                        const key = Object.keys(row)[0];
-                        retDate = row[key];
-                        resolve(retDate);
-                    }
-                    else {
-                        reject(`GetSyncDate: no syncDate`);
-                    }
-                }
-            });
-        });
+        const msg = "GetSyncDate";
+        let retDate = -1;
+        // get the last sync date
+        const stmt = `SELECT sync_date FROM sync_table WHERE id = ?;`;
+        const row = await this.sqliteUtil.queryOne(mDb, stmt, [1]);
+        if (row != null) {
+            const key = Object.keys(row)[0];
+            retDate = row[key];
+            return Promise.resolve(retDate);
+        }
+        else {
+            return Promise.reject(`${msg} no syncDate`);
+        }
     }
     /**
      * GetTablesFull
@@ -1954,6 +1961,7 @@ class ExportToJson {
      * @param resTables
      */
     async getTablesFull(mDb, resTables) {
+        const msg = 'GetTablesFull';
         const tables = [];
         let errmsg = '';
         try {
@@ -1965,21 +1973,21 @@ class ExportToJson {
                     tableName = rTable.name;
                 }
                 else {
-                    errmsg = 'GetTablesFull: no name';
+                    errmsg = `${msg} no name`;
                     break;
                 }
                 if (rTable.sql) {
                     sqlStmt = rTable.sql;
                 }
                 else {
-                    errmsg = 'GetTablesFull: no sql';
+                    errmsg = `${msg} no sql`;
                     break;
                 }
                 const table = {};
                 // create Table's Schema
                 const schema = await this.getSchema(sqlStmt);
                 if (schema.length === 0) {
-                    errmsg = 'GetTablesFull: no Schema returned';
+                    errmsg = `${msg} no Schema returned`;
                     break;
                 }
                 // check schema validity
@@ -2004,7 +2012,7 @@ class ExportToJson {
                     table.schema = schema;
                 }
                 else {
-                    errmsg = `GetTablesFull: must contain schema`;
+                    errmsg = `${msg} must contain schema`;
                     break;
                 }
                 if (indexes.length > 0) {
@@ -2017,7 +2025,7 @@ class ExportToJson {
                     table.values = values;
                 }
                 if (Object.keys(table).length <= 1) {
-                    errmsg = `GetTablesFull: table ${tableName} is not a jsonTable`;
+                    errmsg = `${msg} table ${tableName} is not a jsonTable`;
                     break;
                 }
                 tables.push(table);
@@ -2028,7 +2036,7 @@ class ExportToJson {
             return Promise.resolve(tables);
         }
         catch (err) {
-            return Promise.reject(`GetTablesFull: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     /**
@@ -2038,6 +2046,7 @@ class ExportToJson {
      * @param tableName
      */
     async getSchema(sqlStmt /*,tableName: string,*/) {
+        const msg = 'GetSchema';
         const schema = [];
         // take the substring between parenthesis
         const openPar = sqlStmt.indexOf('(');
@@ -2093,7 +2102,7 @@ class ExportToJson {
             return Promise.resolve(schema);
         }
         catch (err) {
-            return Promise.reject(err);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     /**
@@ -2103,6 +2112,7 @@ class ExportToJson {
      * @param tableName
      */
     async getIndexes(mDb, tableName) {
+        const msg = 'GetIndexes';
         const indexes = [];
         let errmsg = '';
         try {
@@ -2127,12 +2137,12 @@ class ExportToJson {
                             indexes.push(index);
                         }
                         else {
-                            errmsg = `GetIndexes: Table ${tableName} doesn't match`;
+                            errmsg = `${msg} Table ${tableName} doesn't match`;
                             break;
                         }
                     }
                     else {
-                        errmsg = `GetIndexes: Table ${tableName} creating indexes`;
+                        errmsg = `${msg} Table ${tableName} creating indexes`;
                         break;
                     }
                 }
@@ -2143,7 +2153,7 @@ class ExportToJson {
             return Promise.resolve(indexes);
         }
         catch (err) {
-            return Promise.reject(`GetIndexes: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     /**
@@ -2153,6 +2163,7 @@ class ExportToJson {
      * @param tableName
      */
     async getTriggers(mDb, tableName) {
+        const msg = 'GetTriggers';
         const triggers = [];
         try {
             let stmt = 'SELECT name,tbl_name,sql FROM sqlite_master WHERE ';
@@ -2168,22 +2179,22 @@ class ExportToJson {
                             const name = rTrg['name'];
                             let sqlArr = sql.split(name);
                             if (sqlArr.length != 2) {
-                                return Promise.reject(`GetTriggers: sql split name does not return 2 values`);
+                                return Promise.reject(`${msg} sql split name does not return 2 values`);
                             }
                             if (!sqlArr[1].includes(tableName)) {
-                                return Promise.reject(`GetTriggers: sql split does not contains ${tableName}`);
+                                return Promise.reject(`${msg} sql split does not contains ${tableName}`);
                             }
                             const timeEvent = sqlArr[1].split(tableName, 1)[0].trim();
                             sqlArr = sqlArr[1].split(timeEvent + ' ' + tableName);
                             if (sqlArr.length != 2) {
-                                return Promise.reject(`GetTriggers: sql split tableName does not return 2 values`);
+                                return Promise.reject(`${msg} sql split tableName does not return 2 values`);
                             }
                             let condition = '';
                             let logic = '';
                             if (sqlArr[1].trim().substring(0, 5).toUpperCase() !== 'BEGIN') {
                                 sqlArr = sqlArr[1].trim().split('BEGIN');
                                 if (sqlArr.length != 2) {
-                                    return Promise.reject(`GetTriggers: sql split BEGIN does not return 2 values`);
+                                    return Promise.reject(`${msg} sql split BEGIN does not return 2 values`);
                                 }
                                 condition = sqlArr[0].trim();
                                 logic = 'BEGIN' + sqlArr[1];
@@ -2200,18 +2211,18 @@ class ExportToJson {
                             triggers.push(trigger);
                         }
                         else {
-                            return Promise.reject(`GetTriggers: Table ${tableName} doesn't match`);
+                            return Promise.reject(`${msg} Table ${tableName} doesn't match`);
                         }
                     }
                     else {
-                        return Promise.reject(`GetTriggers: Table ${tableName} creating indexes`);
+                        return Promise.reject(`${msg} Table ${tableName} creating indexes`);
                     }
                 }
             }
             return Promise.resolve(triggers);
         }
         catch (err) {
-            return Promise.reject(`GetTriggers: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     /**
@@ -2220,6 +2231,7 @@ class ExportToJson {
      * @param resTables
      */
     async getTablesPartial(mDb, resTables) {
+        const msg = 'GetTablesPartial';
         const tables = [];
         let modTables = {};
         let syncDate = 0;
@@ -2243,14 +2255,14 @@ class ExportToJson {
                     tableName = rTable.name;
                 }
                 else {
-                    errmsg = 'GetTablesFull: no name';
+                    errmsg = `${msg} no name`;
                     break;
                 }
                 if (rTable.sql) {
                     sqlStmt = rTable.sql;
                 }
                 else {
-                    errmsg = 'GetTablesFull: no sql';
+                    errmsg = `${msg} no sql`;
                     break;
                 }
                 if (modTablesKeys.length == 0 ||
@@ -2309,7 +2321,7 @@ class ExportToJson {
                     table.values = values;
                 }
                 if (Object.keys(table).length <= 1) {
-                    errmsg = `GetTablesPartial: table ${tableName} is not a jsonTable`;
+                    errmsg = `${msg} table ${tableName} is not a jsonTable`;
                     break;
                 }
                 tables.push(table);
@@ -2320,7 +2332,7 @@ class ExportToJson {
             return Promise.resolve(tables);
         }
         catch (err) {
-            return Promise.reject(`GetTablesPartial: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     /**
@@ -2329,28 +2341,30 @@ class ExportToJson {
      * @param resTables
      */
     async getPartialModeData(mDb, resTables) {
+        const msg = 'GetPartialModeData';
         const retData = {};
         try {
             // get the synchronization date
             const syncDate = await this.getSyncDate(mDb);
             if (syncDate <= 0) {
-                return Promise.reject(`GetPartialModeData: no syncDate`);
+                return Promise.reject(`${msg} no syncDate`);
             }
             // get the tables which have been updated
             // since last synchronization
             const modTables = await this.getTablesModified(mDb, resTables, syncDate);
             if (modTables.length <= 0) {
-                return Promise.reject(`GetPartialModeData: no modTables`);
+                return Promise.reject(`${msg} no modTables`);
             }
             retData.syncDate = syncDate;
             retData.modTables = modTables;
             return Promise.resolve(retData);
         }
         catch (err) {
-            return Promise.reject(`GetPartialModeData: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
-    async getTablesModified(db, tables, syncDate) {
+    async getTablesModified(mDb, tables, syncDate) {
+        const msg = 'GetTablesModified';
         let errmsg = '';
         try {
             const retModified = {};
@@ -2359,9 +2373,9 @@ class ExportToJson {
                 // get total count of the table
                 let stmt = 'SELECT count(*) AS tcount  ';
                 stmt += `FROM ${rTable.name};`;
-                let retQuery = await this.sqliteUtil.queryAll(db, stmt, []);
+                let retQuery = await this.sqliteUtil.queryAll(mDb, stmt, []);
                 if (retQuery.length != 1) {
-                    errmsg = 'GetTableModified: total ' + 'count not returned';
+                    errmsg = `${msg} total count not returned`;
                     break;
                 }
                 const totalCount = retQuery[0]['tcount'];
@@ -2369,7 +2383,7 @@ class ExportToJson {
                 stmt = 'SELECT count(*) AS mcount FROM ';
                 stmt += `${rTable.name} WHERE last_modified > `;
                 stmt += `${syncDate};`;
-                retQuery = await this.sqliteUtil.queryAll(db, stmt, []);
+                retQuery = await this.sqliteUtil.queryAll(mDb, stmt, []);
                 if (retQuery.length != 1)
                     break;
                 const totalModifiedCount = retQuery[0]['mcount'];
@@ -2391,14 +2405,15 @@ class ExportToJson {
             return Promise.resolve(retModified);
         }
         catch (err) {
-            return Promise.reject(`GetTableModified: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
     }
     async modEmbeddedParentheses(sstr) {
+        const msg = 'ModEmbeddedParentheses';
         const oParArray = this.indexOfChar(sstr, '(');
         const cParArray = this.indexOfChar(sstr, ')');
         if (oParArray.length != cParArray.length) {
-            return Promise.reject("ModEmbeddedParentheses: Not same number of '(' & ')'");
+            return Promise.reject(`${msg} Not same number of '(' & ')'`);
         }
         if (oParArray.length === 0) {
             return Promise.resolve(sstr);
@@ -2485,8 +2500,8 @@ class UtilsDrop {
                     statements.push(stmt);
                 }
                 for (const stmt of statements) {
-                    const lastId = await this.sqliteUtil.prepareRun(db, stmt, [], false);
-                    if (lastId < 0) {
+                    const results = await this.sqliteUtil.prepareRun(db, stmt, [], false);
+                    if (results.lastId < 0) {
                         return Promise.reject(`${msg}: lastId < 0`);
                     }
                 }
@@ -2534,8 +2549,8 @@ class UtilsDrop {
             statements.push(stmt);
         }
         try {
-            const changes = await this.sqliteUtil.execute(db, statements.join('\n'), false);
-            if (changes < 0) {
+            const results = await this.sqliteUtil.execute(db, statements.join('\n'), false);
+            if (results.changes < 0) {
                 return Promise.reject('DropTempTables: changes < 0');
             }
             return Promise.resolve();
@@ -2582,30 +2597,28 @@ class ImportFromJson {
         }
     }
     async createTablesData(mDB, jsonData) {
-        let changes = 0;
+        const msg = 'CreateTablesData';
+        let results;
         let isValue = false;
-        let lastId = -1;
-        let msg = '';
-        let initChanges = -1;
+        let message = '';
         try {
-            initChanges = await this.sqliteUtil.dbChanges(mDB);
             // start a transaction
             await this.sqliteUtil.beginTransaction(mDB, true);
         }
         catch (err) {
-            return Promise.reject(`createTablesData: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
         for (const jTable of jsonData.tables) {
             if (jTable.values != null && jTable.values.length >= 1) {
                 // Create the table's data
                 try {
-                    lastId = await this.jsonUtil.createDataTable(mDB, jTable, jsonData.mode);
-                    if (lastId < 0)
+                    results = await this.jsonUtil.createDataTable(mDB, jTable, jsonData.mode);
+                    if (results.lastId < 0)
                         break;
                     isValue = true;
                 }
                 catch (err) {
-                    msg = err;
+                    message = err;
                     isValue = false;
                     break;
                 }
@@ -2614,21 +2627,20 @@ class ImportFromJson {
         if (isValue) {
             try {
                 await this.sqliteUtil.commitTransaction(mDB, true);
-                changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
-                return Promise.resolve(changes);
+                return Promise.resolve(results.changes);
             }
             catch (err) {
-                return Promise.reject('createTablesData: ' + `${err}`);
+                return Promise.reject(`${msg} ${err}`);
             }
         }
         else {
-            if (msg.length > 0) {
+            if (message.length > 0) {
                 try {
                     await this.sqliteUtil.rollbackTransaction(mDB, true);
-                    return Promise.reject(new Error(`createTablesData: ${msg}`));
+                    return Promise.reject(new Error(`${msg} ${message}`));
                 }
                 catch (err) {
-                    return Promise.reject('createTablesData: ' + `${err}: ${msg}`);
+                    return Promise.reject(`${msg} ${err}: ${message}`);
                 }
             }
             else {
@@ -2643,27 +2655,26 @@ class ImportFromJson {
      * @param jsonData
      */
     async createViews(mDB, jsonData) {
+        const msg = 'CreateViews';
         let isView = false;
-        let msg = '';
-        let initChanges = -1;
-        let changes = -1;
+        let message = '';
+        let results;
         try {
-            initChanges = await this.sqliteUtil.dbChanges(mDB);
             // start a transaction
             await this.sqliteUtil.beginTransaction(mDB, true);
         }
         catch (err) {
-            return Promise.reject(`createViews: ${err}`);
+            return Promise.reject(`${msg} ${err}`);
         }
         for (const jView of jsonData.views) {
             if (jView.value != null) {
                 // Create the view
                 try {
-                    await this.jsonUtil.createView(mDB, jView);
+                    results = await this.jsonUtil.createView(mDB, jView);
                     isView = true;
                 }
                 catch (err) {
-                    msg = err;
+                    message = err;
                     isView = false;
                     break;
                 }
@@ -2672,21 +2683,20 @@ class ImportFromJson {
         if (isView) {
             try {
                 await this.sqliteUtil.commitTransaction(mDB, true);
-                changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
-                return Promise.resolve(changes);
+                return Promise.resolve(results.changes);
             }
             catch (err) {
-                return Promise.reject('createViews: ' + `${err}`);
+                return Promise.reject(`${msg} ${err}`);
             }
         }
         else {
-            if (msg.length > 0) {
+            if (message.length > 0) {
                 try {
                     await this.sqliteUtil.rollbackTransaction(mDB, true);
-                    return Promise.reject(new Error(`createViews: ${msg}`));
+                    return Promise.reject(new Error(`${msg} ${message}`));
                 }
                 catch (err) {
-                    return Promise.reject('createViews: ' + `${err}: ${msg}`);
+                    return Promise.reject(`${msg} ${err}: ${message}`);
                 }
             }
             else {
@@ -3366,7 +3376,6 @@ class UtilsUpgrade {
     async onUpgrade(mDB, vUpgDict, curVersion, targetVersion) {
         let changes;
         const sortedKeys = new Int32Array(Object.keys(vUpgDict).map(item => parseInt(item))).sort();
-        console.log(`@@@ sortedKeys: ${sortedKeys}`);
         for (const versionKey of sortedKeys) {
             if (versionKey > curVersion && versionKey <= targetVersion) {
                 const statements = vUpgDict[versionKey].statements;
@@ -3384,7 +3393,6 @@ class UtilsUpgrade {
                     changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
                 }
                 catch (err) {
-                    console.log(`@@@@ onUpgrade: ${err}`);
                     return Promise.reject(`onUpgrade: ${err}`);
                 }
             }
@@ -3400,7 +3408,6 @@ class UtilsUpgrade {
         try {
             await this.sqliteUtil.beginTransaction(mDB, true);
             for (const statement of statements) {
-                console.log(`@@@ statement: ${statement}`);
                 await this.sqliteUtil.execute(mDB, statement, false);
             }
             await this.sqliteUtil.commitTransaction(mDB, true);
@@ -3408,7 +3415,6 @@ class UtilsUpgrade {
         }
         catch (err) {
             await this.sqliteUtil.rollbackTransaction(mDB, true);
-            console.log(`@@@ ExecuteStatementProcess: ${err}`);
             return Promise.reject(`ExecuteStatementProcess: ${err}`);
         }
     }
@@ -3643,8 +3649,8 @@ class Database {
                               );`;
                     stmts += `INSERT INTO sync_table (sync_date) VALUES (
                               "${date}");`;
-                    changes = await this.sqliteUtil.execute(this.database, stmts, false);
-                    if (changes < 0) {
+                    const results = await this.sqliteUtil.execute(this.database, stmts, false);
+                    if (results.changes < 0) {
                         throw new Error(`CreateSyncTable: failed changes < 0`);
                     }
                 }
@@ -3677,8 +3683,8 @@ class Database {
             const syncDateUnixTimestamp = Math.round(new Date(syncDate).getTime() / 1000);
             let stmt = `UPDATE sync_table SET sync_date = `;
             stmt += `${syncDateUnixTimestamp} WHERE id = 1;`;
-            const changes = await this.sqliteUtil.execute(this.database, stmt, false);
-            if (changes < 0) {
+            const results = await this.sqliteUtil.execute(this.database, stmt, false);
+            if (results.changes < 0) {
                 return { result: false, message: 'setSyncDate failed' };
             }
             else {
@@ -3727,14 +3733,14 @@ class Database {
                 console.log(`$$$ in executeSQL journal_mode: ${mode} $$$`);
                 await this.sqliteUtil.beginTransaction(this.database, this._isDbOpen);
             }
-            const changes = await this.sqliteUtil.execute(this.database, sql, false);
-            if (changes < 0) {
+            const results = await this.sqliteUtil.execute(this.database, sql, false);
+            if (results.changes < 0) {
                 throw new Error('ExecuteSQL: changes < 0');
             }
             if (transaction) {
                 await this.sqliteUtil.commitTransaction(this.database, this._isDbOpen);
             }
-            return changes;
+            return results.changes;
         }
         catch (executeError) {
             let message = `${executeError}`;
@@ -3775,10 +3781,7 @@ class Database {
      */
     async runSQL(statement, values, transaction) {
         this.ensureDatabaseIsOpen();
-        const result = { changes: -1, lastId: -1 };
-        let initChanges = -1;
         try {
-            initChanges = await this.sqliteUtil.dbChanges(this.database);
             // start a transaction
             if (transaction) {
                 const mode = await this.sqliteUtil.getJournalMode(this.database);
@@ -3790,8 +3793,8 @@ class Database {
             throw new Error(`RunSQL: ${err}`);
         }
         try {
-            const lastId = await this.sqliteUtil.prepareRun(this.database, statement, values, false);
-            if (lastId < 0) {
+            const results = await this.sqliteUtil.prepareRun(this.database, statement, values, false);
+            if (results.lastId < 0) {
                 if (transaction) {
                     await this.sqliteUtil.rollbackTransaction(this.database, this._isDbOpen);
                 }
@@ -3800,10 +3803,7 @@ class Database {
             if (transaction) {
                 await this.sqliteUtil.commitTransaction(this.database, this._isDbOpen);
             }
-            result.changes =
-                (await this.sqliteUtil.dbChanges(this.database)) - initChanges;
-            result.lastId = lastId;
-            return result;
+            return results;
         }
         catch (err) {
             if (transaction) {
@@ -3820,10 +3820,8 @@ class Database {
      */
     async execSet(set, transaction) {
         this.ensureDatabaseIsOpen();
-        const result = { changes: -1, lastId: -1 };
-        let initChanges = -1;
+        let results = { changes: 0, lastId: -1 };
         try {
-            initChanges = await this.sqliteUtil.dbChanges(this.database);
             // start a transaction
             if (transaction) {
                 const mode = await this.sqliteUtil.getJournalMode(this.database);
@@ -3835,13 +3833,11 @@ class Database {
             throw new Error(`ExecSet: ${err}`);
         }
         try {
-            result.lastId = await this.sqliteUtil.executeSet(this.database, set, false);
+            results = 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;
+            return results;
         }
         catch (err) {
             const message = err;
@@ -4001,17 +3997,20 @@ class CapacitorSQLite {
         const readonly = options.readonly ? options.readonly : false;
         const connName = readonly ? 'RO_' + dbName : 'RW_' + dbName;
         const database = this.getDatabaseConnectionOrThrowError(connName);
-        if (database.isDBOpen()) {
-            // close the database
-            try {
+        try {
+            if (database.isDBOpen()) {
+                // close the database
                 await database.close();
             }
-            catch (err) {
-                throw new Error(`CloseConnection command failed:  close ${dbName} failed ${err.message}`);
-            }
         }
-        // remove the connection from dictionary
-        delete this.databases[connName];
+        catch (err) {
+            throw new Error(`CloseConnection command failed:  close ${dbName} failed ${err.message}`);
+        }
+        finally {
+            // remove the connection from dictionary
+            delete this.databases[connName];
+        }
+        return;
     }
     async echo(options) {
         const echoValue = this.getOptionValue(options, 'value');