@capacitor-community/sqlite 3.2.4 → 3.3.1

package/electron/dist/plugin.js

@@ -6,6 +6,7 @@ var require$$0 = require('sqlite3');
 var require$$0$1 = require('path');
 var require$$1 = require('fs');
 var require$$2 = require('os');
+var require$$3 = require('jszip');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -13,6 +14,7 @@ var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
 var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
 var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
 var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2);
+var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3);
 
 var src = {};
 
@@ -51,7 +53,7 @@ class UtilsSQLite {
                 await this.dbChanges(mDB);
             }
             catch (err) {
-                return Promise.reject(new Error(msg + `dbChanges ${err.message}`));
+                return Promise.reject(msg + `dbChanges ${err}`);
             }
             try {
                 /*        // set the password
@@ -68,12 +70,12 @@ class UtilsSQLite {
                 }
             }
             catch (err) {
-                return Promise.reject(new Error(msg + `${err.message}`));
+                return Promise.reject(msg + `${err}`);
             }
             return Promise.resolve(mDB);
         }
         else {
-            return Promise.reject(new Error(msg + 'open database failed'));
+            return Promise.reject(msg + 'open database failed');
         }
     }
     /**
@@ -109,7 +111,7 @@ class UtilsSQLite {
             }
             mDB.run(`PRAGMA foreign_keys = '${key}'`, (err) => {
                 if (err) {
-                    reject(new Error(`SetForeignKey: ${err.message}`));
+                    reject(`SetForeignKey: ${err.message}`);
                 }
                 resolve();
             });
@@ -126,7 +128,7 @@ class UtilsSQLite {
             mDB.get(SELECT_VERSION, [], (err, row) => {
                 // process the row here
                 if (err) {
-                    reject(new Error('getVersion failed: ' + `${err.message}`));
+                    reject('getVersion failed: ' + `${err.message}`);
                 }
                 else {
                     if (row == null) {
@@ -150,7 +152,7 @@ class UtilsSQLite {
         return new Promise((resolve, reject) => {
             mDB.run(`PRAGMA user_version = ${version}`, (err) => {
                 if (err) {
-                    reject(new Error('setVersion failed: ' + `${err.message}`));
+                    reject('setVersion failed: ' + `${err.message}`);
                 }
                 resolve();
             });
@@ -215,12 +217,12 @@ class UtilsSQLite {
         return new Promise((resolve, reject) => {
             const msg = 'BeginTransaction: ';
             if (!isOpen) {
-                return Promise.reject(new Error(`${msg}database not opened`));
+                return Promise.reject(`${msg}database not opened`);
             }
             const sql = 'BEGIN TRANSACTION;';
             db.run(sql, (err) => {
                 if (err) {
-                    reject(new Error(`${msg}${err.message}`));
+                    reject(`${msg}${err.message}`);
                 }
                 resolve();
             });
@@ -235,12 +237,12 @@ class UtilsSQLite {
         return new Promise((resolve, reject) => {
             const msg = 'RollbackTransaction: ';
             if (!isOpen) {
-                reject(new Error(`${msg}database not opened`));
+                reject(`${msg}database not opened`);
             }
             const sql = 'ROLLBACK TRANSACTION;';
             db.run(sql, (err) => {
                 if (err) {
-                    reject(new Error(`${msg}${err.message}`));
+                    reject(`${msg}${err.message}`);
                 }
                 resolve();
             });
@@ -255,12 +257,12 @@ class UtilsSQLite {
         return new Promise((resolve, reject) => {
             const msg = 'CommitTransaction: ';
             if (!isOpen) {
-                reject(new Error(`${msg}database not opened`));
+                reject(`${msg}database not opened`);
             }
             const sql = 'COMMIT TRANSACTION;';
             db.run(sql, (err) => {
                 if (err) {
-                    reject(new Error(`${msg}${err.message}`));
+                    reject(`${msg}${err.message}`);
                 }
                 resolve();
             });
@@ -278,7 +280,7 @@ class UtilsSQLite {
             db.get(SELECT_CHANGE, [], (err, row) => {
                 // process the row here
                 if (err) {
-                    reject(new Error(`DbChanges failed: ${err.message}`));
+                    reject(`DbChanges failed: ${err.message}`);
                 }
                 else {
                     if (row == null) {
@@ -304,9 +306,7 @@ class UtilsSQLite {
             db.get(SELECT_LAST_ID, [], (err, row) => {
                 // process the row here
                 if (err) {
-                    let msg = 'GetLastId failed: ';
-                    msg += `${err.message}`;
-                    reject(new Error(msg));
+                    reject(`GetLastId failed: ${err.message}`);
                 }
                 else {
                     if (row == null)
@@ -333,7 +333,7 @@ class UtilsSQLite {
             return Promise.resolve(changes);
         }
         catch (err) {
-            return Promise.reject(new Error(`Execute: ${err.message}`));
+            return Promise.reject(`Execute: ${err.message}`);
         }
     }
     /**
@@ -345,8 +345,7 @@ class UtilsSQLite {
         return new Promise((resolve, reject) => {
             mDB.exec(sql, async (err) => {
                 if (err) {
-                    const msg = err.message;
-                    reject(new Error(`Execute: ${msg}: `));
+                    reject(`Execute: ${err.message}: `);
                 }
                 resolve();
             });
@@ -365,7 +364,7 @@ class UtilsSQLite {
             if (statement == null) {
                 let msg = 'ExecuteSet: Error Nostatement';
                 msg += ` for index ${i}`;
-                return Promise.reject(new Error(msg));
+                return Promise.reject(msg);
             }
             try {
                 if (Array.isArray(values[0])) {
@@ -378,7 +377,7 @@ class UtilsSQLite {
                 }
             }
             catch (err) {
-                return Promise.reject(new Error(`ExecuteSet: ${err.message}`));
+                return Promise.reject(`ExecuteSet: ${err}`);
             }
         }
         return Promise.resolve(lastId);
@@ -394,9 +393,7 @@ class UtilsSQLite {
             let lastId = -1;
             db.run(statement, values, async (err) => {
                 if (err) {
-                    let msg = `PrepareRun: run `;
-                    msg += `${err.message}`;
-                    reject(new Error(msg));
+                    reject(`PrepareRun: run ${err.message}`);
                 }
                 else {
                     try {
@@ -404,9 +401,7 @@ class UtilsSQLite {
                         resolve(lastId);
                     }
                     catch (err) {
-                        let msg = `PrepareRun: lastId `;
-                        msg += `${err.message}`;
-                        reject(new Error(msg));
+                        reject(`PrepareRun: lastId ${err}`);
                     }
                 }
             });
@@ -423,7 +418,7 @@ class UtilsSQLite {
             mDB.serialize(() => {
                 mDB.all(sql, values, (err, rows) => {
                     if (err) {
-                        reject(new Error(`QueryAll: ${err.message}`));
+                        reject(`QueryAll: ${err.message}`);
                     }
                     else {
                         if (rows == null) {
@@ -518,7 +513,7 @@ class UtilsJson {
             await this._uSQLite.beginTransaction(mDB, true);
         }
         catch (err) {
-            return Promise.reject(new Error(`CreateDatabaseSchema: ${err.message}`));
+            return Promise.reject(`CreateDatabaseSchema: ${err}`);
         }
         const stmts = await this.createSchemaStatement(jsonData);
         if (stmts.length > 0) {
@@ -530,18 +525,18 @@ class UtilsJson {
                         await this._uSQLite.rollbackTransaction(mDB, true);
                     }
                     catch (err) {
-                        return Promise.reject(new Error('CreateSchema: changes < 0 ' + `${err.message}`));
+                        return Promise.reject('CreateSchema: changes < 0 ' + `${err}`);
                     }
                 }
             }
             catch (err) {
-                const msg = err.message;
+                const msg = err;
                 try {
                     await this._uSQLite.rollbackTransaction(mDB, true);
-                    return Promise.reject(new Error(`CreateSchema: ${msg}`));
+                    return Promise.reject(`CreateSchema: ${msg}`);
                 }
                 catch (err) {
-                    return Promise.reject(new Error('CreateSchema: changes < 0 ' + `${err.message}: ${msg}`));
+                    return Promise.reject('CreateSchema: changes < 0 ' + `${err}: ${msg}`);
                 }
             }
         }
@@ -550,7 +545,7 @@ class UtilsJson {
             return Promise.resolve(changes);
         }
         catch (err) {
-            return Promise.reject(new Error('CreateSchema: commit ' + `${err.message}`));
+            return Promise.reject('CreateSchema: commit ' + `${err}`);
         }
     }
     /**
@@ -643,21 +638,21 @@ class UtilsJson {
             // Check if the table exists
             const tableExists = await this.isTableExists(mDB, true, table.name);
             if (!tableExists) {
-                return Promise.reject(new Error('CreateDataTable: Table ' + `${table.name} does not exist`));
+                return Promise.reject('CreateDataTable: Table ' + `${table.name} does not exist`);
             }
             // Get the column names and types
             const tableNamesTypes = await this.getTableColumnNamesTypes(mDB, table.name);
             const tableColumnTypes = tableNamesTypes.types;
             const tableColumnNames = tableNamesTypes.names;
             if (tableColumnTypes.length === 0) {
-                return Promise.reject(new Error('CreateDataTable: Table ' + `${table.name} info does not exist`));
+                return Promise.reject('CreateDataTable: Table ' + `${table.name} info does not exist`);
             }
             // Loop on Table Values
             for (let j = 0; j < table.values.length; j++) {
                 // Check the row number of columns
                 if (table.values[j].length != tableColumnTypes.length) {
-                    return Promise.reject(new Error(`CreateDataTable: Table ${table.name} ` +
-                        `values row ${j} not correct length`));
+                    return Promise.reject(`CreateDataTable: Table ${table.name} ` +
+                        `values row ${j} not correct length`);
                 }
                 // Check the column's type before proceeding
                 // remove type checking for allowing RDBMS Types
@@ -687,8 +682,8 @@ class UtilsJson {
                     // Update
                     const setString = await this.setNameForUpdate(tableColumnNames);
                     if (setString.length === 0) {
-                        return Promise.reject(new Error(`CreateDataTable: Table ${table.name} ` +
-                            `values row ${j} not set to String`));
+                        return Promise.reject(`CreateDataTable: Table ${table.name} ` +
+                            `values row ${j} not set to String`);
                     }
                     stmt = `UPDATE ${table.name} SET ${setString} WHERE `;
                     if (typeof table.values[j][0] == 'string') {
@@ -700,13 +695,13 @@ class UtilsJson {
                 }
                 lastId = await this._uSQLite.prepareRun(mDB, stmt, table.values[j]);
                 if (lastId < 0) {
-                    return Promise.reject(new Error('CreateDataTable: lastId < 0'));
+                    return Promise.reject('CreateDataTable: lastId < 0');
                 }
             }
             return Promise.resolve(lastId);
         }
         catch (err) {
-            return Promise.reject(new Error(`CreateDataTable: ${err.message}`));
+            return Promise.reject(`CreateDataTable: ${err}`);
         }
     }
     /**
@@ -730,7 +725,7 @@ class UtilsJson {
             return Promise.resolve({ names: retNames, types: retTypes });
         }
         catch (err) {
-            return Promise.reject(new Error('GetTableColumnNamesTypes: ' + `${err.message}`));
+            return Promise.reject('GetTableColumnNamesTypes: ' + `${err}`);
         }
     }
     /**
@@ -798,7 +793,7 @@ class UtilsJson {
             return Promise.resolve(ret);
         }
         catch (err) {
-            return Promise.reject(new Error(`IsIdExists: ${err.message}`));
+            return Promise.reject(`IsIdExists: ${err}`);
         }
     }
     /**
@@ -816,7 +811,7 @@ class UtilsJson {
                 resolve(retString);
             }
             else {
-                reject(new Error('CreateQuestionMarkString: length = 0'));
+                reject('CreateQuestionMarkString: length = 0');
             }
         });
     }
@@ -834,7 +829,7 @@ class UtilsJson {
             return Promise.resolve(retString);
         }
         else {
-            return Promise.reject(new Error('SetNameForUpdate: length = 0'));
+            return Promise.reject('SetNameForUpdate: length = 0');
         }
     }
     /**
@@ -1070,7 +1065,7 @@ class UtilsJson {
             }
             const isValid = this.isSchema(sch);
             if (!isValid) {
-                return Promise.reject(new Error(`CheckSchemaValidity: schema[${i}] not valid`));
+                return Promise.reject(`CheckSchemaValidity: schema[${i}] not valid`);
             }
         }
         return Promise.resolve();
@@ -1094,7 +1089,7 @@ class UtilsJson {
             }
             const isValid = this.isIndexes(index);
             if (!isValid) {
-                return Promise.reject(new Error(`CheckIndexesValidity: indexes[${i}] not valid`));
+                return Promise.reject(`CheckIndexesValidity: indexes[${i}] not valid`);
             }
         }
         return Promise.resolve();
@@ -1121,7 +1116,7 @@ class UtilsJson {
             }
             const isValid = this.isTriggers(trigger);
             if (!isValid) {
-                return Promise.reject(new Error(`CheckTriggersValidity: triggers[${i}] not valid`));
+                return Promise.reject(`CheckTriggersValidity: triggers[${i}] not valid`);
             }
         }
         return Promise.resolve();
@@ -1142,7 +1137,7 @@ class UtilsJson {
             }
             const isValid = this.isView(view);
             if (!isValid) {
-                return Promise.reject(new Error(`CheckViewsValidity: views[${i}] not valid`));
+                return Promise.reject(`CheckViewsValidity: views[${i}] not valid`);
             }
         }
         return Promise.resolve();
@@ -1157,12 +1152,12 @@ class UtilsJson {
         try {
             const changes = await this._uSQLite.execute(mDB, stmt);
             if (changes < 0) {
-                return Promise.reject(new Error(`CreateView: ${view.name} failed`));
+                return Promise.reject(`CreateView: ${view.name} failed`);
             }
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(new Error(`CreateView: ${err.message}`));
+            return Promise.reject(`CreateView: ${err}`);
         }
     }
 }
@@ -1193,7 +1188,7 @@ class ExportToJson {
             // get Table's name
             const resTables = await this.getTablesNameSQL(mDB);
             if (resTables.length === 0) {
-                return Promise.reject(new Error("createExportObject: table's names failed"));
+                return Promise.reject("createExportObject: table's names failed");
             }
             else {
                 switch (sqlObj.mode) {
@@ -1212,7 +1207,7 @@ class ExportToJson {
                     }
                 }
                 if (errmsg.length > 0) {
-                    return Promise.reject(new Error(errmsg));
+                    return Promise.reject(errmsg);
                 }
                 if (tables.length > 0) {
                     retObj.database = sqlObj.database;
@@ -1228,7 +1223,7 @@ class ExportToJson {
             }
         }
         catch (err) {
-            return Promise.reject(new Error('createExportObject: ' + err.message));
+            return Promise.reject('createExportObject: ' + err);
         }
     }
     /**
@@ -1246,7 +1241,7 @@ class ExportToJson {
             return Promise.resolve(retQuery);
         }
         catch (err) {
-            return Promise.reject(new Error(`getTablesNameSQL: ${err.message}`));
+            return Promise.reject(`getTablesNameSQL: ${err}`);
         }
     }
     /**
@@ -1269,7 +1264,7 @@ class ExportToJson {
             return Promise.resolve(views);
         }
         catch (err) {
-            return Promise.reject(new Error(`getViewsName: ${err.message}`));
+            return Promise.reject(`getViewsName: ${err}`);
         }
     }
     /**
@@ -1284,7 +1279,7 @@ class ExportToJson {
             mDb.get(stmt, [], (err, row) => {
                 // process the row here
                 if (err) {
-                    reject(new Error(`GetSyncDate: ${err.message}`));
+                    reject(`GetSyncDate: ${err.message}`);
                 }
                 else {
                     if (row != null) {
@@ -1293,7 +1288,7 @@ class ExportToJson {
                         resolve(retDate);
                     }
                     else {
-                        reject(new Error(`GetSyncDate: no syncDate`));
+                        reject(`GetSyncDate: no syncDate`);
                     }
                 }
             });
@@ -1374,12 +1369,12 @@ class ExportToJson {
                 tables.push(table);
             }
             if (errmsg.length > 0) {
-                return Promise.reject(new Error(errmsg));
+                return Promise.reject(errmsg);
             }
             return Promise.resolve(tables);
         }
         catch (err) {
-            return Promise.reject(new Error(`GetTablesFull: ${err.message}`));
+            return Promise.reject(`GetTablesFull: ${err}`);
         }
     }
     /**
@@ -1431,7 +1426,7 @@ class ExportToJson {
             return Promise.resolve(schema);
         }
         catch (err) {
-            return Promise.reject(new Error(err.message));
+            return Promise.reject(err);
         }
     }
     /**
@@ -1475,13 +1470,13 @@ class ExportToJson {
                     }
                 }
                 if (errmsg.length > 0) {
-                    return Promise.reject(new Error(errmsg));
+                    return Promise.reject(errmsg);
                 }
             }
             return Promise.resolve(indexes);
         }
         catch (err) {
-            return Promise.reject(new Error(`GetIndexes: ${err.message}`));
+            return Promise.reject(`GetIndexes: ${err}`);
         }
     }
     /**
@@ -1506,22 +1501,22 @@ class ExportToJson {
                             const name = rTrg['name'];
                             let sqlArr = sql.split(name);
                             if (sqlArr.length != 2) {
-                                return Promise.reject(new Error(`GetTriggers: sql split name does not return 2 values`));
+                                return Promise.reject(`GetTriggers: sql split name does not return 2 values`);
                             }
                             if (!sqlArr[1].includes(tableName)) {
-                                return Promise.reject(new Error(`GetTriggers: sql split does not contains ${tableName}`));
+                                return Promise.reject(`GetTriggers: 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(new Error(`GetTriggers: sql split tableName does not return 2 values`));
+                                return Promise.reject(`GetTriggers: 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(new Error(`GetTriggers: sql split BEGIN does not return 2 values`));
+                                    return Promise.reject(`GetTriggers: sql split BEGIN does not return 2 values`);
                                 }
                                 condition = sqlArr[0].trim();
                                 logic = 'BEGIN' + sqlArr[1];
@@ -1538,18 +1533,18 @@ class ExportToJson {
                             triggers.push(trigger);
                         }
                         else {
-                            return Promise.reject(new Error(`GetTriggers: Table ${tableName} doesn't match`));
+                            return Promise.reject(`GetTriggers: Table ${tableName} doesn't match`);
                         }
                     }
                     else {
-                        return Promise.reject(new Error(`GetTriggers: Table ${tableName} creating indexes`));
+                        return Promise.reject(`GetTriggers: Table ${tableName} creating indexes`);
                     }
                 }
             }
             return Promise.resolve(triggers);
         }
         catch (err) {
-            return Promise.reject(new Error(`GetTriggers: ${err.message}`));
+            return Promise.reject(`GetTriggers: ${err}`);
         }
     }
     /**
@@ -1568,7 +1563,7 @@ class ExportToJson {
                 rowNames = tableNamesTypes.names;
             }
             else {
-                return Promise.reject(new Error(`GetValues: Table ${tableName} no names`));
+                return Promise.reject(`GetValues: Table ${tableName} no names`);
             }
             const retValues = await this._uSQLite.queryAll(mDb, query, []);
             for (const rValue of retValues) {
@@ -1586,7 +1581,7 @@ class ExportToJson {
             return Promise.resolve(values);
         }
         catch (err) {
-            return Promise.reject(new Error(`GetValues: ${err.message}`));
+            return Promise.reject(`GetValues: ${err}`);
         }
     }
     /**
@@ -1690,12 +1685,12 @@ class ExportToJson {
                 tables.push(table);
             }
             if (errmsg.length > 0) {
-                return Promise.reject(new Error(errmsg));
+                return Promise.reject(errmsg);
             }
             return Promise.resolve(tables);
         }
         catch (err) {
-            return Promise.reject(new Error(`GetTablesPartial: ${err.message}`));
+            return Promise.reject(`GetTablesPartial: ${err}`);
         }
     }
     /**
@@ -1709,20 +1704,20 @@ class ExportToJson {
             // get the synchronization date
             const syncDate = await this.getSyncDate(mDb);
             if (syncDate <= 0) {
-                return Promise.reject(new Error(`GetPartialModeData: no syncDate`));
+                return Promise.reject(`GetPartialModeData: 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(new Error(`GetPartialModeData: no modTables`));
+                return Promise.reject(`GetPartialModeData: no modTables`);
             }
             retData.syncDate = syncDate;
             retData.modTables = modTables;
             return Promise.resolve(retData);
         }
         catch (err) {
-            return Promise.reject(new Error(`GetPartialModeData: ${err.message}`));
+            return Promise.reject(`GetPartialModeData: ${err}`);
         }
     }
     async getTablesModified(db, tables, syncDate) {
@@ -1761,12 +1756,12 @@ class ExportToJson {
                 retModified[key] = mode;
             }
             if (errmsg.length > 0) {
-                return Promise.reject(new Error(errmsg));
+                return Promise.reject(errmsg);
             }
             return Promise.resolve(retModified);
         }
         catch (err) {
-            return Promise.reject(new Error(`GetTableModified: ${err.message}`));
+            return Promise.reject(`GetTableModified: ${err}`);
         }
     }
     async modEmbeddedParentheses(sstr) {
@@ -1840,7 +1835,7 @@ class UtilsDrop {
             return Promise.resolve(retArr);
         }
         catch (err) {
-            return Promise.reject(new Error(`getTablesNames: ${err.message}`));
+            return Promise.reject(`getTablesNames: ${err}`);
         }
     }
     /**
@@ -1860,7 +1855,7 @@ class UtilsDrop {
             return Promise.resolve(retArr);
         }
         catch (err) {
-            return Promise.reject(new Error(`getViewsNames: ${err.message}`));
+            return Promise.reject(`getViewsNames: ${err}`);
         }
     }
     /**
@@ -1884,7 +1879,7 @@ class UtilsDrop {
                 msg = 'DropViews';
                 break;
             default:
-                return Promise.reject(new Error(`DropElements: ${type} ` + 'not found'));
+                return Promise.reject(`DropElements: ${type} ` + 'not found');
         }
         // get the element's names
         let stmt = 'SELECT name FROM sqlite_master WHERE ';
@@ -1902,14 +1897,14 @@ class UtilsDrop {
                 for (const stmt of statements) {
                     const lastId = await this._uSQLite.prepareRun(db, stmt, []);
                     if (lastId < 0) {
-                        return Promise.reject(new Error(`${msg}: lastId < 0`));
+                        return Promise.reject(`${msg}: lastId < 0`);
                     }
                 }
             }
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(new Error(`${msg}: ${err.message}`));
+            return Promise.reject(`${msg}: ${err}`);
         }
     }
     /**
@@ -1932,7 +1927,7 @@ class UtilsDrop {
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(new Error(`DropAll: ${err.message}`));
+            return Promise.reject(`DropAll: ${err}`);
         }
     }
     /**
@@ -1951,12 +1946,12 @@ class UtilsDrop {
         try {
             const changes = await this._uSQLite.execute(db, statements.join('\n'));
             if (changes < 0) {
-                return Promise.reject(new Error('DropTempTables: changes < 0'));
+                return Promise.reject('DropTempTables: changes < 0');
             }
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(new Error(`DropTempTables: ${err.message}`));
+            return Promise.reject(`DropTempTables: ${err}`);
         }
     }
 }
@@ -1995,7 +1990,7 @@ class ImportFromJson {
             return Promise.resolve(changes);
         }
         catch (err) {
-            return Promise.reject(new Error('CreateDatabaseSchema: ' + `${err.message}`));
+            return Promise.reject('CreateDatabaseSchema: ' + `${err}`);
         }
     }
     async createTablesData(mDB, jsonData) {
@@ -2010,7 +2005,7 @@ class ImportFromJson {
             await this._uSQLite.beginTransaction(mDB, true);
         }
         catch (err) {
-            return Promise.reject(new Error(`createTablesData: ${err.message}`));
+            return Promise.reject(`createTablesData: ${err}`);
         }
         for (const jTable of jsonData.tables) {
             if (jTable.values != null && jTable.values.length >= 1) {
@@ -2022,7 +2017,7 @@ class ImportFromJson {
                     isValue = true;
                 }
                 catch (err) {
-                    msg = err.message;
+                    msg = err;
                     isValue = false;
                     break;
                 }
@@ -2035,7 +2030,7 @@ class ImportFromJson {
                 return Promise.resolve(changes);
             }
             catch (err) {
-                return Promise.reject(new Error('createTablesData: ' + `${err.message}`));
+                return Promise.reject('createTablesData: ' + `${err}`);
             }
         }
         else {
@@ -2045,7 +2040,7 @@ class ImportFromJson {
                     return Promise.reject(new Error(`createTablesData: ${msg}`));
                 }
                 catch (err) {
-                    return Promise.reject(new Error('createTablesData: ' + `${err.message}: ${msg}`));
+                    return Promise.reject('createTablesData: ' + `${err}: ${msg}`);
                 }
             }
             else {
@@ -2070,7 +2065,7 @@ class ImportFromJson {
             await this._uSQLite.beginTransaction(mDB, true);
         }
         catch (err) {
-            return Promise.reject(new Error(`createViews: ${err.message}`));
+            return Promise.reject(`createViews: ${err}`);
         }
         for (const jView of jsonData.views) {
             if (jView.value != null) {
@@ -2080,7 +2075,7 @@ class ImportFromJson {
                     isView = true;
                 }
                 catch (err) {
-                    msg = err.message;
+                    msg = err;
                     isView = false;
                     break;
                 }
@@ -2093,7 +2088,7 @@ class ImportFromJson {
                 return Promise.resolve(changes);
             }
             catch (err) {
-                return Promise.reject(new Error('createViews: ' + `${err.message}`));
+                return Promise.reject('createViews: ' + `${err}`);
             }
         }
         else {
@@ -2103,7 +2098,7 @@ class ImportFromJson {
                     return Promise.reject(new Error(`createViews: ${msg}`));
                 }
                 catch (err) {
-                    return Promise.reject(new Error('createViews: ' + `${err.message}: ${msg}`));
+                    return Promise.reject('createViews: ' + `${err}: ${msg}`);
                 }
             }
             else {
@@ -2124,6 +2119,7 @@ class UtilsFile {
         this.pathDB = 'Databases';
         this.Path = null;
         this.NodeFs = null;
+        this.JSZip = null;
         this.Os = null;
         this.AppName = '';
         this.HomeDir = '';
@@ -2131,6 +2127,7 @@ class UtilsFile {
         this.Path = require$$0__default$1['default'];
         this.NodeFs = require$$1__default['default'];
         this.Os = require$$2__default['default'];
+        this.JSZip = require$$3__default['default'];
         this.HomeDir = this.Os.homedir();
         const dir = __dirname;
         const idx = dir.indexOf('\\');
@@ -2229,15 +2226,13 @@ class UtilsFile {
      */
     setPathSuffix(db) {
         let toDb = db;
-        if (db.length > 9) {
-            const last9 = db.slice(-9);
-            if (last9 != 'SQLite.db') {
-                toDb = this.Path.parse(db).name + 'SQLite.db';
+        const ext = '.db';
+        const sep = this.Path.sep;
+        if (db.substring(db.length - 3) === ext) {
+            if (!db.includes('SQLite.db')) {
+                toDb = db.slice(db.lastIndexOf(sep) + 1, -3) + 'SQLite.db';
             }
         }
-        else {
-            toDb = toDb + 'SQLite.db';
-        }
         return toDb;
     }
     /**
@@ -2249,7 +2244,7 @@ class UtilsFile {
         const filenames = this.NodeFs.readdirSync(path);
         const dbs = [];
         filenames.forEach((file) => {
-            if (this.Path.extname(file) == '.db')
+            if (this.Path.extname(file) == '.db' || this.Path.extname(file) == '.zip')
                 dbs.push(file);
         });
         return Promise.resolve(dbs);
@@ -2257,14 +2252,51 @@ class UtilsFile {
     /**
      * CopyFromAssetToDatabase
      * @param db
-     * @param toDb
+     * @param overwrite
      */
-    async copyFromAssetToDatabase(db, toDb) {
+    async copyFromAssetToDatabase(db, overwrite) {
         const pAsset = this.Path.join(this.getAssetsDatabasesPath(), db);
+        const toDb = this.setPathSuffix(db);
         const pDb = this.Path.join(this.getDatabasesPath(), toDb);
-        await this.copyFilePath(pAsset, pDb);
+        await this.copyFilePath(pAsset, pDb, overwrite);
         return Promise.resolve();
     }
+    /**
+     * unzipDatabase
+     * @param db
+     * @param overwrite
+     */
+    async unzipDatabase(db, overwrite) {
+        const pZip = this.Path.join(this.getAssetsDatabasesPath(), db);
+        // Read the Zip file
+        this.NodeFs.readFile(pZip, (err, data) => {
+            if (err) {
+                console.log(err);
+                return Promise.reject(`unzipDatabase ${JSON.stringify(err)}`);
+            }
+            const zip = new this.JSZip();
+            zip.loadAsync(data).then((contents) => {
+                Object.keys(contents.files).forEach(filename => {
+                    zip
+                        .file(filename)
+                        .async('nodebuffer')
+                        .then(async (content) => {
+                        const toDb = this.setPathSuffix(filename);
+                        const pDb = this.Path.join(this.getDatabasesPath(), toDb);
+                        // check filePath exists
+                        const isPath = this.isPathExists(pDb);
+                        if (!isPath || overwrite) {
+                            if (overwrite && isPath) {
+                                await this.deleteFilePath(pDb);
+                            }
+                            this.NodeFs.writeFileSync(pDb, content);
+                        }
+                        return Promise.resolve();
+                    });
+                });
+            });
+        });
+    }
     /**
      * CopyFileName
      * Copy file name
@@ -2277,15 +2309,15 @@ class UtilsFile {
         const toFilePath = this.getFilePath(toFileName);
         if (filePath.length !== 0 && toFilePath.length !== 0) {
             try {
-                await this.copyFilePath(filePath, toFilePath);
+                await this.copyFilePath(filePath, toFilePath, true);
                 return Promise.resolve();
             }
             catch (err) {
-                return Promise.reject(new Error(`CopyFileName: ${err.message}`));
+                return Promise.reject(`CopyFileName: ${err}`);
             }
         }
         else {
-            return Promise.reject(new Error('CopyFileName: cannot get the ' + 'filePath'));
+            return Promise.reject('CopyFileName: cannot get the ' + 'filePath');
         }
     }
     /**
@@ -2294,26 +2326,25 @@ class UtilsFile {
      * @param filePath
      * @param toFilePath
      */
-    async copyFilePath(filePath, toFilePath) {
+    async copyFilePath(filePath, toFilePath, overwrite) {
         if (filePath.length !== 0 && toFilePath.length !== 0) {
             // check filePath exists
-            const isPath = this.isPathExists(filePath);
-            if (isPath) {
+            const isPath = this.isPathExists(toFilePath);
+            if (!isPath || overwrite) {
                 try {
-                    await this.deleteFilePath(toFilePath);
+                    if (overwrite && isPath) {
+                        await this.deleteFilePath(toFilePath);
+                    }
                     this.NodeFs.copyFileSync(filePath, toFilePath);
-                    return Promise.resolve();
                 }
                 catch (err) {
-                    return Promise.reject(new Error(`CopyFilePath: ${err.message}`));
+                    return Promise.reject(`CopyFilePath: ${err}`);
                 }
             }
-            else {
-                return Promise.reject(new Error('CopyFilePath: filePath does not ' + 'exist'));
-            }
+            return Promise.resolve();
         }
         else {
-            return Promise.reject(new Error('CopyFilePath: cannot get the ' + 'filePath'));
+            return Promise.reject('CopyFilePath: cannot get the ' + 'filePath');
         }
     }
     async copyFile(fromPath, fromFile, toPath, toFile) {
@@ -2324,7 +2355,7 @@ class UtilsFile {
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(new Error(`CopyFile: ${err.message}`));
+            return Promise.reject(`CopyFile: ${err}`);
         }
     }
     /**
@@ -2341,11 +2372,11 @@ class UtilsFile {
                 return Promise.resolve();
             }
             catch (err) {
-                return Promise.reject(new Error('DeleteFileName: delete filePath ' + `failed ${err.message}`));
+                return Promise.reject('DeleteFileName: delete filePath ' + `failed ${err}`);
             }
         }
         else {
-            return Promise.reject(new Error('DeleteFileName: get filePath ' + 'failed'));
+            return Promise.reject('DeleteFileName: get filePath ' + 'failed');
         }
     }
     /**
@@ -2363,7 +2394,7 @@ class UtilsFile {
                     return Promise.resolve();
                 }
                 catch (err) {
-                    return Promise.reject(new Error('DeleteFilePath: ' + `${err.message}`));
+                    return Promise.reject('DeleteFilePath: ' + `${err}`);
                 }
             }
             else {
@@ -2371,7 +2402,7 @@ class UtilsFile {
             }
         }
         else {
-            return Promise.reject(new Error('DeleteFilePath: delete filePath' + 'failed'));
+            return Promise.reject('DeleteFilePath: delete filePath' + 'failed');
         }
     }
     /**
@@ -2389,11 +2420,11 @@ class UtilsFile {
                 return Promise.resolve();
             }
             catch (err) {
-                return Promise.reject(new Error(`RenameFileName: ${err.message}`));
+                return Promise.reject(`RenameFileName: ${err}`);
             }
         }
         else {
-            return Promise.reject(new Error('RenameFileName: filePaths do not ' + 'exist'));
+            return Promise.reject('RenameFileName: filePaths do not ' + 'exist');
         }
     }
     /**
@@ -2413,15 +2444,15 @@ class UtilsFile {
                     return Promise.resolve();
                 }
                 catch (err) {
-                    return Promise.reject(new Error('RenameFilePath: ' + `${err.message}`));
+                    return Promise.reject('RenameFilePath: ' + `${err}`);
                 }
             }
             else {
-                return Promise.reject(new Error('RenameFilePath: filePath ' + 'does not exist'));
+                return Promise.reject('RenameFilePath: filePath ' + 'does not exist');
             }
         }
         else {
-            return Promise.reject(new Error('RenameFilePath: filePath not found'));
+            return Promise.reject('RenameFilePath: filePath not found');
         }
     }
     /**
@@ -2442,15 +2473,15 @@ class UtilsFile {
                     return Promise.resolve();
                 }
                 catch (err) {
-                    return Promise.reject(new Error('RestoreFileName: ' + `${err.message}`));
+                    return Promise.reject('RestoreFileName: ' + `${err}`);
                 }
             }
             else {
-                return Promise.reject(new Error(`RestoreFileName: ${fileName} ` + 'does not exist'));
+                return Promise.reject(`RestoreFileName: ${fileName} ` + 'does not exist');
             }
         }
         else {
-            return Promise.reject(new Error(`RestoreFileName: ${mFileName} ` + 'does not exist'));
+            return Promise.reject(`RestoreFileName: ${mFileName} ` + 'does not exist');
         }
     }
     /**
@@ -2520,11 +2551,11 @@ class UtilsUpgrade {
         if (upgrade != null) {
             const keys = Object.keys(upgrade);
             if (!keys.includes('toVersion')) {
-                return Promise.reject(new Error('onUpgrade: toVersion not given'));
+                return Promise.reject('onUpgrade: toVersion not given');
             }
             const toVersion = upgrade.toVersion;
             if (!keys.includes('statement')) {
-                return Promise.reject(new Error('onUpgrade: statement not given'));
+                return Promise.reject('onUpgrade: statement not given');
             }
             const statement = upgrade.statement;
             let set = [];
@@ -2537,7 +2568,7 @@ class UtilsUpgrade {
                 msg += `version ${toVersion} , but target version `;
                 msg += `is ${targetVersion} for database ${dbName}`;
                 msg += ` and version ${curVersion}`;
-                return Promise.reject(new Error(`onUpgrade: ${msg}`));
+                return Promise.reject(`onUpgrade: ${msg}`);
             }
             try {
                 // set Foreign Keys Off
@@ -2563,11 +2594,11 @@ class UtilsUpgrade {
                 return Promise.resolve(changes);
             }
             catch (err) {
-                return Promise.reject(new Error(`onUpgrade: ${err.message}`));
+                return Promise.reject(`onUpgrade: ${err}`);
             }
         }
         else {
-            return Promise.reject(new Error('onUpgrade: upgrade not found'));
+            return Promise.reject('onUpgrade: upgrade not found');
         }
     }
     /**
@@ -2587,7 +2618,7 @@ class UtilsUpgrade {
             // -> Create new tables from upgrade.statement
             const changes = await this._uSQLite.execute(mDB, statement);
             if (changes < 0) {
-                return Promise.reject(new Error('ExecuteStatementProcess: ' + 'changes < 0'));
+                return Promise.reject('ExecuteStatementProcess: ' + 'changes < 0');
             }
             // -> Create the list of table's common fields
             await this.findCommonColumns(mDB);
@@ -2603,7 +2634,7 @@ class UtilsUpgrade {
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(new Error(`ExecuteStatementProcess: ${err.message}`));
+            return Promise.reject(`ExecuteStatementProcess: ${err}`);
         }
     }
     /**
@@ -2617,7 +2648,7 @@ class UtilsUpgrade {
             // -> load new data
             const lastId = await this._uSQLite.executeSet(mDB, set);
             if (lastId < 0) {
-                return Promise.reject(new Error('ExecuteSetProcess: lastId ' + '< 0'));
+                return Promise.reject('ExecuteSetProcess: lastId ' + '< 0');
             }
             // -> update database version
             await this._uSQLite.setVersion(mDB, toVersion);
@@ -2629,13 +2660,13 @@ class UtilsUpgrade {
                 stmt += `sync_date = ${sDate} WHERE id = 1;`;
                 const changes = await this._uSQLite.execute(mDB, stmt);
                 if (changes < 0) {
-                    return Promise.reject(new Error('ExecuteSetProcess: changes ' + '< 0'));
+                    return Promise.reject('ExecuteSetProcess: changes ' + '< 0');
                 }
             }
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(new Error(`ExecuteSetProcess: ${err.message}`));
+            return Promise.reject(`ExecuteSetProcess: ${err}`);
         }
     }
     /**
@@ -2651,13 +2682,13 @@ class UtilsUpgrade {
                     await this.backupTable(mDB, table);
                 }
                 catch (err) {
-                    return Promise.reject(new Error(`${msg}table ${table}: ` + `${err.message}`));
+                    return Promise.reject(`${msg}table ${table}: ` + `${err}`);
                 }
             }
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(new Error(`BackupTables: ${err.message}`));
+            return Promise.reject(`BackupTables: ${err}`);
         }
     }
     /**
@@ -2682,22 +2713,22 @@ class UtilsUpgrade {
                     await this._uSQLite.rollbackTransaction(mDB, true);
                 }
                 catch (err) {
-                    msg += `: ${err.message}`;
+                    msg += `: ${err}`;
                 }
-                return Promise.reject(new Error(`${msg}`));
+                return Promise.reject(`${msg}`);
             }
             else {
                 try {
                     await this._uSQLite.commitTransaction(mDB, true);
                 }
                 catch (err) {
-                    return Promise.reject(new Error('BackupTable: ' + `${err.message}`));
+                    return Promise.reject('BackupTable: ' + `${err}`);
                 }
             }
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(new Error(`BackupTable: ${err.message}`));
+            return Promise.reject(`BackupTable: ${err}`);
         }
     }
     /**
@@ -2719,7 +2750,7 @@ class UtilsUpgrade {
             return Promise.resolve(retNames);
         }
         catch (err) {
-            return Promise.reject(new Error('GetTableColumnNames: ' + `${err.message}`));
+            return Promise.reject('GetTableColumnNames: ' + `${err}`);
         }
     }
     /**
@@ -2731,7 +2762,7 @@ class UtilsUpgrade {
             // Get new table list
             const tables = await this._uDrop.getTablesNames(mDB);
             if (tables.length === 0) {
-                return Promise.reject(new Error('FindCommonColumns: get ' + "table's names failed"));
+                return Promise.reject('FindCommonColumns: get ' + "table's names failed");
             }
             for (const table of tables) {
                 // get the column's name
@@ -2745,7 +2776,7 @@ class UtilsUpgrade {
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(new Error(`FindCommonColumns: ${err.message}`));
+            return Promise.reject(`FindCommonColumns: ${err}`);
         }
     }
     /**
@@ -2787,9 +2818,9 @@ class UtilsUpgrade {
                     await this._uSQLite.rollbackTransaction(mDB, true);
                 }
                 catch (err) {
-                    msg += `: ${err.message}`;
+                    msg += `: ${err}`;
                 }
-                return Promise.reject(new Error(`${msg}`));
+                return Promise.reject(`${msg}`);
             }
             else {
                 try {
@@ -2797,12 +2828,12 @@ class UtilsUpgrade {
                     return Promise.resolve();
                 }
                 catch (err) {
-                    return Promise.reject(new Error('updateNewTablesData: ' + `${err.message}`));
+                    return Promise.reject('updateNewTablesData: ' + `${err}`);
                 }
             }
         }
         catch (err) {
-            return Promise.reject(new Error('updateNewTablesData: ' + `${err.message}`));
+            return Promise.reject('updateNewTablesData: ' + `${err}`);
         }
     }
 }
@@ -2898,7 +2929,7 @@ class Database {
                             await this._uFile.restoreFileName(this._dbName, 'backup');
                         }
                         catch (err) {
-                            return Promise.reject(new Error(`Open: ${err.message}`));
+                            return Promise.reject(`Open: ${err}`);
                         }
                     }
                 }
@@ -2907,7 +2938,7 @@ class Database {
                         await this._uSQLite.setVersion(this._mDB, this._version);
                     }
                     catch (err) {
-                        return Promise.reject(new Error(`SetVersion: ${this._version} ${err.message}`));
+                        return Promise.reject(`SetVersion: ${this._version} ${err}`);
                     }
                 }
             }
@@ -2916,7 +2947,7 @@ class Database {
         catch (err) {
             if (this._isDBOpen)
                 this.close();
-            return Promise.reject(new Error(`Open: ${err.message}`));
+            return Promise.reject(`Open: ${err}`);
         }
     }
     /**
@@ -2929,8 +2960,8 @@ class Database {
             this._mDB.close((err) => {
                 if (err) {
                     let msg = 'Close: Failed in closing: ';
-                    msg += `${this._dbName}  ${err.message}`;
-                    return Promise.reject(new Error(msg));
+                    msg += `${this._dbName}  ${err}`;
+                    return Promise.reject(msg);
                 }
                 this._isDBOpen = false;
                 return Promise.resolve();
@@ -2952,13 +2983,13 @@ class Database {
             catch (err) {
                 if (this._isDBOpen)
                     this.close();
-                return Promise.reject(new Error(`getVersion: ${err.message}`));
+                return Promise.reject(`getVersion: ${err}`);
             }
         }
         else {
             let msg = `getVersion: Database ${this._dbName} `;
             msg += `not opened`;
-            return Promise.reject(new Error(msg));
+            return Promise.reject(msg);
         }
     }
     /**
@@ -2976,7 +3007,7 @@ class Database {
                 await this.open();
             }
             catch (err) {
-                return Promise.reject(new Error(`DeleteDB: ${err.message}`));
+                return Promise.reject(`DeleteDB: ${err}`);
             }
         }
         // close the database
@@ -2984,7 +3015,7 @@ class Database {
             await this.close();
         }
         catch (err) {
-            return Promise.reject(new Error('DeleteDB: Close failed'));
+            return Promise.reject('DeleteDB: Close failed');
         }
         // delete the database
         if (isExists) {
@@ -2993,8 +3024,8 @@ class Database {
             }
             catch (err) {
                 let msg = `DeleteDB: deleteFile ${dbName}`;
-                msg += ` failed ${err.message}`;
-                return Promise.reject(new Error(msg));
+                msg += ` failed ${err}`;
+                return Promise.reject(msg);
             }
         }
         return Promise.resolve();
@@ -3005,19 +3036,20 @@ class Database {
      * @returns
      */
     async isTableExists(tableName) {
-        if (!this._isDBOpen) {
+        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}`);
+            }
+        }
+        else {
             let msg = `isTableExists: Database ${this._dbName} `;
             msg += `not opened`;
-            return Promise.reject(new Error(msg));
-        }
-        const isOpen = this._isDBOpen;
-        try {
-            const retB = await this._uJson.isTableExists(this._mDB, isOpen, tableName);
-            return Promise.resolve(retB);
-        }
-        catch (err) {
-            const msg = `IsTableExists: ${err.message}`;
-            return Promise.reject(new Error(msg));
+            return Promise.reject(msg);
         }
     }
     /**
@@ -3029,7 +3061,7 @@ class Database {
         if (!this._isDBOpen) {
             let msg = `CreateSyncTable: Database ${this._dbName} `;
             msg += `not opened`;
-            return Promise.reject(new Error(msg));
+            return Promise.reject(msg);
         }
         let changes = -1;
         const isOpen = this._isDBOpen;
@@ -3047,13 +3079,13 @@ class Database {
                             "${date}");`;
                 changes = await this._uSQLite.execute(this._mDB, stmts);
                 if (changes < 0) {
-                    return Promise.reject(new Error(`CreateSyncTable: failed changes < 0`));
+                    return Promise.reject(`CreateSyncTable: failed changes < 0`);
                 }
             }
             return Promise.resolve(changes);
         }
         catch (err) {
-            return Promise.reject(new Error(`CreateSyncTable: ${err.message}`));
+            return Promise.reject(`CreateSyncTable: ${err}`);
         }
     }
     /**
@@ -3081,7 +3113,7 @@ class Database {
             }
         }
         catch (err) {
-            return { result: false, message: `setSyncDate failed: ${err.message}` };
+            return { result: false, message: `setSyncDate failed: ${err}` };
         }
     }
     /**
@@ -3105,7 +3137,7 @@ class Database {
             }
         }
         catch (err) {
-            return { syncDate: 0, message: `setSyncDate failed: ${err.message}` };
+            return { syncDate: 0, message: `setSyncDate failed: ${err}` };
         }
     }
     /**
@@ -3118,29 +3150,29 @@ class Database {
         if (!this._isDBOpen) {
             let msg = `ExecuteSQL: Database ${this._dbName} `;
             msg += `not opened`;
-            return Promise.reject(new Error(msg));
+            return Promise.reject(msg);
         }
         try {
             if (transaction)
                 await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
             const changes = await this._uSQLite.execute(this._mDB, sql);
             if (changes < 0) {
-                return Promise.reject(new Error('ExecuteSQL: changes < 0'));
+                return Promise.reject('ExecuteSQL: changes < 0');
             }
             if (transaction)
                 await this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
             return Promise.resolve(changes);
         }
         catch (err) {
-            let msg = `ExecuteSQL: ${err.message}`;
+            let msg = `ExecuteSQL: ${err}`;
             try {
                 if (transaction)
                     await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
             }
             catch (err) {
-                msg += ` : ${err.message}`;
+                msg += ` : ${err}`;
             }
-            return Promise.reject(new Error(`ExecuteSQL: ${msg}`));
+            return Promise.reject(`ExecuteSQL: ${msg}`);
         }
     }
     /**
@@ -3154,14 +3186,14 @@ class Database {
         if (!this._isDBOpen) {
             let msg = `SelectSQL: Database ${this._dbName} `;
             msg += `not opened`;
-            return Promise.reject(new Error(msg));
+            return Promise.reject(msg);
         }
         try {
             const retArr = await this._uSQLite.queryAll(this._mDB, sql, values);
             return Promise.resolve(retArr);
         }
         catch (err) {
-            return Promise.reject(new Error(`SelectSQL: ${err.message}`));
+            return Promise.reject(`SelectSQL: ${err}`);
         }
     }
     /**
@@ -3175,7 +3207,7 @@ class Database {
         if (!this._isDBOpen) {
             let msg = `RunSQL: Database ${this._dbName} `;
             msg += `not opened`;
-            return Promise.reject(new Error(msg));
+            return Promise.reject(msg);
         }
         const retRes = { changes: -1, lastId: -1 };
         let initChanges = -1;
@@ -3186,14 +3218,14 @@ class Database {
                 await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
         }
         catch (err) {
-            return Promise.reject(new Error(`ExecSet: ${err.message}`));
+            return Promise.reject(`ExecSet: ${err}`);
         }
         try {
             const lastId = await this._uSQLite.prepareRun(this._mDB, statement, values);
             if (lastId < 0) {
                 if (transaction)
                     await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
-                return Promise.reject(new Error(`RunSQL: return LastId < 0`));
+                return Promise.reject(`RunSQL: return LastId < 0`);
             }
             if (transaction)
                 await this._uSQLite.commitTransaction(this._mDB, this._isDBOpen);
@@ -3204,7 +3236,7 @@ class Database {
         catch (err) {
             if (transaction)
                 await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
-            return Promise.reject(new Error(`RunSQL: ${err.message}`));
+            return Promise.reject(`RunSQL: ${err}`);
         }
     }
     /**
@@ -3217,7 +3249,7 @@ class Database {
         if (!this._isDBOpen) {
             let msg = `ExecSet: Database ${this._dbName} `;
             msg += `not opened`;
-            return Promise.reject(new Error(msg));
+            return Promise.reject(msg);
         }
         const retRes = { changes: -1, lastId: -1 };
         let initChanges = -1;
@@ -3228,7 +3260,7 @@ class Database {
                 await this._uSQLite.beginTransaction(this._mDB, this._isDBOpen);
         }
         catch (err) {
-            return Promise.reject(new Error(`ExecSet: ${err.message}`));
+            return Promise.reject(`ExecSet: ${err}`);
         }
         try {
             retRes.lastId = await this._uSQLite.executeSet(this._mDB, set);
@@ -3244,7 +3276,7 @@ class Database {
                     await this._uSQLite.rollbackTransaction(this._mDB, this._isDBOpen);
             }
             catch (err) {
-                return Promise.reject(new Error(`ExecSet: ${msg}: ` + `${err.message}`));
+                return Promise.reject(`ExecSet: ${msg}: ` + `${err}`);
             }
         }
     }
@@ -3267,11 +3299,11 @@ class Database {
                 return Promise.resolve(changes);
             }
             catch (err) {
-                return Promise.reject(new Error(`ImportJson: ${err.message}`));
+                return Promise.reject(`ImportJson: ${err}`);
             }
         }
         else {
-            return Promise.reject(new Error(`ImportJson: database is closed`));
+            return Promise.reject(`ImportJson: database is closed`);
         }
     }
     async exportJson(mode) {
@@ -3288,15 +3320,15 @@ class Database {
                     return Promise.resolve(retJson);
                 }
                 else {
-                    return Promise.reject(new Error(`ExportJson: retJson not valid`));
+                    return Promise.reject(`ExportJson: retJson not valid`);
                 }
             }
             catch (err) {
-                return Promise.reject(new Error(`ExportJson: ${err.message}`));
+                return Promise.reject(`ExportJson: ${err}`);
             }
         }
         else {
-            return Promise.reject(new Error(`ExportJson: database is closed`));
+            return Promise.reject(`ExportJson: database is closed`);
         }
     }
 }
@@ -3392,7 +3424,7 @@ class CapacitorSQLite {
                     'close ' +
                     dbName +
                     ' failed ' +
-                    err.message);
+                    err);
             }
         }
         // remove the connection from dictionary
@@ -3663,10 +3695,10 @@ class CapacitorSQLite {
         const mDB = this._dbDict[dbName];
         try {
             const res = await mDB.isTableExists(tableName);
-            return Promise.resolve({ result: res.result });
+            return Promise.resolve({ result: res });
         }
         catch (err) {
-            return Promise.reject(`isTableExists: ${err.message}`);
+            return Promise.reject(`isTableExists: ${err}`);
         }
     }
     async deleteDatabase(options) {
@@ -3685,7 +3717,7 @@ class CapacitorSQLite {
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(`Delete: ${err.message}`);
+            return Promise.reject(`Delete: ${err}`);
         }
     }
     async isJsonValid(options) {
@@ -3733,7 +3765,7 @@ class CapacitorSQLite {
             return Promise.resolve({ changes: { changes: changes } });
         }
         catch (err) {
-            return Promise.reject(`ImportFromJson: ${err.message}`);
+            return Promise.reject(`ImportFromJson: ${err}`);
         }
     }
     async exportToJson(options) {
@@ -3762,7 +3794,7 @@ class CapacitorSQLite {
             }
         }
         catch (err) {
-            return Promise.reject(`exportToJson: ${err.message}`);
+            return Promise.reject(`exportToJson: ${err}`);
         }
     }
     async createSyncTable(options) {
@@ -3781,7 +3813,7 @@ class CapacitorSQLite {
             return Promise.resolve({ changes: { changes: ret } });
         }
         catch (err) {
-            return Promise.reject(`createSyncTable: ${err.message}`);
+            return Promise.reject(`createSyncTable: ${err}`);
         }
     }
     async setSyncDate(options) {
@@ -3804,7 +3836,7 @@ class CapacitorSQLite {
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(`SetSyncDate: ${err.message}`);
+            return Promise.reject(`SetSyncDate: ${err}`);
         }
     }
     async getSyncDate(options) {
@@ -3823,7 +3855,7 @@ class CapacitorSQLite {
             return Promise.resolve(ret);
         }
         catch (err) {
-            return Promise.reject(`GetSyncDate: ${err.message}`);
+            return Promise.reject(`GetSyncDate: ${err}`);
         }
     }
     async addUpgradeStatement(options) {
@@ -3850,18 +3882,24 @@ class CapacitorSQLite {
         this._versionUpgrades[dbName] = upgVDict;
         return Promise.resolve();
     }
-    async copyFromAssets() {
+    async copyFromAssets(options) {
+        const keys = Object.keys(options);
+        const mOverwrite = keys.includes('overwrite') ? options.overwrite : true;
         // check if the assets/database folder exists
         const assetsDbPath = this._uFile.getAssetsDatabasesPath();
         const res = this._uFile.isPathExists(assetsDbPath);
         if (res) {
             // get the database files
             const dbList = await this._uFile.getFileList(assetsDbPath);
+            // loop through the database files
             dbList.forEach(async (db) => {
-                // for each check if the suffix SQLite.db is there or add it
-                const toDb = this._uFile.setPathSuffix(db);
-                // for each copy the file to the Application database folder
-                await this._uFile.copyFromAssetToDatabase(db, toDb);
+                if (db.substring(db.length - 3) === '.db') {
+                    // for each copy the file to the Application database folder
+                    await this._uFile.copyFromAssetToDatabase(db, mOverwrite);
+                }
+                if (db.substring(db.length - 4) === '.zip') {
+                    await this._uFile.unzipDatabase(db, mOverwrite);
+                }
             });
             return Promise.resolve();
         }
@@ -3939,7 +3977,7 @@ class CapacitorSQLite {
             }
         }
         catch (err) {
-            return Promise.reject(`CheckConnectionsConsistency: ${err.message}`);
+            return Promise.reject(`CheckConnectionsConsistency: ${err}`);
         }
     }
     async resetDbDict(keys) {
@@ -3951,7 +3989,7 @@ class CapacitorSQLite {
             }
         }
         catch (err) {
-            return Promise.reject(`ResetDbDict: ${err.message}`);
+            return Promise.reject(`ResetDbDict: ${err}`);
         }
     }
     async symmetricDifference(setA, setB) {