@capacitor-community/sqlite 4.1.0-3 → 4.1.0-6

package/electron/dist/plugin.js

@@ -43,10 +43,6 @@ class UtilsSQLite {
     password: string,*/) {
         const msg = 'OpenOrCreateDatabase: ';
         // open sqlite3 database
-        /*    const mDB: any = new this.JSQlite.Database(pathDB, {
-          verbose: console.log,
-        });
-        */
         const mDB = new this.SQLite3.Database(pathDB, {
             verbose: console.log,
         });
@@ -62,14 +58,9 @@ class UtilsSQLite {
                 if (password.length > 0) {
                   await this.setCipherPragma(mDB, password);
                 }
-        */
+                */
                 // set Foreign Keys On
                 await this.setForeignKeyConstraintsEnabled(mDB, true);
-                // Check Version
-                const curVersion = await this.getVersion(mDB);
-                if (curVersion === 0) {
-                    await this.setVersion(mDB, 1);
-                }
             }
             catch (err) {
                 return Promise.reject(msg + `${err}`);
@@ -345,9 +336,7 @@ class UtilsSQLite {
                     if (trimStmt === 'DELETE FROM' &&
                         stmt.toLowerCase().includes('WHERE'.toLowerCase())) {
                         const whereStmt = `${stmt.trim()};`;
-                        console.log(`in utilsSQLite execute whereStmt ${whereStmt}`);
                         const rStmt = await this.deleteSQL(mDB, whereStmt, []);
-                        console.log(`in utilsSQLite execute rStmt ${rStmt}`);
                         resArr.push(rStmt);
                     }
                     else {
@@ -356,7 +345,6 @@ class UtilsSQLite {
                 }
                 sqlStmt = resArr.join(';');
             }
-            console.log(`in utilsSQLite execute sqlStmt ${sqlStmt}`);
             await this.execDB(mDB, sqlStmt);
             changes = (await this.dbChanges(mDB)) - initChanges;
             return Promise.resolve(changes);
@@ -448,7 +436,6 @@ class UtilsSQLite {
     async runExec(db, stmt, values = []) {
         return new Promise((resolve, reject) => {
             if (values != null && values.length > 0) {
-                console.log(`in runExec stmt: ${stmt} values: ${values}`);
                 db.run(stmt, values, (err) => {
                     if (err) {
                         console.log(`in runExec err1: ${JSON.stringify(err)}`);
@@ -512,7 +499,6 @@ class UtilsSQLite {
                     .substring('DELETE FROM'.length)
                     .trim();
                 sqlStmt = `UPDATE ${tableName} SET sql_deleted = 1 ${clauseStmt}`;
-                console.log(`in deleteSQL sqlStmt: ${sqlStmt}`);
                 // Find REFERENCES if any and update the sql_deleted column
                 await this.findReferencesAndUpdate(db, tableName, clauseStmt, values);
             }
@@ -537,31 +523,24 @@ class UtilsSQLite {
                 return;
             }
             const tableNameWithRefs = references.pop();
-            console.log(`references: ${references}`);
-            console.log(`tableNameWithRefs: ${tableNameWithRefs}`);
             for (const refe of references) {
                 // get the tableName of the reference
                 const refTable = await this.getReferenceTableName(refe);
                 if (refTable.length <= 0) {
                     continue;
                 }
-                console.log(`refTable: ${refTable}`);
                 // get the with references columnName
                 const withRefsNames = await this.getWithRefsColumnName(refe);
-                console.log(`withRefsNames: ${withRefsNames}`);
                 if (withRefsNames.length <= 0) {
                     continue;
                 }
                 // get the referenced columnName
                 const colNames = await this.getReferencedColumnName(refe);
-                console.log(`colNames: ${colNames}`);
                 if (colNames.length <= 0) {
                     continue;
                 }
                 // update the where clause
                 const uWhereStmt = await this.updateWhere(whereStmt, withRefsNames, colNames);
-                console.log(`whereStmt: ${whereStmt}`);
-                console.log(`uWhereStmt: ${uWhereStmt}`);
                 if (uWhereStmt.length <= 0) {
                     continue;
                 }
@@ -571,31 +550,22 @@ class UtilsSQLite {
                     updTableName = refTable;
                     updColNames = withRefsNames;
                 }
-                console.log(`updTableName: ${updTableName}`);
-                console.log(`updColNames: ${updColNames}`);
                 //update sql_deleted for this reference
                 const stmt = 'UPDATE ' + updTableName + ' SET sql_deleted = 1 ' + uWhereStmt;
-                console.log(`stmt: ${stmt}`);
-                console.log(`values: ${values}`);
                 if (values != null && values.length > 0) {
                     const mVal = await this.replaceUndefinedByNull(values);
                     let arrVal = whereStmt.split('?');
                     if (arrVal[arrVal.length - 1] === ';')
                         arrVal = arrVal.slice(0, -1);
-                    console.log(`arrVal: ${arrVal}`);
                     const selValues = [];
                     for (const [j, val] of arrVal.entries()) {
-                        console.log(`j: ${j} val: ${val}`);
                         for (const updVal of updColNames) {
                             const idxVal = val.indexOf(updVal);
-                            console.log(`updVal: ${updVal} idxVal ${idxVal}`);
                             if (idxVal > -1) {
                                 selValues.push(mVal[j]);
                             }
                         }
                     }
-                    console.log(`*** stmt: ${selValues}`);
-                    console.log(`*** selValues: ${selValues}`);
                     await db.run(stmt, selValues);
                 }
                 else {
@@ -1717,11 +1687,11 @@ utilsJson.UtilsJson = UtilsJson;
 Object.defineProperty(exportToJson, "__esModule", { value: true });
 exportToJson.ExportToJson = void 0;
 const utilsSQLite_1$4 = utilsSQLite;
-const utilsJson_1$4 = utilsJson;
+const utilsJson_1$3 = utilsJson;
 class ExportToJson {
     constructor() {
         this.sqliteUtil = new utilsSQLite_1$4.UtilsSQLite();
-        this.jsonUtil = new utilsJson_1$4.UtilsJson();
+        this.jsonUtil = new utilsJson_1$3.UtilsJson();
     }
     /**
      * CreateExportObject
@@ -2539,14 +2509,14 @@ utilsDrop.UtilsDrop = UtilsDrop;
 
 Object.defineProperty(importFromJson, "__esModule", { value: true });
 importFromJson.ImportFromJson = void 0;
-const utilsDrop_1$1 = utilsDrop;
+const utilsDrop_1 = utilsDrop;
 const utilsSQLite_1$2 = utilsSQLite;
-const utilsJson_1$3 = utilsJson;
+const utilsJson_1$2 = utilsJson;
 class ImportFromJson {
     constructor() {
-        this.jsonUtil = new utilsJson_1$3.UtilsJson();
+        this.jsonUtil = new utilsJson_1$2.UtilsJson();
         this.sqliteUtil = new utilsSQLite_1$2.UtilsSQLite();
-        this.dropUtil = new utilsDrop_1$1.UtilsDrop();
+        this.dropUtil = new utilsDrop_1.UtilsDrop();
     }
     /**
      * CreateDatabaseSchema
@@ -2808,10 +2778,13 @@ class UtilsFile {
      */
     getAssetsDatabasesPath() {
         let retPath = '';
-        const rawdata = this.NodeFs.readFileSync(this.Path.resolve(this.appPath, 'capacitor.config.json'));
-        const webDir = JSON.parse(rawdata).webDir;
+        const webDir = this.capConfig.webDir;
         const dir = webDir === 'www' ? 'src' : 'public';
-        retPath = this.Path.resolve(this.appPath, dir, 'assets', this.pathDB.toLowerCase());
+        let mAppPath = this.appPath;
+        if (this.Path.basename(this.appPath) === "electron") {
+            mAppPath = this.Path.dirname(this.appPath);
+        }
+        retPath = this.Path.resolve(mAppPath, dir, 'assets', 'databases');
         return retPath;
     }
     /**
@@ -3120,18 +3093,10 @@ var utilsUpgrade = {};
 
 Object.defineProperty(utilsUpgrade, "__esModule", { value: true });
 utilsUpgrade.UtilsUpgrade = void 0;
-const utilsJson_1$2 = utilsJson;
-const utilsDrop_1 = utilsDrop;
-const utilsFile_1$2 = utilsFile;
 const utilsSQLite_1$1 = utilsSQLite;
 class UtilsUpgrade {
     constructor() {
         this.sqliteUtil = new utilsSQLite_1$1.UtilsSQLite();
-        this.fileUtil = new utilsFile_1$2.UtilsFile();
-        this.dropUtil = new utilsDrop_1.UtilsDrop();
-        this.jsonUtil = new utilsJson_1$2.UtilsJson();
-        this._alterTables = {};
-        this._commonColumns = {};
     }
     /**
      * OnUpgrade
@@ -3141,300 +3106,50 @@ class UtilsUpgrade {
      * @param curVersion
      * @param targetVersion
      */
-    async onUpgrade(mDB, vUpgDict, dbName, curVersion, targetVersion) {
-        const upgrade = vUpgDict[curVersion];
-        if (upgrade != null) {
-            const keys = Object.keys(upgrade);
-            if (!keys.includes('toVersion')) {
-                return Promise.reject('onUpgrade: toVersion not given');
-            }
-            const toVersion = upgrade.toVersion;
-            if (!keys.includes('statement')) {
-                return Promise.reject('onUpgrade: statement not given');
-            }
-            const statement = upgrade.statement;
-            let set = [];
-            if (keys.includes('set')) {
-                set = upgrade.set;
-            }
-            if (targetVersion < toVersion) {
-                let msg = 'Error: version mistmatch ';
-                msg += 'Upgrade Statement would upgrade to ';
-                msg += `version ${toVersion} , but target version `;
-                msg += `is ${targetVersion} for database ${dbName}`;
-                msg += ` and version ${curVersion}`;
-                return Promise.reject(`onUpgrade: ${msg}`);
-            }
-            try {
-                // set Foreign Keys Off
-                await this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB, false);
-                await this.fileUtil.copyFileName(dbName, `backup-${dbName}`);
-                const initChanges = await this.sqliteUtil.dbChanges(mDB);
-                // Here we assume that all table schemas are given
-                // in the upgrade statement
-                if (statement.length > 0) {
-                    await this.executeStatementProcess(mDB, statement);
-                    // Here we assume that the Set contains only
-                    // - the data for new tables
-                    //   as INSERT statements
-                    // - the data for new columns in existing tables
-                    //   as UPDATE statements
-                    if (set.length > 0) {
-                        await this.executeSetProcess(mDB, set, toVersion);
-                    }
-                }
-                // set Foreign Keys On
-                await this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB, true);
-                const changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
-                return Promise.resolve(changes);
-            }
-            catch (err) {
-                return Promise.reject(`onUpgrade: ${err}`);
-            }
-        }
-        else {
-            return Promise.reject('onUpgrade: upgrade not found');
-        }
-    }
-    /**
-     * ExecuteStatementProcess
-     * @param mDB
-     * @param statement
-     */
-    async executeStatementProcess(mDB, statement) {
-        try {
-            // -> backup all existing tables  "tableName" in
-            //    "temp_tableName"
-            await this.backupTables(mDB);
-            // -> Drop all Indexes
-            await this.dropUtil.dropElements(mDB, 'index');
-            // -> Drop all Triggers
-            await this.dropUtil.dropElements(mDB, 'trigger');
-            // -> Create new tables from upgrade.statement
-            const changes = await this.sqliteUtil.execute(mDB, statement, false);
-            if (changes < 0) {
-                return Promise.reject('ExecuteStatementProcess: ' + 'changes < 0');
-            }
-            // -> Create the list of table's common fields
-            await this.findCommonColumns(mDB);
-            // -> Update the new table's data from old table's data
-            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.dropUtil.dropTempTables(mDB, this._alterTables);
-            // -> Do some cleanup
-            this._alterTables = {};
-            this._commonColumns = {};
-        }
-    }
-    /**
-     * ExecuteSetProcess
-     * @param mDB
-     * @param set
-     * @param toVersion
-     */
-    async executeSetProcess(mDB, set, toVersion) {
-        try {
-            // -> load new data
-            const lastId = await this.sqliteUtil.executeSet(mDB, set, false);
-            if (lastId < 0) {
-                return Promise.reject('ExecuteSetProcess: lastId ' + '< 0');
-            }
-            // -> update database version
-            await this.sqliteUtil.setVersion(mDB, toVersion);
-            // -> update syncDate if any
-            const retB = await this.jsonUtil.isTableExists(mDB, true, 'sync_table');
-            if (retB) {
-                const sDate = Math.round(new Date().getTime() / 1000);
-                let stmt = 'UPDATE sync_table SET ';
-                stmt += `sync_date = ${sDate} WHERE id = 1;`;
-                const changes = await this.sqliteUtil.execute(mDB, stmt, false);
-                if (changes < 0) {
-                    return Promise.reject('ExecuteSetProcess: changes ' + '< 0');
+    async onUpgrade(mDB, vUpgDict, curVersion, targetVersion) {
+        const sortedKeys = Object.keys(vUpgDict)
+            .map(item => parseInt(item))
+            .sort();
+        for (const versionKey of sortedKeys) {
+            if (versionKey > curVersion && versionKey <= targetVersion) {
+                const statements = vUpgDict[versionKey].statements;
+                if (statements.length === 0) {
+                    return Promise.reject('onUpgrade: statements not given');
                 }
-            }
-            return Promise.resolve();
-        }
-        catch (err) {
-            return Promise.reject(`ExecuteSetProcess: ${err}`);
-        }
-    }
-    /**
-     * BackupTables
-     * @param mDB
-     */
-    async backupTables(mDB) {
-        const msg = 'BackupTables: ';
-        try {
-            const tables = await this.sqliteUtil.getTablesNames(mDB);
-            for (const table of tables) {
                 try {
-                    await this.backupTable(mDB, table);
+                    // set Foreign Keys Off
+                    await this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB, false);
+                    const initChanges = await this.sqliteUtil.dbChanges(mDB);
+                    await this.executeStatementsProcess(mDB, statements);
+                    await this.sqliteUtil.setVersion(mDB, versionKey);
+                    // set Foreign Keys On
+                    await this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB, true);
+                    const changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
+                    return Promise.resolve(changes);
                 }
                 catch (err) {
-                    return Promise.reject(`${msg}table ${table}: ` + `${err}`);
+                    return Promise.reject(`onUpgrade: ${err}`);
                 }
             }
-            return Promise.resolve();
-        }
-        catch (err) {
-            return Promise.reject(`BackupTables: ${err}`);
         }
     }
     /**
-     * BackupTable
+     * ExecuteStatementProcess
      * @param mDB
-     * @param table
+     * @param statements
      */
-    async backupTable(mDB, table) {
+    async executeStatementsProcess(mDB, statements) {
         try {
-            // start a transaction
             await this.sqliteUtil.beginTransaction(mDB, true);
-            // get the table's column names
-            const colNames = await this.getTableColumnNames(mDB, table);
-            this._alterTables[`${table}`] = colNames;
-            const tmpTable = `_temp_${table}`;
-            // Drop the tmpTable if exists
-            const delStmt = `DROP TABLE IF EXISTS ${tmpTable};`;
-            await this.sqliteUtil.prepareRun(mDB, delStmt, [], false);
-            // prefix the table with _temp_
-            let stmt = `ALTER TABLE ${table} RENAME `;
-            stmt += `TO ${tmpTable};`;
-            const lastId = await this.sqliteUtil.prepareRun(mDB, stmt, [], false);
-            if (lastId < 0) {
-                let msg = 'BackupTable: lastId < 0';
-                try {
-                    await this.sqliteUtil.rollbackTransaction(mDB, true);
-                }
-                catch (err) {
-                    msg += `: ${err}`;
-                }
-                return Promise.reject(`${msg}`);
-            }
-            else {
-                try {
-                    await this.sqliteUtil.commitTransaction(mDB, true);
-                }
-                catch (err) {
-                    return Promise.reject('BackupTable: ' + `${err}`);
-                }
-            }
-            return Promise.resolve();
-        }
-        catch (err) {
-            return Promise.reject(`BackupTable: ${err}`);
-        }
-    }
-    /**
-     * GetTableColumnNames
-     * @param mDB
-     * @param tableName
-     */
-    async getTableColumnNames(mDB, tableName) {
-        let resQuery = [];
-        const retNames = [];
-        const query = `PRAGMA table_info('${tableName}');`;
-        try {
-            resQuery = await this.sqliteUtil.queryAll(mDB, query, []);
-            if (resQuery.length > 0) {
-                for (const query of resQuery) {
-                    retNames.push(query.name);
-                }
-            }
-            return Promise.resolve(retNames);
-        }
-        catch (err) {
-            return Promise.reject('GetTableColumnNames: ' + `${err}`);
-        }
-    }
-    /**
-     * FindCommonColumns
-     * @param mDB
-     */
-    async findCommonColumns(mDB) {
-        try {
-            // Get new table list
-            const tables = await this.sqliteUtil.getTablesNames(mDB);
-            if (tables.length === 0) {
-                return Promise.reject('FindCommonColumns: get ' + "table's names failed");
-            }
-            for (const table of tables) {
-                // get the column's name
-                const tableNames = await this.getTableColumnNames(mDB, table);
-                // find the common columns
-                const keys = Object.keys(this._alterTables);
-                if (keys.includes(table)) {
-                    this._commonColumns[table] = this.arraysIntersection(this._alterTables[table], tableNames);
-                }
+            for (const statement of statements) {
+                await this.sqliteUtil.execute(mDB, statement, false);
             }
+            await this.sqliteUtil.commitTransaction(mDB, true);
             return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(`FindCommonColumns: ${err}`);
-        }
-    }
-    /**
-     * ArraysIntersection
-     * @param a1
-     * @param a2
-     */
-    arraysIntersection(a1, a2) {
-        if (a1 != null && a2 != null) {
-            const first = new Set(a1);
-            const second = new Set(a2);
-            return [...first].filter(item => second.has(item));
-        }
-        else {
-            return [];
-        }
-    }
-    /**
-     * UpdateNewTablesData
-     * @param mDB
-     */
-    async updateNewTablesData(mDB) {
-        try {
-            // start a transaction
-            await this.sqliteUtil.beginTransaction(mDB, true);
-            const statements = [];
-            const keys = Object.keys(this._commonColumns);
-            keys.forEach(key => {
-                const columns = this._commonColumns[key].join(',');
-                let stmt = `INSERT INTO ${key} `;
-                stmt += `(${columns}) `;
-                stmt += `SELECT ${columns} FROM _temp_${key};`;
-                statements.push(stmt);
-            });
-            const changes = await this.sqliteUtil.execute(mDB, statements.join('\n'), false);
-            if (changes < 0) {
-                let msg = 'updateNewTablesData: ' + 'changes < 0';
-                try {
-                    await this.sqliteUtil.rollbackTransaction(mDB, true);
-                }
-                catch (err) {
-                    msg += `: ${err}`;
-                }
-                return Promise.reject(`${msg}`);
-            }
-            else {
-                try {
-                    await this.sqliteUtil.commitTransaction(mDB, true);
-                    return Promise.resolve();
-                }
-                catch (err) {
-                    return Promise.reject('updateNewTablesData: ' + `${err}`);
-                }
-            }
-        }
-        catch (err) {
-            return Promise.reject('updateNewTablesData: ' + `${err}`);
+            await this.sqliteUtil.rollbackTransaction(mDB, true);
+            return Promise.reject(`ExecuteStatementProcess: ${err}`);
         }
     }
 }
@@ -3518,8 +3233,9 @@ class Database {
             if (this.version > curVersion &&
                 Object.keys(this.upgradeVersionDict).length > 0) {
                 try {
+                    await this.fileUtil.copyFileName(this.dbName, `backup-${this.dbName}`);
                     // execute the upgrade flow process
-                    await this.upgradeUtil.onUpgrade(this.database, this.upgradeVersionDict, this.dbName, curVersion, this.version);
+                    await this.upgradeUtil.onUpgrade(this.database, this.upgradeVersionDict, curVersion, this.version);
                     // delete the backup database
                     await this.fileUtil.deleteFileName(`backup-${this.dbName}`);
                 }
@@ -4301,16 +4017,15 @@ class CapacitorSQLite {
         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')) {
+        if (!versionUpgradeKeys.includes('toVersion') ||
+            !versionUpgradeKeys.includes('statements')) {
             throw new Error('Must provide an upgrade capSQLiteVersionUpgrade Object');
         }
-        if (typeof firstUpgrade.fromVersion != 'number') {
-            throw new Error('upgrade.fromVersion must be a number');
+        if (typeof firstUpgrade.toVersion != 'number') {
+            throw new Error('upgrade.toVersion must be a number');
         }
         const upgradeVersionDict = {};
-        upgradeVersionDict[firstUpgrade.fromVersion] = firstUpgrade;
+        upgradeVersionDict[firstUpgrade.toVersion] = firstUpgrade;
         this.versionUpgrades[dbName] = upgradeVersionDict;
         return;
     }