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

package/dist/plugin.cjs.js

@@ -79,12 +79,10 @@ class SQLiteConnection {
             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'))
@@ -99,7 +97,7 @@ class SQLiteConnection {
             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);
@@ -108,39 +106,44 @@ class SQLiteConnection {
                 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 {
@@ -169,8 +172,9 @@ class SQLiteConnection {
                 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) {
@@ -180,7 +184,8 @@ class SQLiteConnection {
     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) {
@@ -189,12 +194,14 @@ class SQLiteConnection {
     }
     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 {
@@ -220,12 +227,14 @@ class SQLiteConnection {
     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();
         }
@@ -349,16 +358,23 @@ class SQLiteConnection {
  * 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) {
@@ -367,7 +383,10 @@ class SQLiteDBConnection {
     }
     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) {
@@ -378,6 +397,7 @@ class SQLiteDBConnection {
         try {
             const res = await this.sqlite.getUrl({
                 database: this.dbName,
+                readonly: this.readonly,
             });
             return Promise.resolve(res);
         }
@@ -389,6 +409,7 @@ class SQLiteDBConnection {
         try {
             const version = await this.sqlite.getVersion({
                 database: this.dbName,
+                readonly: this.readonly,
             });
             return Promise.resolve(version);
         }
@@ -400,6 +421,7 @@ class SQLiteDBConnection {
         try {
             const res = await this.sqlite.getTableList({
                 database: this.dbName,
+                readonly: this.readonly,
             });
             return Promise.resolve(res);
         }
@@ -409,12 +431,18 @@ class SQLiteDBConnection {
     }
     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);
@@ -428,6 +456,7 @@ class SQLiteDBConnection {
                     database: this.dbName,
                     statement: statement,
                     values: values,
+                    readonly: this.readonly,
                 });
             }
             else {
@@ -435,6 +464,7 @@ class SQLiteDBConnection {
                     database: this.dbName,
                     statement: statement,
                     values: [],
+                    readonly: this.readonly,
                 });
             }
             if (res && typeof res.values[0] === 'object') {
@@ -462,24 +492,31 @@ class SQLiteDBConnection {
     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);
@@ -487,13 +524,19 @@ class SQLiteDBConnection {
     }
     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);
@@ -503,6 +546,7 @@ class SQLiteDBConnection {
         try {
             const res = await this.sqlite.isDBExists({
                 database: this.dbName,
+                readonly: this.readonly,
             });
             return Promise.resolve(res);
         }
@@ -515,6 +559,7 @@ class SQLiteDBConnection {
             const res = await this.sqlite.isTableExists({
                 database: this.dbName,
                 table: table,
+                readonly: this.readonly,
             });
             return Promise.resolve(res);
         }
@@ -526,6 +571,7 @@ class SQLiteDBConnection {
         try {
             const res = await this.sqlite.isDBOpen({
                 database: this.dbName,
+                readonly: this.readonly,
             });
             return Promise.resolve(res);
         }
@@ -535,8 +581,16 @@ class SQLiteDBConnection {
     }
     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);
@@ -544,10 +598,16 @@ class SQLiteDBConnection {
     }
     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);
@@ -555,11 +615,17 @@ class SQLiteDBConnection {
     }
     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);
@@ -569,6 +635,7 @@ class SQLiteDBConnection {
         try {
             const res = await this.sqlite.getSyncDate({
                 database: this.dbName,
+                readonly: this.readonly,
             });
             let retDate = '';
             if (res.syncDate > 0)
@@ -584,6 +651,7 @@ class SQLiteDBConnection {
             const res = await this.sqlite.exportToJson({
                 database: this.dbName,
                 jsonexportmode: mode,
+                readonly: this.readonly,
             });
             return Promise.resolve(res);
         }
@@ -593,8 +661,16 @@ class SQLiteDBConnection {
     }
     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);
@@ -602,55 +678,65 @@ class SQLiteDBConnection {
     }
     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);
         }