@capacitor-community/sqlite 4.1.0-4 → 4.1.0-7

package/dist/plugin.js

@@ -76,12 +76,10 @@ var capacitorCapacitorSQLite = (function (exports, core) {
                 return Promise.reject(err);
             }
         }
-        async addUpgradeStatement(database, fromVersion, toVersion, statement, set) {
+        async addUpgradeStatement(database, toVersion, statements) {
             const upgrade = {
-                fromVersion,
                 toVersion,
-                statement,
-                set: set ? set : [],
+                statements,
             };
             try {
                 if (database.endsWith('.db'))
@@ -96,7 +94,7 @@ var capacitorCapacitorSQLite = (function (exports, core) {
                 return Promise.reject(err);
             }
         }
-        async createConnection(database, encrypted, mode, version) {
+        async createConnection(database, encrypted, mode, version, readonly) {
             try {
                 if (database.endsWith('.db'))
                     database = database.slice(0, -3);
@@ -105,39 +103,44 @@ var capacitorCapacitorSQLite = (function (exports, core) {
                     encrypted,
                     mode,
                     version,
+                    readonly,
                 });
-                const conn = new SQLiteDBConnection(database, this.sqlite);
-                this._connectionDict.set(database, conn);
+                const conn = new SQLiteDBConnection(database, readonly, this.sqlite);
+                const connName = readonly ? `RO_${database}` : `RW_${database}`;
+                this._connectionDict.set(connName, conn);
                 return Promise.resolve(conn);
             }
             catch (err) {
                 return Promise.reject(err);
             }
         }
-        async closeConnection(database) {
+        async closeConnection(database, readonly) {
             try {
                 if (database.endsWith('.db'))
                     database = database.slice(0, -3);
-                await this.sqlite.closeConnection({ database });
-                this._connectionDict.delete(database);
+                await this.sqlite.closeConnection({ database, readonly });
+                const connName = readonly ? `RO_${database}` : `RW_${database}`;
+                this._connectionDict.delete(connName);
                 return Promise.resolve();
             }
             catch (err) {
                 return Promise.reject(err);
             }
         }
-        async isConnection(database) {
+        async isConnection(database, readonly) {
             const res = {};
             if (database.endsWith('.db'))
                 database = database.slice(0, -3);
-            res.result = this._connectionDict.has(database);
+            const connName = readonly ? `RO_${database}` : `RW_${database}`;
+            res.result = this._connectionDict.has(connName);
             return Promise.resolve(res);
         }
-        async retrieveConnection(database) {
+        async retrieveConnection(database, readonly) {
             if (database.endsWith('.db'))
                 database = database.slice(0, -3);
-            if (this._connectionDict.has(database)) {
-                const conn = this._connectionDict.get(database);
+            const connName = readonly ? `RO_${database}` : `RW_${database}`;
+            if (this._connectionDict.has(connName)) {
+                const conn = this._connectionDict.get(connName);
                 if (typeof conn != 'undefined')
                     return Promise.resolve(conn);
                 else {
@@ -166,8 +169,9 @@ var capacitorCapacitorSQLite = (function (exports, core) {
                     databasePath,
                     version,
                 });
-                const conn = new SQLiteDBConnection(databasePath, this.sqlite);
-                this._connectionDict.set(databasePath, conn);
+                const conn = new SQLiteDBConnection(databasePath, true, this.sqlite);
+                const connName = `RO_${databasePath})`;
+                this._connectionDict.set(connName, conn);
                 return Promise.resolve(conn);
             }
             catch (err) {
@@ -177,7 +181,8 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         async closeNCConnection(databasePath) {
             try {
                 await this.sqlite.closeNCConnection({ databasePath });
-                this._connectionDict.delete(databasePath);
+                const connName = `RO_${databasePath})`;
+                this._connectionDict.delete(connName);
                 return Promise.resolve();
             }
             catch (err) {
@@ -186,12 +191,14 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         }
         async isNCConnection(databasePath) {
             const res = {};
-            res.result = this._connectionDict.has(databasePath);
+            const connName = `RO_${databasePath})`;
+            res.result = this._connectionDict.has(connName);
             return Promise.resolve(res);
         }
         async retrieveNCConnection(databasePath) {
             if (this._connectionDict.has(databasePath)) {
-                const conn = this._connectionDict.get(databasePath);
+                const connName = `RO_${databasePath})`;
+                const conn = this._connectionDict.get(connName);
                 if (typeof conn != 'undefined')
                     return Promise.resolve(conn);
                 else {
@@ -217,12 +224,14 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         async closeAllConnections() {
             const delDict = new Map();
             try {
-                for (const database of this._connectionDict.keys()) {
-                    await this.sqlite.closeConnection({ database });
-                    delDict.set(database, null);
+                for (const key of this._connectionDict.keys()) {
+                    const database = key.substring(3);
+                    const readonly = key.substring(0, 3) === ("RO_") ? true : false;
+                    await this.sqlite.closeConnection({ database, readonly });
+                    delDict.set(key, null);
                 }
-                for (const database of delDict.keys()) {
-                    this._connectionDict.delete(database);
+                for (const key of delDict.keys()) {
+                    this._connectionDict.delete(key);
                 }
                 return Promise.resolve();
             }
@@ -346,16 +355,23 @@ var capacitorCapacitorSQLite = (function (exports, core) {
      * SQLiteDBConnection Class
      */
     class SQLiteDBConnection {
-        constructor(dbName, sqlite) {
+        constructor(dbName, readonly, sqlite) {
             this.dbName = dbName;
+            this.readonly = readonly;
             this.sqlite = sqlite;
         }
         getConnectionDBName() {
             return this.dbName;
         }
+        getConnectionReadOnly() {
+            return this.readonly;
+        }
         async open() {
             try {
-                await this.sqlite.open({ database: this.dbName });
+                await this.sqlite.open({
+                    database: this.dbName,
+                    readonly: this.readonly,
+                });
                 return Promise.resolve();
             }
             catch (err) {
@@ -364,7 +380,10 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         }
         async close() {
             try {
-                await this.sqlite.close({ database: this.dbName });
+                await this.sqlite.close({
+                    database: this.dbName,
+                    readonly: this.readonly,
+                });
                 return Promise.resolve();
             }
             catch (err) {
@@ -375,6 +394,7 @@ var capacitorCapacitorSQLite = (function (exports, core) {
             try {
                 const res = await this.sqlite.getUrl({
                     database: this.dbName,
+                    readonly: this.readonly,
                 });
                 return Promise.resolve(res);
             }
@@ -386,6 +406,7 @@ var capacitorCapacitorSQLite = (function (exports, core) {
             try {
                 const version = await this.sqlite.getVersion({
                     database: this.dbName,
+                    readonly: this.readonly,
                 });
                 return Promise.resolve(version);
             }
@@ -397,6 +418,7 @@ var capacitorCapacitorSQLite = (function (exports, core) {
             try {
                 const res = await this.sqlite.getTableList({
                     database: this.dbName,
+                    readonly: this.readonly,
                 });
                 return Promise.resolve(res);
             }
@@ -406,12 +428,18 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         }
         async execute(statements, transaction = true) {
             try {
-                const res = await this.sqlite.execute({
-                    database: this.dbName,
-                    statements: statements,
-                    transaction: transaction,
-                });
-                return Promise.resolve(res);
+                if (!this.readonly) {
+                    const res = await this.sqlite.execute({
+                        database: this.dbName,
+                        statements: statements,
+                        transaction: transaction,
+                        readonly: false,
+                    });
+                    return Promise.resolve(res);
+                }
+                else {
+                    return Promise.reject('not allowed in read-only mode');
+                }
             }
             catch (err) {
                 return Promise.reject(err);
@@ -425,6 +453,7 @@ var capacitorCapacitorSQLite = (function (exports, core) {
                         database: this.dbName,
                         statement: statement,
                         values: values,
+                        readonly: this.readonly,
                     });
                 }
                 else {
@@ -432,6 +461,7 @@ var capacitorCapacitorSQLite = (function (exports, core) {
                         database: this.dbName,
                         statement: statement,
                         values: [],
+                        readonly: this.readonly,
                     });
                 }
                 if (res && typeof res.values[0] === 'object') {
@@ -459,24 +489,31 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         async run(statement, values, transaction = true) {
             let res;
             try {
-                if (values && values.length > 0) {
-                    res = await this.sqlite.run({
-                        database: this.dbName,
-                        statement: statement,
-                        values: values,
-                        transaction: transaction,
-                    });
-                    //        }
+                if (!this.readonly) {
+                    if (values && values.length > 0) {
+                        res = await this.sqlite.run({
+                            database: this.dbName,
+                            statement: statement,
+                            values: values,
+                            transaction: transaction,
+                            readonly: false,
+                        });
+                        //        }
+                    }
+                    else {
+                        res = await this.sqlite.run({
+                            database: this.dbName,
+                            statement: statement,
+                            values: [],
+                            transaction: transaction,
+                            readonly: false,
+                        });
+                    }
+                    return Promise.resolve(res);
                 }
                 else {
-                    res = await this.sqlite.run({
-                        database: this.dbName,
-                        statement: statement,
-                        values: [],
-                        transaction: transaction,
-                    });
+                    return Promise.reject('not allowed in read-only mode');
                 }
-                return Promise.resolve(res);
             }
             catch (err) {
                 return Promise.reject(err);
@@ -484,13 +521,19 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         }
         async executeSet(set, transaction = true) {
             try {
-                const res = await this.sqlite.executeSet({
-                    database: this.dbName,
-                    set: set,
-                    transaction: transaction,
-                });
-                //      }
-                return Promise.resolve(res);
+                if (!this.readonly) {
+                    const res = await this.sqlite.executeSet({
+                        database: this.dbName,
+                        set: set,
+                        transaction: transaction,
+                        readonly: false,
+                    });
+                    //      }
+                    return Promise.resolve(res);
+                }
+                else {
+                    return Promise.reject('not allowed in read-only mode');
+                }
             }
             catch (err) {
                 return Promise.reject(err);
@@ -500,6 +543,7 @@ var capacitorCapacitorSQLite = (function (exports, core) {
             try {
                 const res = await this.sqlite.isDBExists({
                     database: this.dbName,
+                    readonly: this.readonly,
                 });
                 return Promise.resolve(res);
             }
@@ -512,6 +556,7 @@ var capacitorCapacitorSQLite = (function (exports, core) {
                 const res = await this.sqlite.isTableExists({
                     database: this.dbName,
                     table: table,
+                    readonly: this.readonly,
                 });
                 return Promise.resolve(res);
             }
@@ -523,6 +568,7 @@ var capacitorCapacitorSQLite = (function (exports, core) {
             try {
                 const res = await this.sqlite.isDBOpen({
                     database: this.dbName,
+                    readonly: this.readonly,
                 });
                 return Promise.resolve(res);
             }
@@ -532,8 +578,16 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         }
         async delete() {
             try {
-                await this.sqlite.deleteDatabase({ database: this.dbName });
-                return Promise.resolve();
+                if (!this.readonly) {
+                    await this.sqlite.deleteDatabase({
+                        database: this.dbName,
+                        readonly: false,
+                    });
+                    return Promise.resolve();
+                }
+                else {
+                    return Promise.reject('not allowed in read-only mode');
+                }
             }
             catch (err) {
                 return Promise.reject(err);
@@ -541,10 +595,16 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         }
         async createSyncTable() {
             try {
-                const res = await this.sqlite.createSyncTable({
-                    database: this.dbName,
-                });
-                return Promise.resolve(res);
+                if (!this.readonly) {
+                    const res = await this.sqlite.createSyncTable({
+                        database: this.dbName,
+                        readonly: false,
+                    });
+                    return Promise.resolve(res);
+                }
+                else {
+                    return Promise.reject('not allowed in read-only mode');
+                }
             }
             catch (err) {
                 return Promise.reject(err);
@@ -552,11 +612,17 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         }
         async setSyncDate(syncdate) {
             try {
-                await this.sqlite.setSyncDate({
-                    database: this.dbName,
-                    syncdate: syncdate,
-                });
-                return Promise.resolve();
+                if (!this.readonly) {
+                    await this.sqlite.setSyncDate({
+                        database: this.dbName,
+                        syncdate: syncdate,
+                        readonly: false,
+                    });
+                    return Promise.resolve();
+                }
+                else {
+                    return Promise.reject('not allowed in read-only mode');
+                }
             }
             catch (err) {
                 return Promise.reject(err);
@@ -566,6 +632,7 @@ var capacitorCapacitorSQLite = (function (exports, core) {
             try {
                 const res = await this.sqlite.getSyncDate({
                     database: this.dbName,
+                    readonly: this.readonly,
                 });
                 let retDate = '';
                 if (res.syncDate > 0)
@@ -581,6 +648,7 @@ var capacitorCapacitorSQLite = (function (exports, core) {
                 const res = await this.sqlite.exportToJson({
                     database: this.dbName,
                     jsonexportmode: mode,
+                    readonly: this.readonly,
                 });
                 return Promise.resolve(res);
             }
@@ -590,8 +658,16 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         }
         async deleteExportedRows() {
             try {
-                await this.sqlite.deleteExportedRows({ database: this.dbName });
-                return Promise.resolve();
+                if (!this.readonly) {
+                    await this.sqlite.deleteExportedRows({
+                        database: this.dbName,
+                        readonly: false,
+                    });
+                    return Promise.resolve();
+                }
+                else {
+                    return Promise.reject('not allowed in read-only mode');
+                }
             }
             catch (err) {
                 return Promise.reject(err);
@@ -599,55 +675,65 @@ var capacitorCapacitorSQLite = (function (exports, core) {
         }
         async executeTransaction(txn) {
             try {
-                const ret = await this.sqlite.execute({
-                    database: this.dbName,
-                    statements: 'BEGIN TRANSACTION;',
-                    transaction: false,
-                });
-                if (ret.changes.changes < 0) {
-                    return Promise.reject('Error in BEGIN TRANSACTION');
-                }
-                for (const task of txn) {
-                    if (task.values && task.values.length > 0) {
-                        const ret = await this.sqlite.run({
-                            database: this.dbName,
-                            statement: task.statement,
-                            values: task.values,
-                            transaction: false,
-                        });
-                        if (ret.changes.lastId === -1) {
-                            await this.execute('ROLLBACK;', false);
-                            return Promise.reject('Error in transaction run ');
-                        }
+                if (!this.readonly) {
+                    const ret = await this.sqlite.execute({
+                        database: this.dbName,
+                        statements: 'BEGIN TRANSACTION;',
+                        transaction: false,
+                    });
+                    if (ret.changes.changes < 0) {
+                        return Promise.reject('Error in BEGIN TRANSACTION');
                     }
-                    else {
-                        const ret = await this.sqlite.execute({
-                            database: this.dbName,
-                            statements: task.statement,
-                            transaction: false,
-                        });
-                        if (ret.changes.changes < 0) {
-                            await this.sqlite.execute({
+                    for (const task of txn) {
+                        if (task.values && task.values.length > 0) {
+                            const ret = await this.sqlite.run({
+                                database: this.dbName,
+                                statement: task.statement,
+                                values: task.values,
+                                transaction: false,
+                                readonly: false,
+                            });
+                            if (ret.changes.lastId === -1) {
+                                await this.execute('ROLLBACK;', false);
+                                return Promise.reject('Error in transaction run ');
+                            }
+                        }
+                        else {
+                            const ret = await this.sqlite.execute({
                                 database: this.dbName,
-                                statements: 'ROLLBACK;',
+                                statements: task.statement,
                                 transaction: false,
+                                readonly: false,
                             });
-                            return Promise.reject('Error in transaction execute ');
+                            if (ret.changes.changes < 0) {
+                                await this.sqlite.execute({
+                                    database: this.dbName,
+                                    statements: 'ROLLBACK;',
+                                    transaction: false,
+                                    readonly: false,
+                                });
+                                return Promise.reject('Error in transaction execute ');
+                            }
                         }
                     }
+                    await this.sqlite.execute({
+                        database: this.dbName,
+                        statements: 'COMMIT;',
+                        transaction: false,
+                        readonly: false,
+                    });
+                    return Promise.resolve();
+                }
+                else {
+                    return Promise.reject('not allowed in read-only mode');
                 }
-                await this.sqlite.execute({
-                    database: this.dbName,
-                    statements: 'COMMIT;',
-                    transaction: false,
-                });
-                return Promise.resolve();
             }
             catch (err) {
                 await this.sqlite.execute({
                     database: this.dbName,
                     statements: 'ROLLBACK;',
                     transaction: false,
+                    readonly: false,
                 });
                 return Promise.reject(err);
             }