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

package/electron/dist/plugin.js

@@ -28,6 +28,7 @@ var utilsSQLite = {};
 
 Object.defineProperty(utilsSQLite, "__esModule", { value: true });
 utilsSQLite.UtilsSQLite = void 0;
+const SQLITE_OPEN_READONLY = 1;
 class UtilsSQLite {
     constructor() {
         // eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -40,12 +41,20 @@ class UtilsSQLite {
      * @param password
      */
     async openOrCreateDatabase(pathDB /*,
-    password: string,*/) {
+    password: string,*/, readonly) {
         const msg = 'OpenOrCreateDatabase: ';
         // open sqlite3 database
-        const mDB = new this.SQLite3.Database(pathDB, {
-            verbose: console.log,
-        });
+        let mDB;
+        if (!readonly) {
+            mDB = new this.SQLite3.Database(pathDB, {
+                verbose: console.log,
+            });
+        }
+        else {
+            mDB = new this.SQLite3.Database(pathDB, SQLITE_OPEN_READONLY, {
+                verbose: console.log,
+            });
+        }
         if (mDB != null) {
             try {
                 await this.dbChanges(mDB);
@@ -2781,7 +2790,7 @@ class UtilsFile {
         const webDir = this.capConfig.webDir;
         const dir = webDir === 'www' ? 'src' : 'public';
         let mAppPath = this.appPath;
-        if (this.Path.basename(this.appPath) === "electron") {
+        if (this.Path.basename(this.appPath) === 'electron') {
             mAppPath = this.Path.dirname(this.appPath);
         }
         retPath = this.Path.resolve(mAppPath, dir, 'assets', 'databases');
@@ -3168,7 +3177,7 @@ class Database {
     constructor(dbName, 
     //    encrypted: boolean,
     //    mode: string,
-    version, upgDict) {
+    version, readonly, upgDict) {
         this.fileUtil = new utilsFile_1$1.UtilsFile();
         this.sqliteUtil = new utilsSQLite_1.UtilsSQLite();
         this.jsonUtil = new utilsJson_1$1.UtilsJson();
@@ -3182,6 +3191,7 @@ class Database {
         //    this._encrypted = encrypted;
         //    this._mode = mode;
         this.version = version;
+        this.readonly = readonly;
         this.upgradeVersionDict = upgDict;
         this.pathDB = this.fileUtil.getFilePath(dbName);
         this._isDbOpen = false;
@@ -3227,25 +3237,27 @@ class Database {
             }
       */
             this.database = await this.sqliteUtil.openOrCreateDatabase(this.pathDB /*,
-            password,*/);
-            const curVersion = await this.sqliteUtil.getVersion(this.database);
+            password,*/, this.readonly);
             this._isDbOpen = true;
-            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, curVersion, this.version);
-                    // delete the backup database
-                    await this.fileUtil.deleteFileName(`backup-${this.dbName}`);
-                }
-                catch (err) {
-                    // restore the database from backup
+            if (!this.readonly) {
+                const curVersion = await this.sqliteUtil.getVersion(this.database);
+                if (this.version > curVersion &&
+                    Object.keys(this.upgradeVersionDict).length > 0) {
                     try {
-                        await this.fileUtil.restoreFileName(this.dbName, 'backup');
+                        await this.fileUtil.copyFileName(this.dbName, `backup-${this.dbName}`);
+                        // execute the upgrade flow process
+                        await this.upgradeUtil.onUpgrade(this.database, this.upgradeVersionDict, curVersion, this.version);
+                        // delete the backup database
+                        await this.fileUtil.deleteFileName(`backup-${this.dbName}`);
                     }
                     catch (err) {
-                        throw new Error(`Open: ${err}`);
+                        // restore the database from backup
+                        try {
+                            await this.fileUtil.restoreFileName(this.dbName, 'backup');
+                        }
+                        catch (err) {
+                            throw new Error(`Open: ${err}`);
+                        }
                     }
                 }
             }
@@ -3693,23 +3705,27 @@ class CapacitorSQLite {
             ? options.mode
             : 'no-encryption';
         */
+        const readonly = options.readonly ? options.readonly : false;
         let upgrades = {};
         const versionUpgradeKeys = Object.keys(this.versionUpgrades);
         if (versionUpgradeKeys.length !== 0 &&
             versionUpgradeKeys.includes(dbName)) {
             upgrades = this.versionUpgrades[dbName];
         }
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
         const databaseConnection = new Database_1.Database(dbName + 'SQLite.db', 
         /*        encrypted,
         inMode,
         */
-        version, upgrades);
-        this.databases[dbName] = databaseConnection;
+        version, readonly, upgrades);
+        this.databases[connName] = databaseConnection;
         return;
     }
     async closeConnection(options) {
         const dbName = this.getOptionValue(options, 'database');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
         if (database.isDBOpen()) {
             // close the database
             try {
@@ -3720,7 +3736,7 @@ class CapacitorSQLite {
             }
         }
         // remove the connection from dictionary
-        delete this.databases[dbName];
+        delete this.databases[connName];
     }
     async echo(options) {
         const echoValue = this.getOptionValue(options, 'value');
@@ -3730,7 +3746,9 @@ class CapacitorSQLite {
     }
     async open(options) {
         const dbName = this.getOptionValue(options, 'database');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
         try {
             await database.open();
             return;
@@ -3741,80 +3759,128 @@ class CapacitorSQLite {
     }
     async close(options) {
         const dbName = this.getOptionValue(options, 'database');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            await database.close();
-            return;
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            try {
+                await database.close();
+                return;
+            }
+            catch (err) {
+                throw new Error(`Close: ${err}`);
+            }
         }
-        catch (err) {
-            throw new Error(`Close: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`Close: ${msg}`);
         }
     }
     async getVersion(options) {
         const dbName = this.getOptionValue(options, 'database');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            const version = await database.getVersion();
-            const versionResult = {};
-            versionResult.version = version;
-            return versionResult;
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            try {
+                const version = await database.getVersion();
+                const versionResult = {};
+                versionResult.version = version;
+                return versionResult;
+            }
+            catch (err) {
+                throw new Error(`GetVersion: ${err}`);
+            }
         }
-        catch (err) {
-            throw new Error(`GetVersion: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`GetVersion: ${msg}`);
         }
     }
     async getTableList(options) {
         const dbName = this.getOptionValue(options, 'database');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            const tableList = await database.getTableList();
-            const tableListResult = {};
-            tableListResult.values = tableList;
-            return tableListResult;
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            try {
+                const tableList = await database.getTableList();
+                const tableListResult = {};
+                tableListResult.values = tableList;
+                return tableListResult;
+            }
+            catch (err) {
+                throw new Error(`GetTableList: ${err}`);
+            }
         }
-        catch (err) {
-            throw new Error(`GetTableList: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`GetTableList: ${msg}`);
         }
     }
     async execute(options) {
         const dbName = this.getOptionValue(options, 'database');
         const statements = this.getOptionValue(options, 'statements');
         const transaction = this.getOptionValue(options, 'transaction', true);
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            const executeResult = await database.executeSQL(statements, transaction);
-            if (executeResult < 0) {
-                throw new Error('Execute failed changes < 0');
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            if (readonly) {
+                const msg = "not allowed in read-only mode ";
+                throw new Error(`Execute: ${msg}`);
             }
-            else {
-                return { changes: { changes: executeResult } };
+            try {
+                const executeResult = await database.executeSQL(statements, transaction);
+                if (executeResult < 0) {
+                    throw new Error('Execute changes < 0');
+                }
+                else {
+                    return { changes: { changes: executeResult } };
+                }
+            }
+            catch (err) {
+                throw new Error(`Execute: ${err}`);
             }
         }
-        catch (err) {
-            throw new Error(`Execute failed: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`Execute: ${msg}`);
         }
     }
     async executeSet(options) {
         const dbName = this.getOptionValue(options, 'database');
         const setOfStatements = this.getOptionValue(options, 'set');
         const transaction = this.getOptionValue(options, 'transaction', true);
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
         for (const sStmt of setOfStatements) {
             if (!('statement' in sStmt) || !('values' in sStmt)) {
                 throw new Error('ExecuteSet: Must provide a set as ' + 'Array of {statement,values}');
             }
         }
-        try {
-            const execSetResult = await database.execSet(setOfStatements, transaction);
-            if (execSetResult < 0) {
-                throw new Error(`ExecuteSet failed changes <0`);
+        if (database.isDBOpen()) {
+            if (readonly) {
+                const msg = "not allowed in read-only mode ";
+                throw new Error(`ExecuteSet failed: ${msg}`);
             }
-            else {
-                return { changes: execSetResult };
+            try {
+                const execSetResult = await database.execSet(setOfStatements, transaction);
+                if (execSetResult < 0) {
+                    throw new Error(`ExecuteSet failed changes <0`);
+                }
+                else {
+                    return { changes: execSetResult };
+                }
+            }
+            catch (err) {
+                throw new Error(`ExecuteSet failed: ${err}`);
             }
         }
-        catch (err) {
-            throw new Error(`ExecuteSet failed: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`ExecuteSet failed: ${msg}`);
         }
     }
     async run(options) {
@@ -3822,13 +3888,25 @@ class CapacitorSQLite {
         const statement = this.getOptionValue(options, 'statement');
         const values = this.getOptionValue(options, 'values', []);
         const transaction = this.getOptionValue(options, 'transaction', true);
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            const runResult = await database.runSQL(statement, values, transaction);
-            return { changes: runResult };
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            if (readonly) {
+                const msg = "not allowed in read-only mode ";
+                throw new Error(`Run failed: ${msg}`);
+            }
+            try {
+                const runResult = await database.runSQL(statement, values, transaction);
+                return { changes: runResult };
+            }
+            catch (err) {
+                throw new Error(`RUN failed: ${err} `);
+            }
         }
-        catch (err) {
-            throw new Error(`RUN failed: ${err} `);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`Run failed: ${msg}`);
         }
     }
     async query(options) {
@@ -3836,28 +3914,44 @@ class CapacitorSQLite {
         const statement = this.getOptionValue(options, 'statement');
         const values = this.getOptionValue(options, 'values', []);
         if (statement.length === 0) {
-            throw new Error('Statement may not be an empty string.');
+            throw new Error('Query: Statement may not be an empty string.');
         }
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            const queryResult = await database.selectSQL(statement, values);
-            return { values: queryResult };
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            try {
+                const queryResult = await database.selectSQL(statement, values);
+                return { values: queryResult };
+            }
+            catch (err) {
+                throw new Error(`Query: ${err}`);
+            }
         }
-        catch (err) {
-            throw new Error(`Query failed: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`Query: ${msg}`);
         }
     }
     async isDBExists(options) {
         const dbName = this.getOptionValue(options, 'database');
-        // Throw an error, if db connection is not opened yet:
-        this.getDatabaseConnectionOrThrowError(dbName);
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
+        this.getDatabaseConnectionOrThrowError(connName);
+        //    if (database.isDBOpen()) {
         const isExists = this.fileUtil.isFileExists(dbName + 'SQLite.db');
         return { result: isExists };
+        //    } else {
+        //      const msg = `Database ${dbName} not opened`;
+        //     throw new Error(`isDBExists: ${msg}`);
+        //    }
     }
     async isDBOpen(options) {
         const dbName = this.getOptionValue(options, 'database');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        const isOpen = await database.isDBOpen();
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        const isOpen = database.isDBOpen();
         return { result: isOpen };
     }
     async isDatabase(options) {
@@ -3868,24 +3962,38 @@ class CapacitorSQLite {
     async isTableExists(options) {
         const dbName = this.getOptionValue(options, 'database');
         const tableName = this.getOptionValue(options, 'table');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            const isTableExistsResult = await database.isTableExists(tableName);
-            return { result: isTableExistsResult };
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            try {
+                const isTableExistsResult = await database.isTableExists(tableName);
+                return { result: isTableExistsResult };
+            }
+            catch (err) {
+                throw new Error(`isTableExists: ${err}`);
+            }
         }
-        catch (err) {
-            throw new Error(`isTableExists: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`isTableExists: ${msg}`);
         }
     }
     async deleteDatabase(options) {
         const dbName = this.getOptionValue(options, 'database');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (readonly) {
+            const msg = "not allowed in read-only mode ";
+            throw new Error(`DeleteDatabase failed: ${msg}`);
+        }
         try {
             await database.deleteDB(dbName + 'SQLite.db');
             return;
         }
         catch (err) {
-            throw new Error(`Delete: ${err}`);
+            throw new Error(`DeleteDatabase: ${err}`);
         }
     }
     async isJsonValid(options) {
@@ -3917,7 +4025,7 @@ class CapacitorSQLite {
         // Create the database
         const database = new Database_1.Database(dbName, 
         /*encrypted, mode, */
-        targetDbVersion, {});
+        targetDbVersion, false, {});
         try {
             if (overwrite && mode === 'full') {
                 const isExists = this.fileUtil.isFileExists(dbName);
@@ -3950,66 +4058,118 @@ class CapacitorSQLite {
     async exportToJson(options) {
         const dbName = this.getOptionValue(options, 'database');
         const exportMode = this.getOptionValue(options, 'jsonexportmode');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            const exportJsonResult = await database.exportJson(exportMode);
-            const resultKeys = Object.keys(exportJsonResult);
-            if (resultKeys.includes('message')) {
-                throw new Error(`exportToJson: ${exportJsonResult.message}`);
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            try {
+                const exportJsonResult = await database.exportJson(exportMode);
+                const resultKeys = Object.keys(exportJsonResult);
+                if (resultKeys.includes('message')) {
+                    throw new Error(`exportToJson: ${exportJsonResult.message}`);
+                }
+                else {
+                    return { export: exportJsonResult };
+                }
             }
-            else {
-                return { export: exportJsonResult };
+            catch (err) {
+                throw new Error(`ExportToJson: ${err}`);
             }
         }
-        catch (err) {
-            throw new Error(`exportToJson: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`ExportToJson: ${msg}`);
         }
     }
     async createSyncTable(options) {
         const dbName = this.getOptionValue(options, 'database');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            const createTableSyncResult = await database.createSyncTable();
-            return {
-                changes: { changes: createTableSyncResult },
-            };
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            if (readonly) {
+                const msg = "not allowed in read-only mode ";
+                throw new Error(`CreateSyncTable failed: ${msg}`);
+            }
+            try {
+                const createTableSyncResult = await database.createSyncTable();
+                return {
+                    changes: { changes: createTableSyncResult },
+                };
+            }
+            catch (err) {
+                throw new Error(`CreateSyncTable: ${err}`);
+            }
         }
-        catch (err) {
-            throw new Error(`createSyncTable: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`CreateSyncTable: ${msg}`);
         }
     }
     async setSyncDate(options) {
         const dbName = this.getOptionValue(options, 'database');
         const syncDate = this.getOptionValue(options, 'syncdate');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            await database.setSyncDate(syncDate);
-            return;
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            if (readonly) {
+                const msg = "not allowed in read-only mode ";
+                throw new Error(`SetSyncDate failed: ${msg}`);
+            }
+            try {
+                await database.setSyncDate(syncDate);
+                return;
+            }
+            catch (err) {
+                throw new Error(`SetSyncDate: ${err}`);
+            }
         }
-        catch (err) {
-            throw new Error(`SetSyncDate: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`SetSyncDate: ${msg}`);
         }
     }
     async getSyncDate(options) {
         const dbName = this.getOptionValue(options, 'database');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            const ret = await database.getSyncDate();
-            return Promise.resolve(ret);
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = readonly ? "RO_" + dbName : "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            try {
+                const ret = await database.getSyncDate();
+                return Promise.resolve(ret);
+            }
+            catch (err) {
+                throw new Error(`GetSyncDate: ${err}`);
+            }
         }
-        catch (err) {
-            throw new Error(`GetSyncDate: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`GetSyncDate: ${msg}`);
         }
     }
     async deleteExportedRows(options) {
         const dbName = this.getOptionValue(options, 'database');
-        const database = this.getDatabaseConnectionOrThrowError(dbName);
-        try {
-            await database.deleteExportedRows();
-            return Promise.resolve();
+        const readonly = options.readonly ? options.readonly : false;
+        const connName = "RW_" + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            if (readonly) {
+                const msg = "not allowed in read-only mode ";
+                throw new Error(`DeleteExportedRows: ${msg}`);
+            }
+            try {
+                await database.deleteExportedRows();
+                return Promise.resolve();
+            }
+            catch (err) {
+                throw new Error(`DeleteExportedRows: ${err}`);
+            }
         }
-        catch (err) {
-            throw new Error(`DeleteExportedRows: ${err}`);
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`DeleteExportedRows: ${msg}`);
         }
     }
     async addUpgradeStatement(options) {
@@ -4084,7 +4244,12 @@ class CapacitorSQLite {
                 for (const key of inConnectionsSet) {
                     if (!Array.from(outConnectionSet.keys()).includes(key)) {
                         const opt = {};
-                        opt.database = key;
+                        let readonly = false;
+                        if (key.substring(0, 3) === "RO_") {
+                            readonly = true;
+                        }
+                        opt.database = key.substring(3);
+                        opt.readonly = readonly;
                         await this.closeConnection(opt);
                     }
                 }
@@ -4114,7 +4279,12 @@ class CapacitorSQLite {
         try {
             for (const key of keys) {
                 const opt = {};
-                opt.database = key;
+                let readonly = false;
+                if (key.substring(0, 3) === "RO_") {
+                    readonly = true;
+                }
+                opt.database = key.substring(3);
+                opt.readonly = readonly;
                 await this.closeConnection(opt);
             }
         }