stream-chat-react-native-core 5.39.5 → 5.40.0-rc.2

package/src/mock-builders/DB/mock.ts

@@ -2,106 +2,104 @@ import Sqlite3 from 'better-sqlite3';
 
 import type { PreparedQueries } from '../../store/types';
 
-export let db: Sqlite3.Database;
+let db: Sqlite3.Database;
 
 export const sqliteMock = {
-  close: () => {
-    db.close();
+  open: () => {
+    db = new Sqlite3('foobar.db');
     return {
-      message: '',
-      status: 0,
-    };
-  },
-  execute: (dbName: string, queryInput: string, params: unknown[]) => {
-    const query = queryInput.trim().toLowerCase();
-    const stmt = db.prepare(query);
-    let result: unknown[] = [];
+      close: () => {
+        db.close();
+        return {
+          message: '',
+          status: 0,
+        };
+      },
+      execute: (queryInput: string, params: unknown[]) => {
+        const query = queryInput.trim().toLowerCase();
+        const stmt = db.prepare(query);
+        let result: unknown[] = [];
 
-    if (query.indexOf('select') === 0) {
-      if (params) {
-        const modifiedParams = params.map((p) => {
-          if (typeof p == 'boolean') {
-            return Number(p);
+        if (query.indexOf('select') === 0) {
+          if (params) {
+            const modifiedParams = params.map((p) => {
+              if (typeof p == 'boolean') {
+                return Number(p);
+              } else {
+                return p;
+              }
+            });
+            result = stmt.all(modifiedParams);
           } else {
-            return p;
+            result = stmt.all();
           }
-        });
-        result = stmt.all(modifiedParams);
-      } else {
-        result = stmt.all();
-      }
 
-      return {
-        message: '',
-        rows: {
-          _array: result,
-        },
-        status: 0,
-      };
-    }
+          return {
+            message: '',
+            rows: {
+              _array: result,
+            },
+            status: 0,
+          };
+        }
 
-    if (query.indexOf('pragma') === 0) {
-      const pragmaQueryTokens = query.split(' ');
-      if (pragmaQueryTokens[2] === '=') {
-        db.pragma(`${pragmaQueryTokens[1]} = ${pragmaQueryTokens[3]}`);
-      } else {
-        result = db.pragma(`${pragmaQueryTokens[1]}`);
-      }
+        if (query.indexOf('pragma') === 0) {
+          const pragmaQueryTokens = query.split(' ');
+          if (pragmaQueryTokens[2] === '=') {
+            db.pragma(`${pragmaQueryTokens[1]} = ${pragmaQueryTokens[3]}`);
+          } else {
+            result = db.pragma(`${pragmaQueryTokens[1]}`);
+          }
 
-      return {
-        message: '',
-        rows: {
-          _array: result,
-        },
-        status: 0,
-      };
-    }
+          return {
+            message: '',
+            rows: {
+              _array: result,
+            },
+            status: 0,
+          };
+        }
 
-    // insert or create table query
-    if (params) {
-      stmt.run(params);
-    } else {
-      stmt.run();
-    }
+        // insert or create table query
+        if (params) {
+          stmt.run(params);
+        } else {
+          stmt.run();
+        }
 
-    return {
-      message: '',
-      rows: {
-        _array: result,
+        return {
+          message: '',
+          rows: {
+            _array: result,
+          },
+          status: 0,
+        };
       },
-      status: 0,
-    };
-  },
-  executeBatch: (dbName: string, queriesArr: PreparedQueries[]) => {
-    queriesArr.forEach((queryAndParams) => {
-      const query = queryAndParams[0];
-      const params = queryAndParams[1];
-      const stmt = db.prepare(query);
-      if (params) {
-        const modifiedParams = params.map((p) => {
-          if (typeof p == 'boolean') {
-            return Number(p);
+      executeBatch: (queriesArr: PreparedQueries[]) => {
+        queriesArr.forEach((queryAndParams) => {
+          const query = queryAndParams[0];
+          const params = queryAndParams[1];
+          const stmt = db.prepare(query);
+          if (params) {
+            const modifiedParams = params.map((p) => {
+              if (typeof p == 'boolean') {
+                return Number(p);
+              } else {
+                return p;
+              }
+            });
+
+            stmt.run(modifiedParams);
           } else {
-            return p;
+            stmt.run();
           }
         });
 
-        stmt.run(modifiedParams);
-      } else {
-        stmt.run();
-      }
-    });
-
-    return {
-      message: '',
-      staus: 0,
-    };
-  },
-  open: () => {
-    db = new Sqlite3('foobar.db');
-    return {
-      message: '',
-      status: 0,
+        return {
+          message: '',
+          staus: 0,
+        };
+      },
     };
   },
 };

package/src/native.ts

@@ -1,8 +1,6 @@
 import type React from 'react';
 import { FlatList as DefaultFlatList, StyleProp, ViewStyle } from 'react-native';
 
-import type { NetInfoSubscription } from '@react-native-community/netinfo';
-
 import type { Asset, File } from './types/types';
 
 const fail = () => {
@@ -27,6 +25,8 @@ export let compressImage: CompressImage = fail;
 type DeleteFile = ({ uri }: { uri: string }) => Promise<boolean> | never;
 export let deleteFile: DeleteFile = fail;
 
+export let FlatList: typeof DefaultFlatList | undefined;
+
 type GetLocalAssetUri = (uriOrAssetId: string) => Promise<string | undefined> | never;
 export let getLocalAssetUri: GetLocalAssetUri = fail;
 
@@ -46,18 +46,6 @@ type GetPhotos = ({ after, first }: { first: number; after?: string }) =>
   | never;
 export let getPhotos: GetPhotos = fail;
 
-type NetInfo = {
-  addEventListener: (listener: (isConnected: boolean) => void) => NetInfoSubscription | never;
-  fetch: (requestedInterface?: string | undefined) => Promise<boolean> | never;
-};
-
-export let FlatList = DefaultFlatList;
-
-export let NetInfo: NetInfo = {
-  addEventListener: fail,
-  fetch: fail,
-};
-
 type PickDocument = ({ maxNumberOfFiles }: { maxNumberOfFiles?: number }) =>
   | Promise<{
       cancelled: boolean;
@@ -295,7 +283,6 @@ type Handlers = {
   getLocalAssetUri?: GetLocalAssetUri;
   getPhotos?: GetPhotos;
   iOS14RefreshGallerySelection?: iOS14RefreshGallerySelection;
-  NetInfo?: NetInfo;
   oniOS14GalleryLibrarySelectionChange?: OniOS14LibrarySelectionChange;
   pickDocument?: PickDocument;
   pickImage?: PickImage;
@@ -310,7 +297,7 @@ type Handlers = {
 };
 
 export const registerNativeHandlers = (handlers: Handlers) => {
-  if (handlers.Audio) {
+  if (handlers.Audio !== undefined) {
     Audio = handlers.Audio;
   }
 
@@ -318,16 +305,13 @@ export const registerNativeHandlers = (handlers: Handlers) => {
     compressImage = handlers.compressImage;
   }
 
-  if (handlers.deleteFile) {
+  if (handlers.deleteFile !== undefined) {
     deleteFile = handlers.deleteFile;
   }
 
-  if (handlers.FlatList) {
+  if (handlers.FlatList !== undefined) {
     FlatList = handlers.FlatList;
   }
-  if (handlers.NetInfo) {
-    NetInfo = handlers.NetInfo;
-  }
 
   if (handlers.getLocalAssetUri !== undefined) {
     getLocalAssetUri = handlers.getLocalAssetUri;
@@ -353,7 +337,7 @@ export const registerNativeHandlers = (handlers: Handlers) => {
     pickImage = handlers.pickImage;
   }
 
-  if (handlers.saveFile) {
+  if (handlers.saveFile !== undefined) {
     saveFile = handlers.saveFile;
   }
 
@@ -377,7 +361,7 @@ export const registerNativeHandlers = (handlers: Handlers) => {
     triggerHaptic = handlers.triggerHaptic;
   }
 
-  if (handlers.Video) {
+  if (handlers.Video !== undefined) {
     Video = handlers.Video;
   }
 
@@ -387,9 +371,14 @@ export const registerNativeHandlers = (handlers: Handlers) => {
 };
 
 export const isImagePickerAvailable = () => !!takePhoto;
-export const isVideoPackageAvailable = () => !!Video;
-export const isAudioPackageAvailable = () => !!Sound.Player || !!Sound.initializeSound;
-export const isRecordingPackageAvailable = () => !!Audio;
+export const isDocumentPickerAvailable = () => !!pickDocument;
+export const isClipboardAvailable = () => !!setClipboardString;
+export const isVideoPlayerAvailable = () => !!Video;
+export const isHapticFeedbackAvailable = () => !!triggerHaptic;
+export const isShareImageAvailable = () => !!shareImage;
+export const isFileSystemAvailable = () => !!saveFile || !!deleteFile;
+export const isAudioRecorderAvailable = () => !!Audio.startRecording;
+export const isSoundPackageAvailable = () => !!Sound.Player || !!Sound.initializeSound;
 export const isImageMediaLibraryAvailable = () =>
   !!getPhotos &&
   !!iOS14RefreshGallerySelection &&

package/src/store/{QuickSqliteClient.ts → SqliteClient.ts}

@@ -1,12 +1,12 @@
 /* eslint-disable no-underscore-dangle */
-import type { QuickSQLite } from 'react-native-quick-sqlite';
-let sqlite: typeof QuickSQLite;
+import type { DB, OPSQLite } from '@op-engineering/op-sqlite';
+let sqlite: typeof OPSQLite;
 
 try {
-  sqlite = require('react-native-quick-sqlite').QuickSQLite;
+  sqlite = require('@op-engineering/op-sqlite');
 } catch (e) {
   // We want to throw the original error when remote debugger (e.g. Chrome) is enabled.
-  // QuickSQLite can only be used when synchronous method invocations (JSI) are possible.
+  // SQLite can only be used when synchronous method invocations (JSI) are possible.
   // e.g on-device debugger (e.g. Flipper).
   const isRemoteDebuggerError = e instanceof Error && e.message.includes('Failed to install');
   if (isRemoteDebuggerError) {
@@ -25,54 +25,68 @@ 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.
- *
+ * SqliteClient takes care of any direct interaction with sqlite.
+ * This way usage @op-engineering/op-sqlite package is scoped to a single class/file.
  */
-export class QuickSqliteClient {
+export class SqliteClient {
   static dbVersion = 5;
 
   static dbName = DB_NAME;
   static dbLocation = DB_LOCATION;
   static logger: Logger | undefined;
+  static db: DB | undefined;
 
-  static getDbVersion = () => QuickSqliteClient.dbVersion;
+  static getDbVersion = () => SqliteClient.dbVersion;
   // Force a specific db version. This is mainly useful for testsuit.
-  static setDbVersion = (version: number) => (QuickSqliteClient.dbVersion = version);
+  static setDbVersion = (version: number) => (SqliteClient.dbVersion = version);
 
   static openDB = () => {
     try {
-      sqlite.open(QuickSqliteClient.dbName, QuickSqliteClient.dbLocation);
-      sqlite.execute(QuickSqliteClient.dbName, `PRAGMA foreign_keys = ON`, []);
+      if (sqlite === undefined) {
+        throw new Error(
+          'Please install "@op-engineering/op-sqlite" package to enable offline support',
+        );
+      }
+      this.db = sqlite.open({
+        location: SqliteClient.dbLocation,
+        name: SqliteClient.dbName,
+      });
+      this.db.execute(`PRAGMA foreign_keys = ON`, []);
     } catch (e) {
-      this.logger?.('error', `Error opening database ${QuickSqliteClient.dbName}`, {
+      this.logger?.('error', `Error opening database ${SqliteClient.dbName}`, {
         error: e,
       });
-      console.error(`Error opening database ${QuickSqliteClient.dbName}: ${e}`);
+      console.error(`Error opening database ${SqliteClient.dbName}: ${e}`);
     }
   };
 
   static closeDB = () => {
     try {
-      sqlite.close(QuickSqliteClient.dbName);
+      if (!this.db) {
+        throw new Error('DB is not open or initialized.');
+      }
+      this.db.close();
     } catch (e) {
-      this.logger?.('error', `Error closing database ${QuickSqliteClient.dbName}`, {
+      this.logger?.('error', `Error closing database ${SqliteClient.dbName}`, {
         error: e,
       });
-      console.error(`Error closing database ${QuickSqliteClient.dbName}: ${e}`);
+      console.error(`Error closing database ${SqliteClient.dbName}: ${e}`);
     }
   };
 
   static executeSqlBatch = (queries: PreparedQueries[]) => {
     if (!queries || !queries.length) return;
 
-    QuickSqliteClient.openDB();
+    SqliteClient.openDB();
     try {
-      sqlite.executeBatch(DB_NAME, queries);
+      if (!this.db) {
+        throw new Error('DB is not open or initialized.');
+      }
+      this.db.executeBatch(queries);
 
-      QuickSqliteClient.closeDB();
+      SqliteClient.closeDB();
     } catch (e) {
-      QuickSqliteClient.closeDB();
+      SqliteClient.closeDB();
       this.logger?.('error', `SqlBatch queries failed`, {
         error: e,
         queries,
@@ -83,13 +97,16 @@ export class QuickSqliteClient {
 
   static executeSql = (query: string, params?: string[]) => {
     try {
-      QuickSqliteClient.openDB();
-      const { rows } = sqlite.execute(DB_NAME, query, params);
-      QuickSqliteClient.closeDB();
+      SqliteClient.openDB();
+      if (!this.db) {
+        throw new Error('DB is not open or initialized.');
+      }
+      const { rows } = this.db.execute(query, params);
+      SqliteClient.closeDB();
 
       return rows ? rows._array : [];
     } catch (e) {
-      QuickSqliteClient.closeDB();
+      SqliteClient.closeDB();
       this.logger?.('error', `Sql single query failed`, {
         error: e,
         query,
@@ -106,20 +123,23 @@ export class QuickSqliteClient {
     this.logger?.('info', `Dropping tables`, {
       tables: Object.keys(tables),
     });
-    QuickSqliteClient.executeSqlBatch(queries);
+    SqliteClient.executeSqlBatch(queries);
   };
 
   static deleteDatabase = () => {
     this.logger?.('info', `deleteDatabase`, {
-      dbLocation: QuickSqliteClient.dbLocation,
-      dbname: QuickSqliteClient.dbName,
+      dbLocation: SqliteClient.dbLocation,
+      dbname: SqliteClient.dbName,
     });
     try {
-      sqlite.delete(QuickSqliteClient.dbName, QuickSqliteClient.dbLocation);
+      if (!this.db) {
+        throw new Error('DB is not open or initialized.');
+      }
+      this.db.delete();
     } catch (e) {
       this.logger?.('error', `Error deleting DB`, {
-        dbLocation: QuickSqliteClient.dbLocation,
-        dbname: QuickSqliteClient.dbName,
+        dbLocation: SqliteClient.dbLocation,
+        dbname: SqliteClient.dbName,
         error: e,
       });
       throw new Error(`Error deleting DB: ${e}`);
@@ -129,20 +149,15 @@ export class QuickSqliteClient {
   };
 
   static initializeDatabase = () => {
-    if (sqlite === undefined) {
-      throw new Error(
-        'Please install "react-native-quick-sqlite" package to enable offline support',
-      );
-    }
+    SqliteClient.openDB();
+    const version = SqliteClient.getUserPragmaVersion();
 
-    const version = QuickSqliteClient.getUserPragmaVersion();
-
-    if (version !== QuickSqliteClient.dbVersion) {
-      QuickSqliteClient.logger?.('info', `DB version mismatch`);
-      QuickSqliteClient.dropTables();
-      QuickSqliteClient.updateUserPragmaVersion(QuickSqliteClient.dbVersion);
+    if (version !== SqliteClient.dbVersion) {
+      SqliteClient.logger?.('info', `DB version mismatch`);
+      SqliteClient.dropTables();
+      SqliteClient.updateUserPragmaVersion(SqliteClient.dbVersion);
     }
-    QuickSqliteClient.logger?.('info', `create tables if not exists`, {
+    SqliteClient.logger?.('info', `create tables if not exists`, {
       tables: Object.keys(tables),
     });
     const q = (Object.keys(tables) as Table[]).reduce<PreparedQueries[]>(
@@ -153,35 +168,40 @@ export class QuickSqliteClient {
       [],
     );
 
-    QuickSqliteClient.executeSqlBatch(q);
+    SqliteClient.executeSqlBatch(q);
   };
 
   static updateUserPragmaVersion = (version: number) => {
-    QuickSqliteClient.logger?.('info', `updateUserPragmaVersion to ${version}`);
-    QuickSqliteClient.openDB();
-    sqlite.execute(DB_NAME, `PRAGMA user_version = ${version}`, []);
-    QuickSqliteClient.closeDB();
+    SqliteClient.logger?.('info', `updateUserPragmaVersion to ${version}`);
+    SqliteClient.openDB();
+    if (!this.db) {
+      throw new Error('DB is not open or initialized.');
+    }
+    this.db.execute(`PRAGMA user_version = ${version}`, []);
+    SqliteClient.closeDB();
   };
 
   static getUserPragmaVersion = () => {
-    QuickSqliteClient.openDB();
     try {
-      const { rows } = sqlite.execute(DB_NAME, `PRAGMA user_version`, []);
+      if (!this.db) {
+        throw new Error('DB is not open or initialized.');
+      }
+      const { rows } = this.db.execute(`PRAGMA user_version`, []);
       const result = rows ? rows._array : [];
       this.logger?.('info', `getUserPragmaVersion`, {
         result,
       });
-      QuickSqliteClient.closeDB();
+      SqliteClient.closeDB();
       return result[0].user_version as number;
     } catch (e) {
-      QuickSqliteClient.closeDB();
+      SqliteClient.closeDB();
       throw new Error(`Querying for user_version failed: ${e}`);
     }
   };
 
   static resetDB = () => {
     this.logger?.('info', `resetDB`);
-    QuickSqliteClient.dropTables();
-    QuickSqliteClient.initializeDatabase();
+    SqliteClient.dropTables();
+    SqliteClient.initializeDatabase();
   };
 }

package/src/store/apis/addPendingTask.ts

@@ -1,7 +1,7 @@
 import { mapTaskToStorable } from '../mappers/mapTaskToStorable';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import { SqliteClient } from '../SqliteClient';
 import type { PendingTask } from '../types';
 
 /*
@@ -15,17 +15,17 @@ export const addPendingTask = (task: PendingTask) => {
   const storable = mapTaskToStorable(task);
   const { channelId, channelType, payload, type } = storable;
   const query = createUpsertQuery('pendingTasks', storable);
-  QuickSqliteClient.logger?.('info', 'addPendingTask', {
+  SqliteClient.logger?.('info', 'addPendingTask', {
     channelId,
     channelType,
     id: task.id,
     type,
   });
 
-  QuickSqliteClient.executeSql.apply(null, query);
+  SqliteClient.executeSql.apply(null, query);
 
   return () => {
-    QuickSqliteClient.logger?.('info', 'deletePendingTaskAfterAddition', {
+    SqliteClient.logger?.('info', 'deletePendingTaskAfterAddition', {
       channelId,
       channelType,
       id: task.id,
@@ -38,6 +38,6 @@ export const addPendingTask = (task: PendingTask) => {
       type,
     });
 
-    QuickSqliteClient.executeSql.apply(null, query);
+    SqliteClient.executeSql.apply(null, query);
   };
 };

package/src/store/apis/deleteChannel.ts

@@ -1,18 +1,18 @@
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
+import { SqliteClient } from '../SqliteClient';
 
 export const deleteChannel = ({ cid, flush = true }: { cid: string; flush?: boolean }) => {
   const query = createDeleteQuery('channels', {
     cid,
   });
 
-  QuickSqliteClient.logger?.('info', 'deleteChannel', {
+  SqliteClient.logger?.('info', 'deleteChannel', {
     cid,
     flush,
   });
 
   if (flush) {
-    QuickSqliteClient.executeSql.apply(null, query);
+    SqliteClient.executeSql.apply(null, query);
   }
 
   return [query];

package/src/store/apis/deleteMember.ts

@@ -1,7 +1,7 @@
 import type { ChannelMemberResponse } from 'stream-chat';
 
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
+import { SqliteClient } from '../SqliteClient';
 
 export const deleteMember = ({
   cid,
@@ -17,14 +17,14 @@ export const deleteMember = ({
     userId: member.user_id,
   });
 
-  QuickSqliteClient.logger?.('info', 'deleteMember', {
+  SqliteClient.logger?.('info', 'deleteMember', {
     cid,
     flush,
     userId: member.user_id,
   });
 
   if (flush) {
-    QuickSqliteClient.executeSql.apply(null, query);
+    SqliteClient.executeSql.apply(null, query);
   }
 
   return [query];

package/src/store/apis/deleteMessage.ts

@@ -1,18 +1,18 @@
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
+import { SqliteClient } from '../SqliteClient';
 
 export const deleteMessage = ({ flush = true, id }: { id: string; flush?: boolean }) => {
   const query = createDeleteQuery('messages', {
     id,
   });
 
-  QuickSqliteClient.logger?.('info', 'deleteMessage', {
+  SqliteClient.logger?.('info', 'deleteMessage', {
     flush,
     id,
   });
 
   if (flush) {
-    QuickSqliteClient.executeSql.apply(null, query);
+    SqliteClient.executeSql.apply(null, query);
   }
 
   return [query];

package/src/store/apis/deleteMessagesForChannel.ts

@@ -1,5 +1,5 @@
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
+import { SqliteClient } from '../SqliteClient';
 
 export const deleteMessagesForChannel = ({
   cid,
@@ -12,13 +12,13 @@ export const deleteMessagesForChannel = ({
     cid,
   });
 
-  QuickSqliteClient.logger?.('info', 'deleteMessagesForChannel', {
+  SqliteClient.logger?.('info', 'deleteMessagesForChannel', {
     cid,
     flush,
   });
 
   if (flush) {
-    QuickSqliteClient.executeSql.apply(null, query);
+    SqliteClient.executeSql.apply(null, query);
   }
 
   return [query];