@capacitor-community/sqlite 3.4.2-5 → 3.4.3-2

package/electron/dist/plugin.js

@@ -777,7 +777,7 @@ class UtilsJson {
                         trig += `${jTable.name}`;
                         trig += `_trigger_last_modified `;
                         trig += `AFTER UPDATE ON ${jTable.name} `;
-                        trig += 'FOR EACH ROW WHEN NEW.last_modified <= ';
+                        trig += 'FOR EACH ROW WHEN NEW.last_modified < ';
                         trig += 'OLD.last_modified BEGIN UPDATE ';
                         trig += `${jTable.name} `;
                         trig += `SET last_modified = `;
@@ -859,6 +859,7 @@ class UtilsJson {
                 */
                 const retisIdExists = await this.isIdExists(mDB, table.name, tableColumnNames[0], table.values[j][0]);
                 let stmt;
+                let isRun = true;
                 if (mode === 'full' || (mode === 'partial' && !retisIdExists)) {
                     // Insert
                     const nameString = tableColumnNames.join();
@@ -880,10 +881,16 @@ class UtilsJson {
                     else {
                         stmt += `${tableColumnNames[0]} = ${table.values[j][0]};`;
                     }
+                    isRun = await this.checkUpdate(mDB, table.values[j], table.name, tableColumnNames);
                 }
-                lastId = await this._uSQLite.prepareRun(mDB, stmt, table.values[j]);
-                if (lastId < 0) {
-                    return Promise.reject('CreateDataTable: lastId < 0');
+                if (isRun) {
+                    lastId = await this._uSQLite.prepareRun(mDB, stmt, table.values[j]);
+                    if (lastId < 0) {
+                        return Promise.reject('CreateDataTable: lastId < 0');
+                    }
+                }
+                else {
+                    lastId = 0;
                 }
             }
             return Promise.resolve(lastId);
@@ -892,6 +899,84 @@ class UtilsJson {
             return Promise.reject(`CreateDataTable: ${err}`);
         }
     }
+    /**
+     *
+     * @param db
+     * @param values
+     * @param tbName
+     * @param tColNames
+     * @returns
+     */
+    async checkUpdate(db, values, tbName, tColNames) {
+        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}`));
+        }
+    }
+    /**
+     * 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.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, []);
+            for (const rValue of retValues) {
+                const row = [];
+                for (const rName of rowNames) {
+                    if (Object.keys(rValue).includes(rName)) {
+                        row.push(rValue[rName]);
+                    }
+                    else {
+                        row.push('NULL');
+                    }
+                }
+                values.push(row);
+            }
+            return Promise.resolve(values);
+        }
+        catch (err) {
+            return Promise.reject(`GetValues: ${err}`);
+        }
+    }
     /**
      * GetTableColumnNamesTypes
      * @param mDB
@@ -1539,7 +1624,7 @@ class ExportToJson {
                 }
                 // create Table's Data
                 const query = `SELECT * FROM ${tableName};`;
-                const values = await this.getValues(mDb, query, tableName);
+                const values = await this._uJson.getValues(mDb, query, tableName);
                 table.name = tableName;
                 if (schema.length > 0) {
                     table.schema = schema;
@@ -1742,43 +1827,6 @@ class ExportToJson {
             return Promise.reject(`GetTriggers: ${err}`);
         }
     }
-    /**
-     * 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._uJson.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, []);
-            for (const rValue of retValues) {
-                const row = [];
-                for (const rName of rowNames) {
-                    if (Object.keys(rValue).includes(rName)) {
-                        row.push(rValue[rName]);
-                    }
-                    else {
-                        row.push('NULL');
-                    }
-                }
-                values.push(row);
-            }
-            return Promise.resolve(values);
-        }
-        catch (err) {
-            return Promise.reject(`GetValues: ${err}`);
-        }
-    }
     /**
      * GetTablesPartial
      * @param mDb
@@ -1858,7 +1906,7 @@ class ExportToJson {
                         `SELECT * FROM ${tableName} ` +
                             `WHERE last_modified > ${syncDate};`;
                 }
-                const values = await this.getValues(mDb, query, tableName);
+                const values = await this._uJson.getValues(mDb, query, tableName);
                 // check the table object validity
                 table.name = tableName;
                 if (schema.length > 0) {
@@ -2687,15 +2735,17 @@ class UtilsUpgrade {
             if (Object.keys(this._commonColumns).length > 0) {
                 await this.updateNewTablesData(mDB);
             }
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(`ExecuteStatementProcess: ${err}`);
+        }
+        finally {
             // -> 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}`);
         }
     }
     /**
@@ -2764,9 +2814,13 @@ class UtilsUpgrade {
             // 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._uSQLite.prepareRun(mDB, delStmt, []);
             // prefix the table with _temp_
             let stmt = `ALTER TABLE ${table} RENAME `;
-            stmt += `TO _temp_${table};`;
+            stmt += `TO ${tmpTable};`;
             const lastId = await this._uSQLite.prepareRun(mDB, stmt, []);
             if (lastId < 0) {
                 let msg = 'BackupTable: lastId < 0';
@@ -2915,24 +2969,24 @@ 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();
+        this.dropUtil = new utilsDrop_1.UtilsDrop();
         //  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);
     }
     /**
@@ -2943,7 +2997,7 @@ class Database {
      * @since 0.0.1
      */
     isDBOpen() {
-        return this._isDBOpen;
+        return this._isDbOpen;
     }
     /**
      * Open
@@ -2951,7 +3005,7 @@ class Database {
      * @returns Promise<boolean>
      */
     async open() {
-        this._isDBOpen = false;
+        this._isDbOpen = false;
         //    let password = '';
         try {
             /*
@@ -2973,34 +3027,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}`);
         }
     }
     /**
@@ -3009,18 +3063,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
@@ -3028,21 +3077,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}`);
         }
     }
     /**
@@ -3053,14 +3096,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
@@ -3068,20 +3111,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
@@ -3089,20 +3130,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}`);
         }
     }
     /**
@@ -3111,18 +3146,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.jsonUtil.isLastModified(this.database, isOpen);
                 if (isLastModified) {
                     const date = Math.round(new Date().getTime() / 1000);
                     let stmts = `
@@ -3132,23 +3163,23 @@ 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);
                     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}`);
         }
     }
     /**
@@ -3158,20 +3189,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);
             if (changes < 0) {
                 return { result: false, message: 'setSyncDate failed' };
             }
@@ -3189,19 +3216,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` };
@@ -3218,32 +3241,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);
             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}`);
         }
     }
     /**
@@ -3254,17 +3276,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}`);
         }
     }
     /**
@@ -3275,39 +3293,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);
             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._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
-            retRes.changes = (await this._uSQLite.dbChanges(this._mDB)) - initChanges;
-            retRes.lastId = lastId;
-            return Promise.resolve(retRes);
+            if (transaction) {
+                await this.sqliteUtil.commitTransaction(this.database, this._isDbOpen);
+            }
+            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}`);
         }
     }
     /**
@@ -3317,103 +3336,99 @@ 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);
+            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);
-        }
+        this.ensureDatabaseIsOpen();
         try {
-            const retArr = await this._uDrop.getTablesNames(this._mDB);
-            return Promise.resolve(retArr);
+            const tableNames = await this.dropUtil.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 {
+            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);
             }
+            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 {
+            const jsonResult = await this.exportToJsonUtil.createExportObject(this.database, inJson);
+            const isValid = this.jsonUtil.isJsonSQLite(jsonResult);
+            if (isValid) {
+                return jsonResult;
             }
-            catch (err) {
-                return Promise.reject(`ExportJson: ${err}`);
+            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.`);
         }
     }
 }
@@ -3426,49 +3441,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;
@@ -3484,612 +3465,382 @@ 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');
-        }
-        if (!keys.includes('upgrade')) {
-            return Promise.reject('Must provide an upgrade statement');
-        }
-        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();
+        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) {
@@ -4100,25 +3851,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) {
@@ -4130,7 +3881,7 @@ class CapacitorSQLite {
             }
         }
         catch (err) {
-            return Promise.reject(`ResetDbDict: ${err}`);
+            throw new Error(`ResetDbDict: ${err}`);
         }
     }
     async symmetricDifference(setA, setB) {
@@ -4143,7 +3894,101 @@ 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.');
+    }
+    async deleteExportedRows(options) {
+        const dbName = this.getOptionValue(options, 'database');
+        //    const database = this.getDatabaseConnectionOrThrowError(dbName);
+        console.log('deleteExportedRows', dbName);
+        throw new Error('Method not implemented.');
     }
 }
 exports.CapacitorSQLite = src.CapacitorSQLite = CapacitorSQLite;