@capacitor-community/sqlite 3.4.1-1 → 3.4.1-4

package/electron/dist/plugin.js

@@ -7,6 +7,7 @@ var require$$0$1 = require('path');
 var require$$1 = require('fs');
 var require$$2 = require('os');
 var require$$3 = require('jszip');
+var require$$4 = require('electron');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -15,6 +16,7 @@ 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 require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
 
 var src = {};
 
@@ -435,12 +437,187 @@ utilsSQLite.UtilsSQLite = UtilsSQLite;
 
 var utilsJson = {};
 
+var utilsDrop = {};
+
+Object.defineProperty(utilsDrop, "__esModule", { value: true });
+utilsDrop.UtilsDrop = void 0;
+const utilsSQLite_1$5 = utilsSQLite;
+class UtilsDrop {
+    constructor() {
+        this._uSQLite = new utilsSQLite_1$5.UtilsSQLite();
+    }
+    /**
+     * GetTablesNames
+     * @param mDb
+     */
+    async getTablesNames(mDb) {
+        let sql = 'SELECT name FROM sqlite_master WHERE ';
+        sql += "type='table' AND name NOT LIKE 'sync_table' ";
+        sql += "AND name NOT LIKE '_temp_%' ";
+        sql += "AND name NOT LIKE 'sqlite_%' ";
+        sql += 'ORDER BY rootpage DESC;';
+        const retArr = [];
+        try {
+            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            for (const query of retQuery) {
+                retArr.push(query.name);
+            }
+            return Promise.resolve(retArr);
+        }
+        catch (err) {
+            return Promise.reject(`getTablesNames: ${err}`);
+        }
+    }
+    /**
+     * GetViewsNames
+     * @param mDb
+     */
+    async getViewsNames(mDb) {
+        let sql = 'SELECT name FROM sqlite_master WHERE ';
+        sql += "type='view' AND name NOT LIKE 'sqlite_%' ";
+        sql += 'ORDER BY rootpage DESC;';
+        const retArr = [];
+        try {
+            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            for (const query of retQuery) {
+                retArr.push(query.name);
+            }
+            return Promise.resolve(retArr);
+        }
+        catch (err) {
+            return Promise.reject(`getViewsNames: ${err}`);
+        }
+    }
+    /**
+     * DropElements
+     * @param db
+     * @param type ["table","index","trigger"]
+     */
+    async dropElements(db, type) {
+        let msg = '';
+        switch (type) {
+            case 'index':
+                msg = 'DropIndexes';
+                break;
+            case 'trigger':
+                msg = 'DropTriggers';
+                break;
+            case 'table':
+                msg = 'DropTables';
+                break;
+            case 'view':
+                msg = 'DropViews';
+                break;
+            default:
+                return Promise.reject(`DropElements: ${type} ` + 'not found');
+        }
+        // get the element's names
+        let stmt = 'SELECT name FROM sqlite_master WHERE ';
+        stmt += `type = '${type}' AND name NOT LIKE 'sqlite_%';`;
+        try {
+            const elements = await this._uSQLite.queryAll(db, stmt, []);
+            if (elements.length > 0) {
+                const upType = type.toUpperCase();
+                const statements = [];
+                for (const elem of elements) {
+                    let stmt = `DROP ${upType} IF EXISTS `;
+                    stmt += `${elem.name};`;
+                    statements.push(stmt);
+                }
+                for (const stmt of statements) {
+                    const lastId = await this._uSQLite.prepareRun(db, stmt, []);
+                    if (lastId < 0) {
+                        return Promise.reject(`${msg}: lastId < 0`);
+                    }
+                }
+            }
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(`${msg}: ${err}`);
+        }
+    }
+    /**
+     * DropAll
+     * Drop all database's elements
+     * @param db
+     */
+    async dropAll(db) {
+        try {
+            // drop tables
+            await this.dropElements(db, 'table');
+            // drop indexes
+            await this.dropElements(db, 'index');
+            // drop triggers
+            await this.dropElements(db, 'trigger');
+            // drop views
+            await this.dropElements(db, 'view');
+            // vacuum the database
+            await this._uSQLite.prepareRun(db, 'VACUUM;', []);
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(`DropAll: ${err}`);
+        }
+    }
+    /**
+     * DropTempTables
+     * @param db
+     * @param alterTables
+     */
+    async dropTempTables(db, alterTables) {
+        const tempTables = Object.keys(alterTables);
+        const statements = [];
+        for (const tTable of tempTables) {
+            let stmt = 'DROP TABLE IF EXISTS ';
+            stmt += `_temp_${tTable};`;
+            statements.push(stmt);
+        }
+        try {
+            const changes = await this._uSQLite.execute(db, statements.join('\n'));
+            if (changes < 0) {
+                return Promise.reject('DropTempTables: changes < 0');
+            }
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(`DropTempTables: ${err}`);
+        }
+    }
+}
+utilsDrop.UtilsDrop = UtilsDrop;
+
 Object.defineProperty(utilsJson, "__esModule", { value: true });
 utilsJson.UtilsJson = void 0;
