stream-chat-react-native-core 5.44.2-beta.1 → 6.0.0-beta.1

package/src/store/SqliteClient.ts

@@ -0,0 +1,210 @@
+import type { DB, OPSQLite } from '@op-engineering/op-sqlite';
+let sqlite: typeof OPSQLite;
+
+try {
+  sqlite = require('@op-engineering/op-sqlite');
+} 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.
+  // e.g on-device debugger (e.g. Flipper).
+  const isRemoteDebuggerError = e instanceof Error && e.message.includes('Failed to install');
+  if (isRemoteDebuggerError) {
+    throw e;
+  }
+  // Reaching here will mean that QuickSQLite is not installed for one of the reasons
+  // 1. Running on regular expo, where we don't support offline storage yet.
+  // 2. Offline support is disabled, in which case this library is not installed.
+}
+
+import { Logger } from 'stream-chat';
+
+import { DB_LOCATION, DB_NAME } from './constants';
+import { tables } from './schema';
+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.
+ */
+export class SqliteClient {
+  static dbVersion = 7;
+
+  static dbName = DB_NAME;
+  static dbLocation = DB_LOCATION;
+  static logger: Logger | undefined;
+  static db: DB | undefined;
+
+  static getDbVersion = () => SqliteClient.dbVersion;
+  // Force a specific db version. This is mainly useful for testsuit.
+  static setDbVersion = (version: number) => (SqliteClient.dbVersion = version);
+
+  static openDB = async () => {
+    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,
+      });
+
+      await this.db.execute(`PRAGMA foreign_keys = ON`, []);
+    } catch (e) {
+      this.logger?.('error', `Error opening database ${SqliteClient.dbName}`, {
+        error: e,
+      });
+      console.error(`Error opening database ${SqliteClient.dbName}: ${e}`);
+    }
+  };
+
+  static closeDB = () => {
+    try {
+      if (!this.db) {
+        throw new Error('DB is not open or initialized.');
+      }
+      this.db.close();
+      this.db = undefined;
+    } catch (e) {
+      this.logger?.('error', `Error closing database ${SqliteClient.dbName}`, {
+        error: e,
+      });
+      console.error(`Error closing database ${SqliteClient.dbName}: ${e}`);
+    }
+  };
+
+  static executeSqlBatch = async (queries: PreparedQueries[]) => {
+    if (!queries || !queries.length) return;
+
+    try {
+      if (!this.db) {
+        throw new Error('DB is not open or initialized.');
+      }
+      await this.db.executeBatch(queries);
+    } catch (e) {
+      this.logger?.('error', `SqlBatch queries failed`, {
+        error: e,
+        queries,
+      });
+      throw new Error(`Queries failed: ${e}`);
+    }
+  };
+
+  static executeSql = async (query: string, params?: string[]) => {
+    try {
+      if (!this.db) {
+        throw new Error('DB is not open or initialized.');
+      }
+      const { rows } = await this.db.execute(query, params);
+
+      return rows ? rows : [];
+    } catch (e) {
+      this.logger?.('error', `Sql single query failed`, {
+        error: e,
+        query,
+      });
+      throw new Error(`Query failed: ${e}: `);
+    }
+  };
+
+  static dropTables = async () => {
+    const queries: PreparedQueries[] = Object.keys(tables).map((table) => [
+      `DROP TABLE IF EXISTS ${table}`,
+      [],
+    ]);
+    this.logger?.('info', `Dropping tables`, {
+      tables: Object.keys(tables),
+    });
+    await SqliteClient.executeSqlBatch(queries);
+  };
+
+  static deleteDatabase = () => {
+    this.logger?.('info', `deleteDatabase`, {
+      dbLocation: SqliteClient.dbLocation,
+      dbname: SqliteClient.dbName,
+    });
+    try {
+      if (!this.db) {
+        throw new Error('DB is not open or initialized.');
+      }
+      this.db.delete();
+    } catch (e) {
+      this.logger?.('error', `Error deleting DB`, {
+        dbLocation: SqliteClient.dbLocation,
+        dbname: SqliteClient.dbName,
+        error: e,
+      });
+      throw new Error(`Error deleting DB: ${e}`);
+    }
+
+    return true;
+  };
+
+  static initializeDatabase = async () => {
+    try {
+      await SqliteClient.openDB();
+      const version = await SqliteClient.getUserPragmaVersion();
+
+      if (version !== SqliteClient.dbVersion) {
+        SqliteClient.logger?.('info', `DB version mismatch`);
+        await SqliteClient.dropTables();
+        await SqliteClient.updateUserPragmaVersion(SqliteClient.dbVersion);
+      }
+      SqliteClient.logger?.('info', `create tables if not exists`, {
+        tables: Object.keys(tables),
+      });
+      const q = (Object.keys(tables) as Table[]).reduce<PreparedQueries[]>(
+        (queriesSoFar, tableName) => {
+          queriesSoFar.push(...createCreateTableQuery(tableName));
+          return queriesSoFar;
+        },
+        [],
+      );
+
+      await SqliteClient.executeSqlBatch(q);
+    } catch (e) {
+      console.log('Error initializing DB', e);
+      this.logger?.('error', `Error initializing DB`, {
+        dbLocation: SqliteClient.dbLocation,
+        dbname: SqliteClient.dbName,
+        error: e,
+      });
+    }
+  };
+
+  static updateUserPragmaVersion = async (version: number) => {
+    SqliteClient.logger?.('info', `updateUserPragmaVersion to ${version}`);
+    if (!this.db) {
+      throw new Error('DB is not open or initialized.');
+    }
+    await this.db.execute(`PRAGMA user_version = ${version}`, []);
+  };
+
+  static getUserPragmaVersion = async () => {
+    try {
+      if (!this.db) {
+        throw new Error('DB is not open or initialized.');
+      }
+      const { rows } = await this.db.execute(`PRAGMA user_version`, []);
+      const result = rows ? rows : [];
+      this.logger?.('info', `getUserPragmaVersion`, {
+        result,
+      });
+      return result[0].user_version as number;
+    } catch (e) {
+      console.log('Error getting user_version', e);
+      throw new Error(`Querying for user_version failed: ${e}`);
+    }
+  };
+
+  static resetDB = async () => {
+    this.logger?.('info', `resetDB`);
+    if (this.db) {
+      await SqliteClient.dropTables();
+      SqliteClient.closeDB();
+    }
+    await 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';
 
 /*
@@ -11,21 +11,21 @@ import type { PendingTask } from '../types';
  *
  * @return {() => void} - A function that can be called to remove the task from the database
  */
-export const addPendingTask = (task: PendingTask) => {
+export const addPendingTask = async (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);
+  await SqliteClient.executeSql.apply(null, query);
 
-  return () => {
-    QuickSqliteClient.logger?.('info', 'deletePendingTaskAfterAddition', {
+  return async () => {
+    SqliteClient.logger?.('info', 'deletePendingTaskAfterAddition', {
       channelId,
       channelType,
       id: task.id,
@@ -38,6 +38,6 @@ export const addPendingTask = (task: PendingTask) => {
       type,
     });
 
-    QuickSqliteClient.executeSql.apply(null, query);
+    await 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 }) => {
+export const deleteChannel = async ({ 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);
+    await SqliteClient.executeSql.apply(null, query);
   }
 
   return [query];

package/src/store/apis/deleteMember.ts

@@ -1,9 +1,9 @@
 import type { ChannelMemberResponse } from 'stream-chat';
 
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const deleteMember = ({
+export const deleteMember = async ({
   cid,
   flush = true,
   member,
@@ -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);
+    await 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 }) => {
+export const deleteMessage = async ({ 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);
+    await SqliteClient.executeSql.apply(null, query);
   }
 
   return [query];

package/src/store/apis/deleteMessagesForChannel.ts

@@ -1,7 +1,7 @@
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const deleteMessagesForChannel = ({
+export const deleteMessagesForChannel = async ({
   cid,
   flush = true,
 }: {
@@ -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);
+    await SqliteClient.executeSql.apply(null, query);
   }
 
   return [query];

package/src/store/apis/deletePendingTask.ts

@@ -1,16 +1,16 @@
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const deletePendingTask = ({ id }: { id: number }) => {
+export const deletePendingTask = async ({ id }: { id: number }) => {
   const query = createDeleteQuery('pendingTasks', {
     id,
   });
 
-  QuickSqliteClient.logger?.('info', 'deletePendingTask', {
+  SqliteClient.logger?.('info', 'deletePendingTask', {
     id,
   });
 
-  QuickSqliteClient.executeSql.apply(null, query);
+  await SqliteClient.executeSql.apply(null, query);
 
   return [query];
 };

package/src/store/apis/deleteReaction.ts

@@ -1,7 +1,7 @@
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const deleteReaction = ({
+export const deleteReaction = async ({
   flush = true,
   messageId,
   reactionType,
@@ -18,14 +18,14 @@ export const deleteReaction = ({
     userId,
   });
 
-  QuickSqliteClient.logger?.('info', 'deleteReaction', {
+  SqliteClient.logger?.('info', 'deleteReaction', {
     messageId,
     type: reactionType,
     userId,
   });
 
   if (flush) {
-    QuickSqliteClient.executeSql.apply(null, query);
+    await SqliteClient.executeSql.apply(null, query);
   }
 
   return [query];

package/src/store/apis/deleteReactions.ts

@@ -1,7 +1,7 @@
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const deleteReactionsForMessage = ({
+export const deleteReactionsForMessage = async ({
   flush = true,
   messageId,
 }: {
@@ -16,7 +16,7 @@ export const deleteReactionsForMessage = ({
     messageId,
   });
   if (flush) {
-    QuickSqliteClient.executeSql.apply(null, query);
+    await SqliteClient.executeSql.apply(null, query);
   }
 
   return [query];

package/src/store/apis/getAllChannelIds.ts

@@ -1,10 +1,10 @@
 import { selectChannels } from './queries/selectChannels';
 
-import { QuickSqliteClient } from '../QuickSqliteClient';
+import { SqliteClient } from '../SqliteClient';
 
-export const getAllChannelIds = () => {
-  const channels = selectChannels();
+export const getAllChannelIds = async () => {
+  const channels = await selectChannels();
 
-  QuickSqliteClient.logger?.('info', 'getAllChannelIds');
+  SqliteClient.logger?.('info', 'getAllChannelIds');
   return channels.map((c) => c.cid);
 };

package/src/store/apis/getAppSettings.ts

@@ -1,17 +1,17 @@
 import type { AppSettingsAPIResponse } from 'stream-chat';
 
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createSelectQuery } from '../sqlite-utils/createSelectQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const getAppSettings = ({
+export const getAppSettings = async ({
   currentUserId,
 }: {
   currentUserId: string;
-}): AppSettingsAPIResponse => {
-  QuickSqliteClient.logger?.('info', 'getAppSettings', {
+}): Promise<AppSettingsAPIResponse> => {
+  SqliteClient.logger?.('info', 'getAppSettings', {
     currentUserId,
   });
-  const result = QuickSqliteClient.executeSql.apply(
+  const result = await SqliteClient.executeSql.apply(
     null,
     createSelectQuery('userSyncStatus', ['*'], {
       userId: currentUserId,

package/src/store/apis/getChannelMessages.ts

@@ -7,11 +7,11 @@ import { selectReactionsForMessages } from './queries/selectReactionsForMessages
 import type { DefaultStreamChatGenerics } from '../../types/types';
 import { isBlockedMessage } from '../../utils/utils';
 import { mapStorableToMessage } from '../mappers/mapStorableToMessage';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createSelectQuery } from '../sqlite-utils/createSelectQuery';
+import { SqliteClient } from '../SqliteClient';
 import type { TableRow, TableRowJoinedUser } from '../types';
 
-export const getChannelMessages = <
+export const getChannelMessages = async <
   StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
 >({
   channelIds,
@@ -20,15 +20,15 @@ export const getChannelMessages = <
   channelIds: string[];
   currentUserId: string;
 }) => {
-  QuickSqliteClient.logger?.('info', 'getChannelMessages', {
+  SqliteClient.logger?.('info', 'getChannelMessages', {
     channelIds,
     currentUserId,
   });
-  const messageRows = selectMessagesForChannels(channelIds);
+  const messageRows = await selectMessagesForChannels(channelIds);
   const messageIds = messageRows.map(({ id }) => id);
 
   // Populate the message reactions.
-  const reactionRows = selectReactionsForMessages(messageIds);
+  const reactionRows = await selectReactionsForMessages(messageIds);
   const messageIdVsReactions: Record<string, TableRowJoinedUser<'reactions'>[]> = {};
   reactionRows.forEach((reaction) => {
     if (!messageIdVsReactions[reaction.messageId]) {
@@ -39,7 +39,7 @@ export const getChannelMessages = <
   const messageIdsVsPolls: Record<string, TableRow<'poll'>> = {};
   const pollsById: Record<string, TableRow<'poll'>> = {};
   const messagesWithPolls = messageRows.filter((message) => !!message.poll_id);
-  const polls = QuickSqliteClient.executeSql.apply(
+  const polls = await SqliteClient.executeSql.apply(
     null,
     createSelectQuery('poll', ['*'], {
       id: messagesWithPolls.map((message) => message.poll_id),

package/src/store/apis/getChannels.ts

@@ -7,7 +7,7 @@ import { selectChannels } from './queries/selectChannels';
 
 import type { DefaultStreamChatGenerics } from '../../types/types';
 import { mapStorableToChannel } from '../mappers/mapStorableToChannel';
-import { QuickSqliteClient } from '../QuickSqliteClient';
+import { SqliteClient } from '../SqliteClient';
 
 /**
  * Returns the list of channels with state enriched for given channel ids.
@@ -18,7 +18,7 @@ import { QuickSqliteClient } from '../QuickSqliteClient';
  *
  * @returns {Array} Channels with enriched state.
  */
-export const getChannels = <
+export const getChannels = async <
   StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
 >({
   channelIds,
@@ -26,13 +26,13 @@ export const getChannels = <
 }: {
   channelIds: string[];
   currentUserId: string;
-}): Omit<ChannelAPIResponse<StreamChatGenerics>, 'duration'>[] => {
-  QuickSqliteClient.logger?.('info', 'getChannels', { channelIds, currentUserId });
-  const channels = selectChannels({ channelIds });
+}): Promise<Omit<ChannelAPIResponse<StreamChatGenerics>, 'duration'>[]> => {
+  SqliteClient.logger?.('info', 'getChannels', { channelIds, currentUserId });
+  const channels = await selectChannels({ channelIds });
 
-  const cidVsMembers = getMembers<StreamChatGenerics>({ channelIds });
-  const cidVsReads = getReads<StreamChatGenerics>({ channelIds });
-  const cidVsMessages = getChannelMessages<StreamChatGenerics>({
+  const cidVsMembers = await getMembers<StreamChatGenerics>({ channelIds });
+  const cidVsReads = await getReads<StreamChatGenerics>({ channelIds });
+  const cidVsMessages = await getChannelMessages<StreamChatGenerics>({
     channelIds,
     currentUserId,
   });

package/src/store/apis/getChannelsForFilterSort.ts

@@ -5,7 +5,7 @@ import { selectChannelIdsForFilterSort } from './queries/selectChannelIdsForFilt
 
 import type { DefaultStreamChatGenerics } from '../../types/types';
 
-import { QuickSqliteClient } from '../QuickSqliteClient';
+import { SqliteClient } from '../SqliteClient';
 
 /**
  * Gets the channels from database for given filter and sort query.
@@ -17,7 +17,7 @@ import { QuickSqliteClient } from '../QuickSqliteClient';
  *
  * @returns Array of channels corresponding to filters & sort. Returns null if filters + sort query doesn't exist in "channelQueries" table.
  */
-export const getChannelsForFilterSort = <
+export const getChannelsForFilterSort = async <
   StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
 >({
   currentUserId,
@@ -27,15 +27,15 @@ export const getChannelsForFilterSort = <
   currentUserId: string;
   filters?: ChannelFilters<StreamChatGenerics>;
   sort?: ChannelSort<StreamChatGenerics>;
-}): Omit<ChannelAPIResponse<StreamChatGenerics>, 'duration'>[] | null => {
+}): Promise<Omit<ChannelAPIResponse<StreamChatGenerics>, 'duration'>[] | null> => {
   if (!filters && !sort) {
     console.warn('Please provide the query (filters/sort) to fetch channels from DB');
     return null;
   }
 
-  QuickSqliteClient.logger?.('info', 'getChannelsForFilterSort', { filters, sort });
+  SqliteClient.logger?.('info', 'getChannelsForFilterSort', { filters, sort });
 
-  const channelIds = selectChannelIdsForFilterSort({ filters, sort });
+  const channelIds = await selectChannelIdsForFilterSort({ filters, sort });
 
   if (!channelIds) return null;
 
@@ -43,7 +43,7 @@ export const getChannelsForFilterSort = <
     return [];
   }
 
-  return getChannels({
+  return await getChannels({
     channelIds,
     currentUserId,
   });

package/src/store/apis/getLastSyncedAt.ts

@@ -1,13 +1,13 @@
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createSelectQuery } from '../sqlite-utils/createSelectQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const getLastSyncedAt = ({
+export const getLastSyncedAt = async ({
   currentUserId,
 }: {
   currentUserId: string;
-}): number | undefined => {
-  QuickSqliteClient.logger?.('info', 'getLastSyncedAt', { currentUserId });
-  const result = QuickSqliteClient.executeSql.apply(
+}): Promise<number | undefined> => {
+  SqliteClient.logger?.('info', 'getLastSyncedAt', { currentUserId });
+  const result = await SqliteClient.executeSql.apply(
     null,
     createSelectQuery('userSyncStatus', ['*'], {
       userId: currentUserId,

package/src/store/apis/getMembers.ts

@@ -4,17 +4,17 @@ import { selectMembersForChannels } from './queries/selectMembersForChannels';
 
 import type { DefaultStreamChatGenerics } from '../../types/types';
 import { mapStorableToMember } from '../mappers/mapStorableToMember';
-import { QuickSqliteClient } from '../QuickSqliteClient';
+import { SqliteClient } from '../SqliteClient';
 
-export const getMembers = <
+export const getMembers = async <
   StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
 >({
   channelIds,
 }: {
   channelIds: string[];
 }) => {
-  QuickSqliteClient.logger?.('info', 'getMembers', { channelIds });
-  const memberRows = selectMembersForChannels(channelIds);
+  SqliteClient.logger?.('info', 'getMembers', { channelIds });
+  const memberRows = await selectMembersForChannels(channelIds);
   const cidVsMembers: Record<string, ChannelMemberResponse<StreamChatGenerics>[]> = {};
   memberRows.forEach((member) => {
     if (!cidVsMembers[member.cid]) {

package/src/store/apis/getPendingTasks.ts

@@ -1,15 +1,15 @@
 import { mapStorableToTask } from '../mappers/mapStorableToTask';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createSelectQuery } from '../sqlite-utils/createSelectQuery';
+import { SqliteClient } from '../SqliteClient';
 import type { TableRowJoinedUser } from '../types';
 
-export const getPendingTasks = (conditions: { messageId?: string } = {}) => {
+export const getPendingTasks = async (conditions: { messageId?: string } = {}) => {
   const query = createSelectQuery('pendingTasks', ['*'], conditions, {
     createdAt: 1,
   });
 
-  QuickSqliteClient.logger?.('info', 'getPendingTasks', { conditions });
-  const result = QuickSqliteClient.executeSql.apply(null, query);
+  SqliteClient.logger?.('info', 'getPendingTasks', { conditions });
+  const result = await SqliteClient.executeSql.apply(null, query);
 
   return result.map((r: TableRowJoinedUser<'pendingTasks'>) => mapStorableToTask(r));
 };

package/src/store/apis/getReactions.ts

@@ -2,7 +2,7 @@ import type { ReactionResponse } from 'stream-chat';
 
 import type { DefaultStreamChatGenerics } from '../../types/types';
 import { mapStorableToReaction } from '../mappers/mapStorableToReaction';
-import { QuickSqliteClient } from '../QuickSqliteClient';
+import { SqliteClient } from '../SqliteClient';
 import { TableRowJoinedUser } from '../types';
 
 export const getReactions = <
@@ -12,7 +12,7 @@ export const getReactions = <
 }: {
   reactions: TableRowJoinedUser<'reactions'>[];
 }): ReactionResponse<StreamChatGenerics>[] => {
-  QuickSqliteClient.logger?.('info', 'getReactions', { reactions });
+  SqliteClient.logger?.('info', 'getReactions', { reactions });
 
   // Enrich the channels with state
   return reactions.map((reaction) => ({