stream-chat-react-native-core 5.40.0-rc.2 → 5.41.0-beta.1

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

@@ -2,104 +2,106 @@ import Sqlite3 from 'better-sqlite3';
 
 import type { PreparedQueries } from '../../store/types';
 
-let db: Sqlite3.Database;
+export let db: Sqlite3.Database;
 
 export const sqliteMock = {
-  open: () => {
-    db = new Sqlite3('foobar.db');
+  close: () => {
+    db.close();
     return {
-      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[] = [];
+      message: '',
+      status: 0,
+    };
+  },
+  execute: (dbName: string, 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);
-              } else {
-                return p;
-              }
-            });
-            result = stmt.all(modifiedParams);
+    if (query.indexOf('select') === 0) {
+      if (params) {
+        const modifiedParams = params.map((p) => {
+          if (typeof p == 'boolean') {
+            return Number(p);
           } else {
-            result = stmt.all();
+            return p;
           }
+        });
+        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,
-          },
-          status: 0,
-        };
+    return {
+      message: '',
+      rows: {
+        _array: result,
       },
-      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);
+      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);
           } else {
-            stmt.run();
+            return p;
           }
         });
 
-        return {
-          message: '',
-          staus: 0,
-        };
-      },
+        stmt.run(modifiedParams);
+      } else {
+        stmt.run();
+      }
+    });
+
+    return {
+      message: '',
+      staus: 0,
+    };
+  },
+  open: () => {
+    db = new Sqlite3('foobar.db');
+    return {
+      message: '',
+      status: 0,
     };
   },
 };

package/src/native.ts

@@ -1,6 +1,8 @@
 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 = () => {
@@ -25,8 +27,6 @@ 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,6 +46,18 @@ 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;
@@ -283,6 +295,7 @@ type Handlers = {
   getLocalAssetUri?: GetLocalAssetUri;
   getPhotos?: GetPhotos;
   iOS14RefreshGallerySelection?: iOS14RefreshGallerySelection;
+  NetInfo?: NetInfo;
   oniOS14GalleryLibrarySelectionChange?: OniOS14LibrarySelectionChange;
   pickDocument?: PickDocument;
   pickImage?: PickImage;
@@ -297,7 +310,7 @@ type Handlers = {
 };
 
 export const registerNativeHandlers = (handlers: Handlers) => {
-  if (handlers.Audio !== undefined) {
+  if (handlers.Audio) {
     Audio = handlers.Audio;
   }
 
@@ -305,13 +318,16 @@ export const registerNativeHandlers = (handlers: Handlers) => {
     compressImage = handlers.compressImage;
   }
 
-  if (handlers.deleteFile !== undefined) {
+  if (handlers.deleteFile) {
     deleteFile = handlers.deleteFile;
   }
 
-  if (handlers.FlatList !== undefined) {
+  if (handlers.FlatList) {
     FlatList = handlers.FlatList;
   }
+  if (handlers.NetInfo) {
+    NetInfo = handlers.NetInfo;
+  }
 
   if (handlers.getLocalAssetUri !== undefined) {
     getLocalAssetUri = handlers.getLocalAssetUri;
@@ -337,7 +353,7 @@ export const registerNativeHandlers = (handlers: Handlers) => {
     pickImage = handlers.pickImage;
   }
 
-  if (handlers.saveFile !== undefined) {
+  if (handlers.saveFile) {
     saveFile = handlers.saveFile;
   }
 
@@ -361,7 +377,7 @@ export const registerNativeHandlers = (handlers: Handlers) => {
     triggerHaptic = handlers.triggerHaptic;
   }
 
-  if (handlers.Video !== undefined) {
+  if (handlers.Video) {
     Video = handlers.Video;
   }
 
@@ -371,14 +387,9 @@ export const registerNativeHandlers = (handlers: Handlers) => {
 };
 
 export const isImagePickerAvailable = () => !!takePhoto;
-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 isVideoPackageAvailable = () => !!Video;
+export const isAudioPackageAvailable = () => !!Sound.Player || !!Sound.initializeSound;
+export const isRecordingPackageAvailable = () => !!Audio;
 export const isImageMediaLibraryAvailable = () =>
   !!getPhotos &&
   !!iOS14RefreshGallerySelection &&

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

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