@capacitor-community/sqlite 5.0.7-2 → 5.0.8

package/src/definitions.ts

@@ -120,6 +120,34 @@ export interface CapacitorSQLitePlugin {
    * @since 0.0.1
    */
   close(options: capSQLiteOptions): Promise<void>;
+  /**
+   * Begin Database Transaction
+   * @param options  
+   * @returns capSQLiteChanges
+   * @since 5.0.7
+   */
+  beginTransaction(options: capSQLiteOptions): Promise<capSQLiteChanges>;
+  /**
+   * Commit Database Transaction
+   * @param options  
+   * @returns capSQLiteChanges
+   * @since 5.0.7
+   */
+  commitTransaction(options: capSQLiteOptions): Promise<capSQLiteChanges>;
+    /**
+   * Rollback Database Transaction
+   * @param options  
+   * @returns capSQLiteChanges
+   * @since 5.0.7
+   */
+  rollbackTransaction(options: capSQLiteOptions): Promise<capSQLiteChanges>;
+  /**
+   * Is Database Transaction Active
+   * @param options  
+   * @returns capSQLiteResult
+   * @since 5.0.7
+   */
+  isTransactionActive(options: capSQLiteOptions): Promise<capSQLiteResult>; 
   /**
    * Load a SQlite extension
    * @param options :capSQLiteExtensionPath
@@ -531,6 +559,14 @@ export interface capSQLiteExecuteOptions {
    * @since 4.1.0-7
    */
   readonly?: boolean;
+  /**
+   * Compatibility SQL92
+   * !!! ELECTRON ONLY
+   * default (true)
+   * @since 5.0.7
+   */
+  isSQL92?: boolean;
+
 }
 export interface capSQLiteSetOptions {
   /**
@@ -561,6 +597,13 @@ export interface capSQLiteSetOptions {
    * @since 5.0.5-3
    */
   returnMode?: string;
+  /**
+   * Compatibility SQL92
+   * !!! ELECTRON ONLY
+   * default (true)
+   * @since 5.0.7
+   */
+  isSQL92?: boolean;
 }
 export interface capSQLiteRunOptions {
   /**
@@ -595,6 +638,13 @@ export interface capSQLiteRunOptions {
    * @since 5.0.5-3
    */
   returnMode?: string;
+  /**
+   * Compatibility SQL92
+   * !!! ELECTRON ONLY
+   * default (true)
+   * @since 5.0.7
+   */
+  isSQL92?: boolean;
 }
 export interface capSQLiteQueryOptions {
   /**
@@ -617,6 +667,13 @@ export interface capSQLiteQueryOptions {
    * @since 4.1.0-7
    */
   readonly?: boolean;
+  /**
+   * Compatibility SQL92
+   * !!! ELECTRON ONLY
+   * default (true)
+   * @since 5.0.7
+   */
+  isSQL92?: boolean;
 }
 export interface capSQLiteImportOptions {
   /**
@@ -642,6 +699,15 @@ export interface capSQLiteExportOptions {
    * @since 4.1.0-7
    */
   readonly?: boolean;
+  /**
+   * Encrypted
+   * When your database is encrypted
+   * Choose the export Json Object
+   * Encrypted (true) / Unencrypted (false)
+   * default false
+   * @since 5.0.8
+   */
+  encrypted?: boolean
 }
 export interface capSQLiteFromAssetsOptions {
   /**
@@ -1553,8 +1619,8 @@ export class SQLiteConnection implements ISQLiteConnection {
   async checkConnectionsConsistency(): Promise<capSQLiteResult> {
     try {
       const keys = [...this._connectionDict.keys()];
-      const openModes = [];
-      const dbNames = [];
+      const openModes: string[] = [];
+      const dbNames: string[] = [];
       for (const key of keys) {
         openModes.push(key.substring(0, 2));
         dbNames.push(key.substring(3));
@@ -1740,6 +1806,30 @@ export interface ISQLiteDBConnection {
    * @since 2.9.0 refactor
    */
   close(): Promise<void>;
+  /**
+   * Begin Database Transaction
+   * @returns capSQLiteChanges
+   * @since 5.0.7
+   */
+  beginTransaction(): Promise<capSQLiteChanges>;
+  /**
+   * Commit Database Transaction
+   * @returns capSQLiteChanges
+   * @since 5.0.7
+   */
+  commitTransaction(): Promise<capSQLiteChanges>;
+  /**
+   * Rollback Database Transaction
+   * @returns capSQLiteChanges
+   * @since 5.0.7
+   */
+  rollbackTransaction(): Promise<capSQLiteChanges>;
+  /**
+   * Is Database Transaction Active
+   * @returns capSQLiteResult
+   * @since 5.0.7
+   */
+  isTransactionActive(): Promise<capSQLiteResult>;   
   /**
    * Get Database Url
    * @returns Promise<capSQLiteUrl>
@@ -1769,22 +1859,28 @@ export interface ISQLiteDBConnection {
   /**
    * Execute SQLite DB Connection Statements
    * @param statements
+   * @param transaction (optional)
+   * @param isSQL92 (optional)
    * @returns Promise<capSQLiteChanges>
    * @since 2.9.0 refactor
    */
-  execute(statements: string, transaction?: boolean): Promise<capSQLiteChanges>;
+  execute(statements: string, transaction?: boolean, isSQL92?: boolean): Promise<capSQLiteChanges>;
   /**
    * Execute SQLite DB Connection Query
    * @param statement
    * @param values (optional)
+   * @param isSQL92 (optional)
    * @returns Promise<Promise<DBSQLiteValues>
    * @since 2.9.0 refactor
    */
-  query(statement: string, values?: any[]): Promise<DBSQLiteValues>;
+  query(statement: string, values?: any[], isSQL92?: boolean): Promise<DBSQLiteValues>;
   /**
    * Execute SQLite DB Connection Raw Statement
    * @param statement
    * @param values (optional)
+   * @param transaction (optional)
+   * @param returnMode (optional)
+   * @param isSQL92 (optional)
    * @returns Promise<capSQLiteChanges>
    * @since 2.9.0 refactor
    */
@@ -1793,10 +1889,14 @@ export interface ISQLiteDBConnection {
     values?: any[],
     transaction?: boolean,
     returnMode?: string,
+    isSQL92?: boolean
   ): Promise<capSQLiteChanges>;
   /**
    * Execute SQLite DB Connection Set
    * @param set
+   * @param transaction (optional)
+   * @param returnMode (optional)
+   * @param isSQL92 (optional)
    * @returns Promise<capSQLiteChanges>
    * @since 2.9.0 refactor
    */
@@ -1804,6 +1904,7 @@ export interface ISQLiteDBConnection {
     set: capSQLiteSet[],
     transaction?: boolean,
     returnMode?: string,
+    isSQL92?: boolean
   ): Promise<capSQLiteChanges>;
   /**
    * Check if a SQLite DB Connection exists
@@ -1856,10 +1957,11 @@ export interface ISQLiteDBConnection {
   /**
    * Export the given database to a JSON Object
    * @param mode
+   * @param encrypted (optional) since 5.0.8 not for Web platform
    * @returns Promise<capSQLiteJson>
    * @since 2.9.0 refactor
    */
-  exportToJson(mode: string): Promise<capSQLiteJson>;
+  exportToJson(mode: string, encrypted?: boolean): Promise<capSQLiteJson>;
   /**
    * Remove rows with sql_deleted = 1 after an export
    * @returns Promise<void>
@@ -1870,12 +1972,14 @@ export interface ISQLiteDBConnection {
   /**
    *
    * @param txn
-   * @returns Promise<void>
+   * @param isSQL92
+   * @returns Promise<capSQLiteChanges> since 5.0.7
    * @since 3.4.0
    */
   executeTransaction(
     txn: { statement: string; values?: any[] }[],
-  ): Promise<void>;
+    isSQL92: boolean
+  ): Promise<capSQLiteChanges>;
 }
 /**
  * SQLiteDBConnection Class
@@ -1895,6 +1999,9 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
   }
 
   async open(): Promise<void> {
+    const jeepSQlEL = document.querySelector("jeep-sqlite")
+    console.log(`in definition open jeepSQlEL: `,jeepSQlEL )
+
     try {
       await this.sqlite.open({
         database: this.dbName,
@@ -1916,39 +2023,64 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
       return Promise.reject(err);
     }
   }
+  async beginTransaction(): Promise<capSQLiteChanges> {
+    try {
+      const changes: capSQLiteChanges = await this.sqlite
+                          .beginTransaction({database: this.dbName});
+      return Promise.resolve(changes);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async commitTransaction(): Promise<capSQLiteChanges> {
+    try {
+      const changes: capSQLiteChanges = await this.sqlite
+                          .commitTransaction({database: this.dbName});
+      return Promise.resolve(changes);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async rollbackTransaction(): Promise<capSQLiteChanges> {
+    try {
+      const changes: capSQLiteChanges = await this.sqlite
+                          .rollbackTransaction({database: this.dbName});
+      return Promise.resolve(changes);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  } 
+  async isTransactionActive(): Promise<capSQLiteResult> {
+    try {
+      const result: capSQLiteResult = await this.sqlite
+                          .isTransactionActive({database: this.dbName});
+      return Promise.resolve(result);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }  
 
   async loadExtension(path: string): Promise<void> {
     try {
-      console.log(`database: ${this.dbName}`);
-      console.log(`readonly: ${this.readonly}}`);
-      console.log(`path: ${path}}`);
       await this.sqlite.loadExtension({
         database: this.dbName,
         path: path,
         readonly: this.readonly,
       });
-      console.log(`loadExtension successful`);
       return Promise.resolve();
     } catch (err) {
-      console.log(`loadExtension failed `);
       return Promise.reject(err);
     }
   }
   async enableLoadExtension(toggle: boolean): Promise<void> {
     try {
-      console.log(`database: ${this.dbName}`);
-      console.log(`readonly: ${this.readonly}`);
-      console.log(`toggle: ${toggle}`);
       await this.sqlite.enableLoadExtension({
         database: this.dbName,
         toggle: toggle,
         readonly: this.readonly,
       });
-      console.log(`enableLoadExtension successful`);
       return Promise.resolve();
     } catch (err) {
-      console.log(err);
-      console.log(`enableLoadExtension failed `);
       return Promise.reject(err);
     }
   }
@@ -1989,6 +2121,7 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
   async execute(
     statements: string,
     transaction = true,
+    isSQL92 = true
   ): Promise<capSQLiteChanges> {
     try {
       if (!this.readonly) {
@@ -1997,6 +2130,7 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
           statements: statements,
           transaction: transaction,
           readonly: false,
+          isSQL92: isSQL92
         });
         return Promise.resolve(res);
       } else {
@@ -2006,7 +2140,7 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
       return Promise.reject(err);
     }
   }
-  async query(statement: string, values?: any[]): Promise<DBSQLiteValues> {
+  async query(statement: string, values?: any[], isSQL92 = true): Promise<DBSQLiteValues> {
     let res: any;
     try {
       if (values && values.length > 0) {
@@ -2015,6 +2149,7 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
           statement: statement,
           values: values,
           readonly: this.readonly,
+          isSql92 : true
         });
       } else {
         res = await this.sqlite.query({
@@ -2022,6 +2157,7 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
           statement: statement,
           values: [],
           readonly: this.readonly,
+          isSQL92: isSQL92
         });
       }
 
@@ -2037,6 +2173,7 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
     values?: any[],
     transaction = true,
     returnMode = 'no',
+    isSQL92 = true
   ): Promise<capSQLiteChanges> {
     let res: any;
     try {
@@ -2052,6 +2189,7 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
             transaction: transaction,
             readonly: false,
             returnMode: mRetMode,
+            isSQL92: true
           });
           //        }
         } else {
@@ -2065,6 +2203,7 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
             transaction: transaction,
             readonly: false,
             returnMode: mRetMode,
+            isSQL92: isSQL92
           });
         }
         // reorder rows for ios
@@ -2081,6 +2220,7 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
     set: capSQLiteSet[],
     transaction = true,
     returnMode = 'no',
+    isSQL92 = true
   ): Promise<capSQLiteChanges> {
     let res: any;
     try {
@@ -2091,6 +2231,7 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
           transaction: transaction,
           readonly: false,
           returnMode: returnMode,
+          isSQL92: isSQL92
         });
         //      }
         // reorder rows for ios
@@ -2197,12 +2338,13 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
       return Promise.reject(err);
     }
   }
-  async exportToJson(mode: string): Promise<capSQLiteJson> {
+  async exportToJson(mode: string, encrypted = false): Promise<capSQLiteJson> {
     try {
       const res: any = await this.sqlite.exportToJson({
         database: this.dbName,
         jsonexportmode: mode,
         readonly: this.readonly,
+        encrypted: encrypted,
       });
       return Promise.resolve(res);
     } catch (err) {
@@ -2226,18 +2368,26 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
   }
 
   async executeTransaction(
-    txn: { statement: string; values?: any[] }[],
-  ): Promise<void> {
-    try {
-      if (!this.readonly) {
-        const ret = await this.sqlite.execute({
-          database: this.dbName,
-          statements: 'BEGIN TRANSACTION;',
-          transaction: false,
+    txn: { statement: string; values?: any[]}[],
+    isSQL92 = true 
+  ): Promise<capSQLiteChanges> {
+    let changes = 0;
+    let isActive = false;
+    if (!this.readonly) {
+      try {
+          await this.sqlite.beginTransaction({
+          database: this.dbName
         });
-        if (ret.changes.changes < 0) {
-          return Promise.reject('Error in BEGIN TRANSACTION');
+        isActive = await this.sqlite.isTransactionActive({
+          database: this.dbName
+        });
+        if(!isActive) {
+          return Promise.reject('After Begin Transaction, no transaction active');
         }
+      } catch (err) {
+        return Promise.reject(err);
+      }
+      try {
         for (const task of txn) {
           if (task.values && task.values.length > 0) {
             const retMode = task.statement.toUpperCase().includes('RETURNING')
@@ -2250,11 +2400,12 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
               transaction: false,
               readonly: false,
               returnMode: retMode,
+              isSQL92: isSQL92
             });
-            if (ret.changes.lastId === -1) {
-              await this.execute('ROLLBACK;', false);
-              return Promise.reject('Error in transaction run ');
+            if (ret.changes.changes <= 0) {
+              throw new Error('Error in transaction method run ');
             }
+            changes += ret.changes.changes;
           } else {
             const ret = await this.sqlite.execute({
               database: this.dbName,
@@ -2262,37 +2413,43 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
               transaction: false,
               readonly: false,
             });
+            isActive = await this.sqlite.isTransactionActive({
+              database: this.dbName
+            });
             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 ');
+              throw new Error('Error in transaction method execute ');
             }
+            changes += ret.changes.changes;
           }
         }
-        await this.sqlite.execute({
-          database: this.dbName,
-          statements: 'COMMIT;',
-          transaction: false,
-          readonly: false,
+        isActive = await this.sqlite.isTransactionActive({
+          database: this.dbName
         });
-        return Promise.resolve();
-      } else {
-        return Promise.reject('not allowed in read-only mode');
+        if(isActive) {
+          const retC = await this.sqlite.commitTransaction({
+            database: this.dbName
+          });
+          changes += retC.changes.changes;
+        }
+        const retChanges = {changes:{changes:changes}}
+        return Promise.resolve(retChanges);
+      } catch (err: any) {
+        const msg = err.message ? err.message : err;
+        isActive = await this.sqlite.isTransactionActive({
+          database: this.dbName
+        });
+        if(isActive) {
+          await this.sqlite.rollbackTransaction({
+            database: this.dbName,
+          });
+        }
+        return Promise.reject(msg);
       }
-    } catch (err: any) {
-      await this.sqlite.execute({
-        database: this.dbName,
-        statements: 'ROLLBACK;',
-        transaction: false,
-        readonly: false,
-      });
-      return Promise.reject(err);
+   
+    } else {
+        return Promise.reject('not allowed in read-only mode');
     }
-  }
+ }
   private async reorderRows(res: any): Promise<any> {
     const retRes: any = res;
     if (res?.values && typeof res.values[0] === 'object') {

package/src/web.ts

@@ -205,6 +205,54 @@ export class CapacitorSQLiteWeb
       throw new Error(`${err}`);
     }
   }
+  async beginTransaction(options: capSQLiteOptions): Promise<capSQLiteChanges> {
+    this.ensureJeepSqliteIsAvailable();
+    this.ensureWebstoreIsOpen();
+
+    try {
+      const changes: capSQLiteChanges =
+        await this.jeepSqliteElement.beginTransaction(options);
+      return changes;
+    } catch (err) {
+      throw new Error(`${err}`);
+    }
+  }
+  async commitTransaction(options: capSQLiteOptions): Promise<capSQLiteChanges> {
+    this.ensureJeepSqliteIsAvailable();
+    this.ensureWebstoreIsOpen();
+
+    try {
+      const changes: capSQLiteChanges =
+        await this.jeepSqliteElement.commitTransaction(options);
+      return changes;
+    } catch (err) {
+      throw new Error(`${err}`);
+    }
+  }
+  async rollbackTransaction(options: capSQLiteOptions): Promise<capSQLiteChanges> {
+    this.ensureJeepSqliteIsAvailable();
+    this.ensureWebstoreIsOpen();
+
+    try {
+      const changes: capSQLiteChanges =
+        await this.jeepSqliteElement.rollbackTransaction(options);
+      return changes;
+    } catch (err) {
+      throw new Error(`${err}`);
+    }
+  }
+  async isTransactionActive(options: capSQLiteOptions): Promise<capSQLiteResult> {
+    this.ensureJeepSqliteIsAvailable();
+    this.ensureWebstoreIsOpen();
+
+    try {
+      const result: capSQLiteResult =
+        await this.jeepSqliteElement.isTransactionActive(options);
+      return result;
+    } catch (err) {
+      throw new Error(`${err}`);
+    }
+  } 
 
   async getTableList(options: capSQLiteOptions): Promise<capSQLiteValues> {
     this.ensureJeepSqliteIsAvailable();