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

package/electron/dist/plugin.js

@@ -58,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}`);
@@ -1692,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
@@ -2514,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
@@ -3098,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
@@ -3119,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}`);
         }
     }
 }
@@ -3496,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}`);
                 }
@@ -4279,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;
     }