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

package/src/store/apis/getReactionsforFilterSort.ts

@@ -5,7 +5,7 @@ import { selectReactionsForMessages } from './queries/selectReactionsForMessages
 
 import type { DefaultStreamChatGenerics } from '../../types/types';
 
-import { QuickSqliteClient } from '../QuickSqliteClient';
+import { SqliteClient } from '../SqliteClient';
 
 /**
  * Fetches reactions for a message from the database based on the provided filters and sort.
@@ -13,7 +13,7 @@ import { QuickSqliteClient } from '../QuickSqliteClient';
  * @param filters The filters to be applied while fetching reactions.
  * @param sort The sort to be applied while fetching reactions.
  */
-export const getReactionsForFilterSort = <
+export const getReactionsForFilterSort = async <
   StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
 >({
   currentMessageId,
@@ -23,15 +23,15 @@ export const getReactionsForFilterSort = <
   currentMessageId: string;
   filters?: ReactionFilters<StreamChatGenerics>;
   sort?: ReactionSort<StreamChatGenerics>;
-}): ReactionResponse<StreamChatGenerics>[] | null => {
+}): Promise<ReactionResponse<StreamChatGenerics>[] | null> => {
   if (!filters && !sort) {
     console.warn('Please provide the query (filters/sort) to fetch channels from DB');
     return null;
   }
 
-  QuickSqliteClient.logger?.('info', 'getReactionsForFilterSort', { filters, sort });
+  SqliteClient.logger?.('info', 'getReactionsForFilterSort', { filters, sort });
 
-  const reactions = selectReactionsForMessages([currentMessageId]);
+  const reactions = await selectReactionsForMessages([currentMessageId]);
 
   if (!reactions) return null;
 
@@ -39,5 +39,7 @@ export const getReactionsForFilterSort = <
     return [];
   }
 
-  return getReactions({ reactions });
+  const filteredReactions = reactions.filter((reaction) => reaction.type === filters?.type);
+
+  return getReactions({ reactions: filteredReactions });
 };

package/src/store/apis/getReads.ts

@@ -4,17 +4,17 @@ import { selectReadsForChannels } from './queries/selectReadsForChannels';
 
 import type { DefaultStreamChatGenerics } from '../../types/types';
 import { mapStorableToRead } from '../mappers/mapStorableToRead';
-import { QuickSqliteClient } from '../QuickSqliteClient';
+import { SqliteClient } from '../SqliteClient';
 