-const utilsSQLite_1$5 = utilsSQLite;
+const utilsDrop_1$2 = utilsDrop;
+const utilsSQLite_1$4 = utilsSQLite;
 class UtilsJson {
     constructor() {
-        this._uSQLite = new utilsSQLite_1$5.UtilsSQLite();
+        this._uSQLite = new utilsSQLite_1$4.UtilsSQLite();
+        this._uDrop = new utilsDrop_1$2.UtilsDrop();
+    }
+    /**
+     * isLastModified
+     * @param db
+     * @param isOpen
+     */
+    async isLastModified(db, isOpen) {
+        if (!isOpen) {
+            return Promise.reject('isLastModified: database not opened');
+        }
+        try {
+            const tableList = await this._uDrop.getTablesNames(db);
+            for (const table of tableList) {
+                const tableNamesTypes = await this.getTableColumnNamesTypes(db, table);
+                const tableColumnNames = tableNamesTypes.names;
+                if (tableColumnNames.includes('last_modified')) {
+                    return Promise.resolve(true);
+                }
+            }
+        }
+        catch (err) {
+            return Promise.reject(`isLastModified: ${err}`);
+        }
     }
     /**
      * IsTableExists
@@ -554,6 +731,7 @@ class UtilsJson {
      */
     async createSchemaStatement(jsonData) {
         const statements = [];
+        let isLastModified = false;
         // Prepare the statement to execute
         try {
             for (const jTable of jsonData.tables) {
@@ -564,6 +742,9 @@ class UtilsJson {
                         if (j === jTable.schema.length - 1) {
                             if (jTable.schema[j].column) {
                                 statements.push(`${jTable.schema[j].column} ${jTable.schema[j].value}`);
+                                if (jTable.schema[j].column === 'last_modified') {
+                                    isLastModified = true;
+                                }
                             }
                             else if (jTable.schema[j].foreignkey) {
                                 statements.push(`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value}`);
@@ -575,6 +756,9 @@ class UtilsJson {
                         else {
                             if (jTable.schema[j].column) {
                                 statements.push(`${jTable.schema[j].column} ${jTable.schema[j].value},`);
+                                if (jTable.schema[j].column === 'last_modified') {
+                                    isLastModified = true;
+                                }
                             }
                             else if (jTable.schema[j].foreignkey) {
                                 statements.push(`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value},`);
@@ -585,17 +769,19 @@ class UtilsJson {
                         }
                     }
                     statements.push(');');
-                    // create trigger last_modified associated with the table
-                    let trig = 'CREATE TRIGGER IF NOT EXISTS ';
-                    trig += `${jTable.name}`;
-                    trig += `_trigger_last_modified `;
-                    trig += `AFTER UPDATE ON ${jTable.name} `;
-                    trig += 'FOR EACH ROW WHEN NEW.last_modified <= ';
-                    trig += 'OLD.last_modified BEGIN UPDATE ';
-                    trig += `${jTable.name} `;
-                    trig += `SET last_modified = `;
-                    trig += "(strftime('%s','now')) WHERE id=OLD.id; END;";
-                    statements.push(trig);
+                    if (isLastModified) {
+                        // create trigger last_modified associated with the table
+                        let trig = 'CREATE TRIGGER IF NOT EXISTS ';
+                        trig += `${jTable.name}`;
+                        trig += `_trigger_last_modified `;
+                        trig += `AFTER UPDATE ON ${jTable.name} `;
+                        trig += 'FOR EACH ROW WHEN NEW.last_modified <= ';
+                        trig += 'OLD.last_modified BEGIN UPDATE ';
+                        trig += `${jTable.name} `;
+                        trig += `SET last_modified = `;
+                        trig += "(strftime('%s','now')) WHERE id=OLD.id; END;";
+                        statements.push(trig);
+                    }
                 }
                 if (jTable.indexes != null && jTable.indexes.length >= 1) {
                     for (const jIndex of jTable.indexes) {
@@ -1165,11 +1351,11 @@ utilsJson.UtilsJson = UtilsJson;
 
 Object.defineProperty(exportToJson, "__esModule", { value: true });
 exportToJson.ExportToJson = void 0;
-const utilsSQLite_1$4 = utilsSQLite;
+const utilsSQLite_1$3 = utilsSQLite;
 const utilsJson_1$4 = utilsJson;
 class ExportToJson {
     constructor() {
-        this._uSQLite = new utilsSQLite_1$4.UtilsSQLite();
+        this._uSQLite = new utilsSQLite_1$3.UtilsSQLite();
         this._uJson = new utilsJson_1$4.UtilsJson();
     }
     /**
@@ -1191,6 +1377,10 @@ class ExportToJson {
                 return Promise.reject("createExportObject: table's names failed");
             }
             else {
+                const isTable = await this._uJson.isTableExists(mDB, true, 'sync_table');
+                if (!isTable && sqlObj.mode === 'partial') {
+                    return Promise.reject('No sync_table available');
+                }
                 switch (sqlObj.mode) {
                     case 'partial': {
                         tables = await this.getTablesPartial(mDB, resTables);
@@ -1807,156 +1997,6 @@ exportToJson.ExportToJson = ExportToJson;
 
 var importFromJson = {};
 
-var utilsDrop = {};
-
-Object.defineProperty(utilsDrop, "__esModule", { value: true });
-utilsDrop.UtilsDrop = void 0;
-const utilsSQLite_1$3 = utilsSQLite;
-class UtilsDrop {
-    constructor() {
-        this._uSQLite = new utilsSQLite_1$3.UtilsSQLite();
-    }
-    /**
-     * GetTablesNames
-     * @param mDb
-     */
-    async getTablesNames(mDb) {
-        let sql = 'SELECT name FROM sqlite_master WHERE ';
-        sql += "type='table' AND name NOT LIKE 'sync_table' ";
-        sql += "AND name NOT LIKE '_temp_%' ";
-        sql += "AND name NOT LIKE 'sqlite_%' ";
-        sql += 'ORDER BY rootpage DESC;';
-        const retArr = [];
-        try {
-            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
-            for (const query of retQuery) {
-                retArr.push(query.name);
-            }
-            return Promise.resolve(retArr);
-        }
-        catch (err) {
-            return Promise.reject(`getTablesNames: ${err}`);
-        }
-    }
-    /**
-     * GetViewsNames
-     * @param mDb
-     */
-    async getViewsNames(mDb) {
-        let sql = 'SELECT name FROM sqlite_master WHERE ';
-        sql += "type='view' AND name NOT LIKE 'sqlite_%' ";
-        sql += 'ORDER BY rootpage DESC;';
-        const retArr = [];
-        try {
-            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
-            for (const query of retQuery) {
-                retArr.push(query.name);
-            }
-            return Promise.resolve(retArr);
-        }
-        catch (err) {
-            return Promise.reject(`getViewsNames: ${err}`);
-        }
-    }
-    /**
-     * DropElements
-     * @param db
-     * @param type ["table","index","trigger"]
-     */
-    async dropElements(db, type) {
-        let msg = '';
-        switch (type) {
-            case 'index':
-                msg = 'DropIndexes';
-                break;
-            case 'trigger':
-                msg = 'DropTriggers';
-                break;
-            case 'table':
-                msg = 'DropTables';
-                break;
-            case 'view':
-                msg = 'DropViews';
-                break;
-            default:
-                return Promise.reject(`DropElements: ${type} ` + 'not found');
-        }
-        // get the element's names
-        let stmt = 'SELECT name FROM sqlite_master WHERE ';
-        stmt += `type = '${type}' AND name NOT LIKE 'sqlite_%';`;
-        try {
-            const elements = await this._uSQLite.queryAll(db, stmt, []);
-            if (elements.length > 0) {
-                const upType = type.toUpperCase();
-                const statements = [];
-                for (const elem of elements) {
-                    let stmt = `DROP ${upType} IF EXISTS `;
-                    stmt += `${elem.name};`;
-                    statements.push(stmt);
-                }
-                for (const stmt of statements) {
-                    const lastId = await this._uSQLite.prepareRun(db, stmt, []);
-                    if (lastId < 0) {
-                        return Promise.reject(`${msg}: lastId < 0`);
-                    }
-                }
-            }
-            return Promise.resolve();
-        }
-        catch (err) {
-            return Promise.reject(`${msg}: ${err}`);
-        }
-    }
-    /**
-     * DropAll
-     * Drop all database's elements
-     * @param db
-     */
-    async dropAll(db) {
-        try {
-            // drop tables
-            await this.dropElements(db, 'table');
-            // drop indexes
-            await this.dropElements(db, 'index');
-            // drop triggers
-            await this.dropElements(db, 'trigger');
-            // drop views
-            await this.dropElements(db, 'view');
-            // vacuum the database
-            await this._uSQLite.prepareRun(db, 'VACUUM;', []);
-            return Promise.resolve();
-        }
-        catch (err) {
-            return Promise.reject(`DropAll: ${err}`);
-        }
-    }
-    /**
-     * DropTempTables
-     * @param db
-     * @param alterTables
-     */
-    async dropTempTables(db, alterTables) {
-        const tempTables = Object.keys(alterTables);
-        const statements = [];
-        for (const tTable of tempTables) {
-            let stmt = 'DROP TABLE IF EXISTS ';
-            stmt += `_temp_${tTable};`;
-            statements.push(stmt);
-        }
-        try {
-            const changes = await this._uSQLite.execute(db, statements.join('\n'));
-            if (changes < 0) {
-                return Promise.reject('DropTempTables: changes < 0');
-            }
-            return Promise.resolve();
-        }
-        catch (err) {
-            return Promise.reject(`DropTempTables: ${err}`);
-        }
-    }
-}
-utilsDrop.UtilsDrop = UtilsDrop;
-
 Object.defineProperty(importFromJson, "__esModule", { value: true });
 importFromJson.ImportFromJson = void 0;
 const utilsDrop_1$1 = utilsDrop;
@@ -2121,6 +2161,7 @@ class UtilsFile {
         this.NodeFs = null;
         this.JSZip = null;
         this.Os = null;
+        this.Electron = null;
         this.AppName = '';
         this.HomeDir = '';
         this.sep = '/';
@@ -2128,15 +2169,38 @@ class UtilsFile {
         this.NodeFs = require$$1__default['default'];
         this.Os = require$$2__default['default'];
         this.JSZip = require$$3__default['default'];
+        this.Electron = require$$4__default['default'];
         this.HomeDir = this.Os.homedir();
         const dir = __dirname;
         const idx = dir.indexOf('\\');
         if (idx != -1)
             this.sep = '\\';
-        this.appPath = dir.substring(0, dir.indexOf(`electron${this.sep}`) /* + 8*/);
+        this.appPath = this.Electron.app.getAppPath();
         const rawdata = this.NodeFs.readFileSync(this.Path.resolve(this.appPath, 'package.json'));
         this.AppName = JSON.parse(rawdata).name;
+        const pathToBuild = this.Path.join(this.appPath, 'build');
+        if (this.NodeFs.existsSync(this.Path.join(pathToBuild, 'capacitor.config.js'))) {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            this.capConfig = require(this.Path.join(pathToBuild, 'capacitor.config.js')).default;
+        }
+        else {
+            this.capConfig = JSON.parse(this.NodeFs.readFileSync(this.Path.join(this.appPath, 'capacitor.config.json')).toString());
+        }
         this.osType = this.Os.type();
+        switch (this.osType) {
+            case 'Darwin':
+                this.pathDB = this.capConfig.plugins.CapacitorSQLite.electronMacLocation;
+                break;
+            case 'Linux':
+                this.pathDB = this.capConfig.plugins.CapacitorSQLite.electronLinuxLocation;
+                break;
+            case 'Windows_NT':
+                this.pathDB = this.capConfig.plugins.CapacitorSQLite.electronWindowsLocation;
+                break;
+            default:
+                console.log('other operating system');
+        }
+        console.log(`&&& Databases path: ${this.pathDB}`);
     }
     /**
      * IsPathExists
@@ -2175,37 +2239,26 @@ class UtilsFile {
     getFilePath(fileName) {
         return this.Path.join(this.getDatabasesPath(), fileName);
     }
-    /**
-     * GetCustomerPath
-     * get the customer path
-     */
-    getCustomerPath(custPath) {
-        return this.Path.join(this.HomeDir, custPath);
-    }
-    /**
-     * GetCustomerFilePath
-     * get the customer file path
-     */
-    getCustomerFilePath(custPath, file) {
-        return this.Path.join(custPath, file);
-    }
     /**
      * GetDatabasesPath
      * get the database folder path
      */
     getDatabasesPath() {
         let retPath = '';
+        const sep = this.Path.sep;
         const dbFolder = this.pathDB;
-        retPath = this.Path.join(this.HomeDir, dbFolder, this.AppName);
-        let retB = this._createFolderIfNotExists(this.Path.join(this.HomeDir, dbFolder));
-        if (retB) {
-            retB = this._createFolderIfNotExists(this.Path.join(this.HomeDir, dbFolder, this.AppName));
-            if (!retB)
-                retPath = '';
+        if (dbFolder.includes(sep)) {
+            retPath = dbFolder;
+            if (this.Path.basename(dbFolder) !== this.AppName) {
+                retPath = this.Path.join(dbFolder, this.AppName);
+            }
         }
         else {
-            retPath = '';
+            retPath = this.Path.join(this.HomeDir, dbFolder, this.AppName);
         }
+        const retB = this._createFolderIfNotExists(retPath);
+        if (!retB)
+            retPath = '';
         return retPath;
     }
     /**
@@ -3069,17 +3122,23 @@ class Database {
         try {
             const retB = await this._uJson.isTableExists(this._mDB, isOpen, 'sync_table');
             if (!retB) {
-                const date = Math.round(new Date().getTime() / 1000);
-                let stmts = `
-                        CREATE TABLE IF NOT EXISTS sync_table (
-                            id INTEGER PRIMARY KEY NOT NULL,
-                            sync_date INTEGER
-                            );`;
-                stmts += `INSERT INTO sync_table (sync_date) VALUES (
-                            "${date}");`;
-                changes = await this._uSQLite.execute(this._mDB, stmts);
-                if (changes < 0) {
-                    return Promise.reject(`CreateSyncTable: failed changes < 0`);
+                const isLastModified = await this._uJson.isLastModified(this._mDB, isOpen);
+                if (isLastModified) {
+                    const date = Math.round(new Date().getTime() / 1000);
+                    let stmts = `
+                          CREATE TABLE IF NOT EXISTS sync_table (
+                              id INTEGER PRIMARY KEY NOT NULL,
+                              sync_date INTEGER
+                              );`;
+                    stmts += `INSERT INTO sync_table (sync_date) VALUES (
+                              "${date}");`;
+                    changes = await this._uSQLite.execute(this._mDB, stmts);
+                    if (changes < 0) {
+                        return Promise.reject(`CreateSyncTable: failed changes < 0`);
+                    }
+                }
+                else {
+                    return Promise.reject('No last_modified column in tables');
                 }
             }
             return Promise.resolve(changes);
@@ -3101,6 +3160,10 @@ class Database {
             return { result: false, message: msg };
         }
         try {
+            const isTable = await this._uJson.isTableExists(this._mDB, this._isDBOpen, 'sync_table');
+            if (!isTable) {
+                return Promise.reject('No sync_table available');
+            }
             const sDate = Math.round(new Date(syncDate).getTime() / 1000);
             let stmt = `UPDATE sync_table SET sync_date = `;
             stmt += `${sDate} WHERE id = 1;`;
@@ -3128,6 +3191,10 @@ class Database {
             return { syncDate: 0, message: msg };
         }
         try {
+            const isTable = await this._uJson.isTableExists(this._mDB, this._isDBOpen, 'sync_table');
+            if (!isTable) {
+                return Promise.reject('No sync_table available');
+            }
             const syncDate = await this._eTJson.getSyncDate(this._mDB);
             if (syncDate > 0) {
                 return { syncDate: syncDate };