fix: maintain the support for v4 quick-sqlite to avoind breaking change

Author: vishalnarkhede

package/src/store/QuickSqliteClient.ts

@@ -11,13 +11,16 @@ try {
 }
 
 import { DB_LOCATION, DB_NAME } from './constants';
+import { QuickSqliteClient_v4 } from './QuickSqliteClient_v4';
 import { tables } from './schema';
 import { createCreateTableQuery } from './sqlite-utils/createCreateTableQuery';
 import type { PreparedQueries, Table } from './types';
 
 /**
  * QuickSqliteClient takes care of any direct interaction with sqlite.
  * This way usage react-native-quick-sqlite package is scoped to a single class/file.
+ *
+ * TODO: Drop the support for v4 of react-native-quick-sqlite in the next major release.
  */
 export class QuickSqliteClient {
   static dbVersion = 3;
@@ -29,7 +32,16 @@ export class QuickSqliteClient {
   // Force a specific db version. This is mainly useful for testsuit.
   static setDbVersion = (version: number) => (this.dbVersion = version);
 
+  // @ts-ignore
+  static isQuickSqliteV4 = sqlite.executeSql ? true : false;
+
+  // print if legacy version
   static openDB = () => {
+    if (this.isQuickSqliteV4) {
+      QuickSqliteClient_v4.openDB();
+      return;
+    }
+
     try {
       sqlite.open(this.dbName, this.dbLocation);
       sqlite.execute(this.dbName, `PRAGMA foreign_keys = ON`, []);
@@ -39,6 +51,11 @@ export class QuickSqliteClient {
   };
 
   static closeDB = () => {
+    if (this.isQuickSqliteV4) {
+      QuickSqliteClient_v4.closeDB();
+      return;
+    }
+
     try {
       sqlite.close(this.dbName);
     } catch (e) {
@@ -48,10 +65,16 @@ export class QuickSqliteClient {
 
   static executeSqlBatch = (queries: PreparedQueries[]) => {
     if (!queries || !queries.length) return;
-    this.openDB();
 
+    if (this.isQuickSqliteV4) {
+      QuickSqliteClient_v4.executeSqlBatch(queries);
+      return;
+    }
+
+    this.openDB();
     try {
       sqlite.executeBatch(DB_NAME, queries);
+
       this.closeDB();
     } catch (e) {
       this.closeDB();
@@ -62,6 +85,10 @@ export class QuickSqliteClient {
   static executeSql = (query: string, params?: string[]) => {
     this.openDB();
 
+    if (this.isQuickSqliteV4) {
+      return QuickSqliteClient_v4.executeSql(query, params);
+    }
+
     try {
       const { rows } = sqlite.execute(DB_NAME, query, params);
       this.closeDB();
@@ -83,6 +110,10 @@ export class QuickSqliteClient {
   };
 
   static deleteDatabase = () => {
+    if (this.isQuickSqliteV4) {
+      return QuickSqliteClient_v4.deleteDatabase();
+    }
+
     try {
       sqlite.delete(this.dbName, this.dbLocation);
     } catch (e) {
@@ -100,6 +131,14 @@ export class QuickSqliteClient {
       );
     }
 
+    if (this.isQuickSqliteV4) {
+      console.warn(
+        'You seem to be using an older version of "react-native-quick-sqlite" dependency,',
+        'and we are going to drop support for it in the next major release.',
+        'Please upgrade to the version v5 of "react-native-quick-sqlite" to avoid any issues.',
+      );
+    }
+
     const version = this.getUserPragmaVersion();
 
     if (version !== this.dbVersion) {
@@ -118,16 +157,22 @@ export class QuickSqliteClient {
   };
 
   static updateUserPragmaVersion = (version: number) => {
-    this.openDB();
+    if (this.isQuickSqliteV4) {
+      QuickSqliteClient_v4.updateUserPragmaVersion(version);
+      return;
+    }
 
+    this.openDB();
     sqlite.execute(DB_NAME, `PRAGMA user_version = ${version}`, []);
-
     this.closeDB();
   };
 
   static getUserPragmaVersion = () => {
-    this.openDB();
+    if (this.isQuickSqliteV4) {
+      return QuickSqliteClient_v4.getUserPragmaVersion();
+    }
 
+    this.openDB();
     try {
       const { rows } = sqlite.execute(DB_NAME, `PRAGMA user_version`, []);
       const result = rows ? rows._array : [];

package/src/store/QuickSqliteClient_v4.ts

@@ -0,0 +1,98 @@
+// We are going to disable type checks for this file, since this QuickSqliteClient is for legacy version of sqlite but
+// dev-dependency "react-native-quick-sqlite" is not available for legacy version of sqlite.
+/* eslint-disable no-underscore-dangle */
+// @ts-nocheck
+
+import type { QuickSQLite } from 'react-native-quick-sqlite';
+let sqlite: typeof QuickSQLite;
+
+try {
+  sqlite = require('react-native-quick-sqlite').QuickSQLite;
+} catch (e) {
+  // Failed for one of the reason
+  // 1. Running on expo, where we don't support offline storage yet.
+  // 2. Offline support is disabled, in which case this library is not installed.
+}
+import { DB_LOCATION, DB_NAME, DB_STATUS_ERROR } from './constants';
+import type { PreparedQueries } from './types';
+
+// QuickSqliteClient takes care of any direct interaction with sqlite for v4 of react-native-quick-sqlite.
+// This is to avoid any breaking changes for users using v4 of react-native-quick-sqlite.
+export class QuickSqliteClient_v4 {
+  static dbName = DB_NAME;
+  static dbLocation = DB_LOCATION;
+
+  static openDB = () => {
+    const { message, status } = sqlite.open(this.dbName, this.dbLocation);
+    sqlite.executeSql(this.dbName, `PRAGMA foreign_keys = ON`, []);
+
+    if (status === DB_STATUS_ERROR) {
+      console.error(`Error opening database ${this.dbName}: ${message}`);
+    }
+  };
+
+  static closeDB = () => {
+    const { message, status } = sqlite.close(this.dbName);
+
+    if (status === DB_STATUS_ERROR) {
+      console.error(`Error closing database ${this.dbName}: ${message}`);
+    }
+  };
+
+  static executeSqlBatch = (queries: PreparedQueries[]) => {
+    this.openDB();
+
+    const res = sqlite.executeSqlBatch(DB_NAME, queries);
+
+    if (res.status === 1) {
+      console.error(`Query/queries failed: ${res.message} ${JSON.stringify(res)}`);
+    }
+
+    this.closeDB();
+  };
+
+  static executeSql = (query: string, params?: string[]) => {
+    this.openDB();
+
+    const { message, rows, status } = sqlite.executeSql(DB_NAME, query, params);
+
+    this.closeDB();
+
+    if (status === 1) {
+      console.error(`Query/queries failed: ${message}: `, query);
+    }
+
+    return rows ? rows._array : [];
+  };
+
+  static deleteDatabase = () => {
+    const { message, status } = sqlite.delete(this.dbName, this.dbLocation);
+    if (status === DB_STATUS_ERROR) {
+      throw new Error(`Error deleting DB: ${message}`);
+    }
+
+    return true;
+  };
+
+  static updateUserPragmaVersion = (version: number) => {
+    this.openDB();
+
+    sqlite.executeSql(DB_NAME, `PRAGMA user_version = ${version}`, []);
+
+    this.closeDB();
+  };
+
+  static getUserPragmaVersion = () => {
+    this.openDB();
+
+    const { message, rows, status } = sqlite.executeSql(DB_NAME, `PRAGMA user_version`, []);
+
+    this.closeDB();
+    if (status === 1) {
+      console.error(`Querying for user_version failed: ${message}`);
+    }
+
+    const result = rows ? rows._array : [];
+    return result[0].user_version as number;
+  };
+}