-export const getReads = <
+export const getReads = async <
   StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
 >({
   channelIds,
 }: {
   channelIds: string[];
 }) => {
-  QuickSqliteClient.logger?.('info', 'getReads', { channelIds });
-  const reads = selectReadsForChannels(channelIds);
+  SqliteClient.logger?.('info', 'getReads', { channelIds });
+  const reads = await selectReadsForChannels(channelIds);
   const cidVsReads: Record<string, ReadResponse<StreamChatGenerics>[]> = {};
 
   reads.forEach((read) => {

package/src/store/apis/insertReaction.ts

@@ -1,12 +1,12 @@
 import type { FormatMessageResponse, MessageResponse, ReactionResponse } from 'stream-chat';
 
 import { mapReactionToStorable } from '../mappers/mapReactionToStorable';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createUpdateQuery } from '../sqlite-utils/createUpdateQuery';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import { SqliteClient } from '../SqliteClient';
 import type { PreparedQueries } from '../types';
 
-export const insertReaction = ({
+export const insertReaction = async ({
   flush = true,
   message,
   reaction,
@@ -33,13 +33,13 @@ export const insertReaction = ({
     ),
   );
 
-  QuickSqliteClient.logger?.('info', 'insertReaction', {
+  SqliteClient.logger?.('info', 'insertReaction', {
     flush,
     reaction: storableReaction,
   });
 
   if (flush) {
-    QuickSqliteClient.executeSqlBatch(queries);
+    await SqliteClient.executeSqlBatch(queries);
   }
 
   return queries;

package/src/store/apis/queries/selectChannelIdsForFilterSort.ts

@@ -1,8 +1,8 @@
 import type { ChannelFilters, ChannelSort } from 'stream-chat';
 
 import type { DefaultStreamChatGenerics } from '../../../types/types';
-import { QuickSqliteClient } from '../../QuickSqliteClient';
 import { createSelectQuery } from '../../sqlite-utils/createSelectQuery';
+import { SqliteClient } from '../../SqliteClient';
 
 import { convertFilterSortToQuery } from '../utils/convertFilterSortToQuery';
 
@@ -16,7 +16,7 @@ import { convertFilterSortToQuery } from '../utils/convertFilterSortToQuery';
  * @returns Array of channel ids corresponding to filters & sort. Returns null if filters + sort query doesn't exist in "channelQueries" table.
  */
 
-export const selectChannelIdsForFilterSort = <
+export const selectChannelIdsForFilterSort = async <
   StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
 >({
   filters,
@@ -24,14 +24,14 @@ export const selectChannelIdsForFilterSort = <
 }: {
   filters?: ChannelFilters<StreamChatGenerics>;
   sort?: ChannelSort<StreamChatGenerics>;
-}): string[] | null => {
+}): Promise<string[] | null> => {
   const query = convertFilterSortToQuery({ filters, sort });
 
-  QuickSqliteClient.logger?.('info', 'selectChannelIdsForFilterSort', {
+  SqliteClient.logger?.('info', 'selectChannelIdsForFilterSort', {
     query,
   });
 
-  const results = QuickSqliteClient.executeSql.apply(
+  const results = await SqliteClient.executeSql.apply(
     null,
     createSelectQuery('channelQueries', ['*'], {
       id: query,

package/src/store/apis/queries/selectChannels.ts

@@ -1,10 +1,10 @@
-import { QuickSqliteClient } from '../../QuickSqliteClient';
 import { createSelectQuery } from '../../sqlite-utils/createSelectQuery';
+import { SqliteClient } from '../../SqliteClient';
 import type { TableRowJoinedUser } from '../../types';
 
-export const selectChannels = ({
-  channelIds,
-}: { channelIds?: string[] } = {}): TableRowJoinedUser<'channels'>[] => {
+export const selectChannels = async ({ channelIds }: { channelIds?: string[] } = {}): Promise<
+  TableRowJoinedUser<'channels'>[]
+> => {
   const query = createSelectQuery(
     'channels',
     ['*'],
@@ -15,11 +15,11 @@ export const selectChannels = ({
       : undefined,
   );
 
-  QuickSqliteClient.logger?.('info', 'selectChannels', {
+  SqliteClient.logger?.('info', 'selectChannels', {
     channelIds,
   });
 
-  const result = QuickSqliteClient.executeSql.apply(null, query);
+  const result = await SqliteClient.executeSql.apply(null, query);
 
   if (channelIds) {
     return result.sort(

package/src/store/apis/queries/selectMembersForChannels.ts

@@ -1,9 +1,11 @@
 import type { TableRowJoinedUser } from '../../../store/types';
 
-import { QuickSqliteClient } from '../../QuickSqliteClient';
 import { tables } from '../../schema';
+import { SqliteClient } from '../../SqliteClient';
 
-export const selectMembersForChannels = (cids: string[]): TableRowJoinedUser<'members'>[] => {
+export const selectMembersForChannels = async (
+  cids: string[],
+): Promise<TableRowJoinedUser<'members'>[]> => {
   const questionMarks = Array(cids.length).fill('?').join(',');
   const membersColumnNames = Object.keys(tables.members.columns)
     .map((name) => `'${name}', a.${name}`)
@@ -12,11 +14,11 @@ export const selectMembersForChannels = (cids: string[]): TableRowJoinedUser<'me
     .map((name) => `'${name}', b.${name}`)
     .join(', ');
 
-  QuickSqliteClient.logger?.('info', 'selectMembersForChannels', {
+  SqliteClient.logger?.('info', 'selectMembersForChannels', {
     cids,
   });
 
-  const result = QuickSqliteClient.executeSql(
+  const result = await SqliteClient.executeSql(
     `SELECT
       json_object(
         'user', json_object(

package/src/store/apis/queries/selectMessagesForChannels.ts

@@ -1,8 +1,10 @@
-import { QuickSqliteClient } from '../../QuickSqliteClient';
 import { tables } from '../../schema';
+import { SqliteClient } from '../../SqliteClient';
 import type { TableRowJoinedUser } from '../../types';
 
-export const selectMessagesForChannels = (cids: string[]): TableRowJoinedUser<'messages'>[] => {
+export const selectMessagesForChannels = async (
+  cids: string[],
+): Promise<TableRowJoinedUser<'messages'>[]> => {
   const questionMarks = Array(cids.length).fill('?').join(',');
   const messagesColumnNames = Object.keys(tables.messages.columns)
     .map((name) => `'${name}', a.${name}`)
@@ -11,11 +13,11 @@ export const selectMessagesForChannels = (cids: string[]): TableRowJoinedUser<'m
     .map((name) => `'${name}', b.${name}`)
     .join(', ');
 
-  QuickSqliteClient.logger?.('info', 'selectMessagesForChannels', {
+  SqliteClient.logger?.('info', 'selectMessagesForChannels', {
     cids,
   });
 
-  const result = QuickSqliteClient.executeSql(
+  const result = await SqliteClient.executeSql(
     `SELECT
       json_object(
         'user', json_object(
@@ -35,7 +37,7 @@ export const selectMessagesForChannels = (cids: string[]): TableRowJoinedUser<'m
     ) a
     LEFT JOIN
       users b
-    ON b.id = a.userId 
+    ON b.id = a.userId
     WHERE RowNum < 200`,
     cids,
   );

package/src/store/apis/queries/selectReactionsForMessages.ts

@@ -1,14 +1,14 @@
-import { QuickSqliteClient } from '../../QuickSqliteClient';
 import { tables } from '../../schema';
+import { SqliteClient } from '../../SqliteClient';
 import type { TableRowJoinedUser } from '../../types';
 
 /**
  * Fetches reactions for a message from the database for messageIds.
  * @param messageIds The message IDs for which reactions are to be fetched.
  */
-export const selectReactionsForMessages = (
+export const selectReactionsForMessages = async (
   messageIds: string[],
-): TableRowJoinedUser<'reactions'>[] => {
+): Promise<TableRowJoinedUser<'reactions'>[]> => {
   const questionMarks = Array(messageIds.length).fill('?').join(',');
   const reactionsColumnNames = Object.keys(tables.reactions.columns)
     .map((name) => `'${name}', a.${name}`)
@@ -17,11 +17,11 @@ export const selectReactionsForMessages = (
     .map((name) => `'${name}', b.${name}`)
     .join(', ');
 
-  QuickSqliteClient.logger?.('info', 'selectReactionsForMessages', {
+  SqliteClient.logger?.('info', 'selectReactionsForMessages', {
     messageIds,
   });
 
-  const result = QuickSqliteClient.executeSql(
+  const result = await SqliteClient.executeSql(
     `SELECT
       json_object(
         'user', json_object(

package/src/store/apis/queries/selectReadsForChannels.ts

@@ -1,8 +1,10 @@
-import { QuickSqliteClient } from '../../QuickSqliteClient';
 import { tables } from '../../schema';
+import { SqliteClient } from '../../SqliteClient';
 import type { TableRowJoinedUser } from '../../types';
 
-export const selectReadsForChannels = (cids: string[]): TableRowJoinedUser<'reads'>[] => {
+export const selectReadsForChannels = async (
+  cids: string[],
+): Promise<TableRowJoinedUser<'reads'>[]> => {
   const questionMarks = Array(cids.length).fill('?').join(',');
   const readsColumnNames = Object.keys(tables.reads.columns)
     .map((name) => `'${name}', a.${name}`)
@@ -11,11 +13,11 @@ export const selectReadsForChannels = (cids: string[]): TableRowJoinedUser<'read
     .map((name) => `'${name}', b.${name}`)
     .join(', ');
 
-  QuickSqliteClient.logger?.('info', 'selectReadsForChannels', {
+  SqliteClient.logger?.('info', 'selectReadsForChannels', {
     cids,
   });
 
-  const result = QuickSqliteClient.executeSql(
+  const result = await SqliteClient.executeSql(
     `SELECT
       json_object(
         'user', json_object(
@@ -26,7 +28,7 @@ export const selectReadsForChannels = (cids: string[]): TableRowJoinedUser<'read
     FROM reads a
     LEFT JOIN
       users b
-    ON b.id = a.userId 
+    ON b.id = a.userId
     WHERE a.cid in (${questionMarks})`,
     cids,
   );

package/src/store/apis/updateMessage.ts

@@ -3,14 +3,14 @@ import type { FormatMessageResponse, MessageResponse } from 'stream-chat';
 import { mapMessageToStorable } from '../mappers/mapMessageToStorable';
 import { mapReactionToStorable } from '../mappers/mapReactionToStorable';
 import { mapUserToStorable } from '../mappers/mapUserToStorable';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
 import { createSelectQuery } from '../sqlite-utils/createSelectQuery';
 import { createUpdateQuery } from '../sqlite-utils/createUpdateQuery';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import { SqliteClient } from '../SqliteClient';
 import type { PreparedQueries } from '../types';
 
-export const updateMessage = ({
+export const updateMessage = async ({
   flush = true,
   message,
 }: {
@@ -19,7 +19,7 @@ export const updateMessage = ({
 }) => {
   const queries: PreparedQueries[] = [];
 
-  const messages = QuickSqliteClient.executeSql.apply(
+  const messages = await SqliteClient.executeSql.apply(
     null,
     createSelectQuery('messages', ['*'], {
       id: message.id,
@@ -71,14 +71,14 @@ export const updateMessage = ({
     queries.push(createUpsertQuery('reactions', storableReaction));
   });
 
-  QuickSqliteClient.logger?.('info', 'updateMessage', {
+  SqliteClient.logger?.('info', 'updateMessage', {
     message: storableMessage,
     reactions: storableReactions,
     users: storableUsers,
   });
 
   if (flush) {
-    QuickSqliteClient.executeSqlBatch(queries);
+    await SqliteClient.executeSqlBatch(queries);
   }
 
   return queries;

package/src/store/apis/updatePollMessage.ts

@@ -3,12 +3,12 @@ import { isVoteAnswer, PollAnswer, PollResponse, PollVote } from 'stream-chat';
 import { DefaultStreamChatGenerics } from '../../types/types';
 import { mapPollToStorable } from '../mappers/mapPollToStorable';
 import { mapStorableToPoll } from '../mappers/mapStorableToPoll';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createSelectQuery } from '../sqlite-utils/createSelectQuery';
 import { createUpdateQuery } from '../sqlite-utils/createUpdateQuery';
+import { SqliteClient } from '../SqliteClient';
 import type { PreparedQueries } from '../types';
 
-export const updatePollMessage = <
+export const updatePollMessage = async <
   StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
 >({
   eventType,
@@ -25,7 +25,7 @@ export const updatePollMessage = <
 }) => {
   const queries: PreparedQueries[] = [];
 
-  const pollsFromDB = QuickSqliteClient.executeSql.apply(
+  const pollsFromDB = await SqliteClient.executeSql.apply(
     null,
     createSelectQuery('poll', ['*'], {
       id: poll.id,
@@ -61,13 +61,13 @@ export const updatePollMessage = <
         id: poll.id,
       }),
     );
-    QuickSqliteClient.logger?.('info', 'updatePoll', {
+    SqliteClient.logger?.('info', 'updatePoll', {
       poll: storablePoll,
     });
   }
 
   if (flush) {
-    QuickSqliteClient.executeSqlBatch(queries);
+    SqliteClient.executeSqlBatch(queries);
   }
 
   return queries;

package/src/store/apis/updateReaction.ts

@@ -3,12 +3,12 @@ import type { FormatMessageResponse, MessageResponse, ReactionResponse } from 's
 import { mapMessageToStorable } from '../mappers/mapMessageToStorable';
 import { mapReactionToStorable } from '../mappers/mapReactionToStorable';
 import { mapUserToStorable } from '../mappers/mapUserToStorable';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createUpdateQuery } from '../sqlite-utils/createUpdateQuery';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import { SqliteClient } from '../SqliteClient';
 import type { PreparedQueries } from '../types';
 
-export const updateReaction = ({
+export const updateReaction = async ({
   flush = true,
   message,
   reaction,
@@ -41,7 +41,7 @@ export const updateReaction = ({
     queries.push(createUpdateQuery('messages', { reactionGroups }, { id: message.id }));
   }
 
-  QuickSqliteClient.logger?.('info', 'updateReaction', {
+  SqliteClient.logger?.('info', 'updateReaction', {
     addedUser: storableUser,
     flush,
     updatedReaction: storableReaction,
@@ -49,7 +49,7 @@ export const updateReaction = ({
   });
 
   if (flush) {
-    QuickSqliteClient.executeSqlBatch(queries);
+    await SqliteClient.executeSqlBatch(queries);
   }
 
   return queries;

package/src/store/apis/upsertAppSettings.ts

@@ -1,9 +1,9 @@
 import type { AppSettingsAPIResponse } from 'stream-chat';
 
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const upsertAppSettings = ({
+export const upsertAppSettings = async ({
   appSettings,
   currentUserId,
   flush = true,
@@ -18,13 +18,13 @@ export const upsertAppSettings = ({
     userId: currentUserId,
   });
 
-  QuickSqliteClient.logger?.('info', 'upsertAppSettings', {
+  SqliteClient.logger?.('info', 'upsertAppSettings', {
     appSettings: storableAppSettings,
     flush,
     userId: currentUserId,
   });
 
   if (flush) {
-    QuickSqliteClient.executeSql.apply(null, query);
+    await SqliteClient.executeSql.apply(null, query);
   }
 };

package/src/store/apis/upsertChannelData.ts

@@ -1,10 +1,10 @@
 import type { ChannelResponse } from 'stream-chat';
 
 import { mapChannelDataToStorable } from '../mappers/mapChannelDataToStorable';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const upsertChannelData = ({
+export const upsertChannelData = async ({
   channel,
   flush = true,
 }: {
@@ -13,12 +13,13 @@ export const upsertChannelData = ({
 }) => {
   const storableChannel = mapChannelDataToStorable(channel);
   const query = createUpsertQuery('channels', storableChannel);
-  QuickSqliteClient.logger?.('info', 'upsertChannelData', {
+  SqliteClient.logger?.('info', 'upsertChannelData', {
     channel: storableChannel,
     flush,
   });
+
   if (flush) {
-    QuickSqliteClient.executeSqlBatch([query]);
+    await SqliteClient.executeSqlBatch([query]);
   }
 
   return [query];

package/src/store/apis/upsertChannelDataFromChannel.ts

@@ -2,10 +2,10 @@ import type { Channel } from 'stream-chat';
 
 import { DefaultStreamChatGenerics } from '../../types/types';
 import { mapChannelToStorable } from '../mappers/mapChannelToStorable';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const upsertChannelDataFromChannel = <
+export const upsertChannelDataFromChannel = async <
   StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,
 >({
   channel,
@@ -18,7 +18,7 @@ export const upsertChannelDataFromChannel = <
   if (!storableChannel) return;
   const query = createUpsertQuery('channels', storableChannel);
   if (flush) {
-    QuickSqliteClient.executeSqlBatch([query]);
+    await SqliteClient.executeSqlBatch([query]);
   }
 
   return [query];

package/src/store/apis/upsertChannels.ts

@@ -7,11 +7,11 @@ import { upsertMessages } from './upsertMessages';
 import { upsertReads } from './upsertReads';
 
 import { mapChannelDataToStorable } from '../mappers/mapChannelDataToStorable';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import { SqliteClient } from '../SqliteClient';
 import type { PreparedQueries } from '../types';
 
-export const upsertChannels = ({
+export const upsertChannels = async ({
   channels,
   filters,
   flush = true,
@@ -29,13 +29,13 @@ export const upsertChannels = ({
 
   const channelIds = channels.map((channel) => channel.channel.cid);
 
-  QuickSqliteClient.logger?.('info', 'upsertChannels', {
+  SqliteClient.logger?.('info', 'upsertChannels', {
     channelIds,
   });
 
   if (filters || sort) {
     queries = queries.concat(
-      upsertCidsForQuery({
+      await upsertCidsForQuery({
         cids: channelIds,
         filters,
         flush: false,
@@ -49,7 +49,7 @@ export const upsertChannels = ({
 
     const { members, messages, read } = channel;
     queries = queries.concat(
-      upsertMembers({
+      await upsertMembers({
         cid: channel.channel.cid,
         flush: false,
         members,
@@ -58,7 +58,7 @@ export const upsertChannels = ({
 
     if (read) {
       queries = queries.concat(
-        upsertReads({
+        await upsertReads({
           cid: channel.channel.cid,
           flush: false,
           reads: read,
@@ -68,7 +68,7 @@ export const upsertChannels = ({
 
     if (isLatestMessagesSet) {
       queries = queries.concat(
-        upsertMessages({
+        await upsertMessages({
           flush: false,
           messages,
         }),
@@ -77,7 +77,7 @@ export const upsertChannels = ({
   }
 
   if (flush) {
-    QuickSqliteClient.executeSqlBatch(queries);
+    await SqliteClient.executeSqlBatch(queries);
   }
 
   return queries;

package/src/store/apis/upsertCidsForQuery.ts

@@ -2,10 +2,10 @@ import type { ChannelFilters, ChannelSort } from 'stream-chat';
 
 import { convertFilterSortToQuery } from './utils/convertFilterSortToQuery';
 
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const upsertCidsForQuery = ({
+export const upsertCidsForQuery = async ({
   cids,
   filters,
   flush = true,
@@ -24,14 +24,14 @@ export const upsertCidsForQuery = ({
     id,
   });
 
-  QuickSqliteClient.logger?.('info', 'upsertCidsForQuery', {
+  SqliteClient.logger?.('info', 'upsertCidsForQuery', {
     cids: cidsString,
     flush,
     id,
   });
 
   if (flush) {
-    QuickSqliteClient.executeSql.apply(null, query);
+    await SqliteClient.executeSql.apply(null, query);
   }
 
   return [query];

package/src/store/apis/upsertMembers.ts

@@ -2,11 +2,11 @@ import type { ChannelMemberResponse } from 'stream-chat';
 
 import { mapMemberToStorable } from '../mappers/mapMemberToStorable';
 import { mapUserToStorable } from '../mappers/mapUserToStorable';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import { SqliteClient } from '../SqliteClient';
 import type { PreparedQueries } from '../types';
 
-export const upsertMembers = ({
+export const upsertMembers = async ({
   cid,
   flush = true,
   members,
@@ -32,7 +32,7 @@ export const upsertMembers = ({
     queries.push(createUpsertQuery('members', storableMember));
   });
 
-  QuickSqliteClient.logger?.('info', 'upsertMembers', {
+  SqliteClient.logger?.('info', 'upsertMembers', {
     cid,
     flush,
     storableMembers,
@@ -40,7 +40,7 @@ export const upsertMembers = ({
   });
 
   if (flush) {
-    QuickSqliteClient.executeSqlBatch(queries);
+    await SqliteClient.executeSqlBatch(queries);
   }
 
   return queries;

package/src/store/apis/upsertMessages.ts

@@ -4,10 +4,10 @@ import { mapMessageToStorable } from '../mappers/mapMessageToStorable';
 import { mapPollToStorable } from '../mappers/mapPollToStorable';
 import { mapReactionToStorable } from '../mappers/mapReactionToStorable';
 import { mapUserToStorable } from '../mappers/mapUserToStorable';
-import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
+import { SqliteClient } from '../SqliteClient';
 
-export const upsertMessages = ({
+export const upsertMessages = async ({
   flush = true,
   messages,
 }: {
@@ -44,7 +44,7 @@ export const upsertMessages = ({
     ...storablePolls.map((storablePoll) => createUpsertQuery('poll', storablePoll)),
   ];
 
-  QuickSqliteClient.logger?.('info', 'upsertMessages', {
+  SqliteClient.logger?.('info', 'upsertMessages', {
     flush,
     messages: storableMessages,
     polls: storablePolls,
@@ -53,7 +53,7 @@ export const upsertMessages = ({
   });
 
   if (flush) {
-    QuickSqliteClient.executeSqlBatch(finalQueries);
+    await SqliteClient.executeSqlBatch(finalQueries);
   }
 
   return finalQueries;