stream-chat-react-native-core 5.26.0-beta.6 → 5.26.0

package/src/store/apis/deleteChannel.ts

@@ -6,6 +6,11 @@ export const deleteChannel = ({ cid, flush = true }: { cid: string; flush?: bool
     cid,
   });
 
+  QuickSqliteClient.logger?.('info', 'deleteChannel', {
+    cid,
+    flush,
+  });
+
   if (flush) {
     QuickSqliteClient.executeSql.apply(null, query);
   }

package/src/store/apis/deleteMember.ts

@@ -17,6 +17,12 @@ export const deleteMember = ({
     userId: member.user_id,
   });
 
+  QuickSqliteClient.logger?.('info', 'deleteMember', {
+    cid,
+    flush,
+    userId: member.user_id,
+  });
+
   if (flush) {
     QuickSqliteClient.executeSql.apply(null, query);
   }

package/src/store/apis/deleteMessage.ts

@@ -5,6 +5,12 @@ export const deleteMessage = ({ flush = true, id }: { id: string; flush?: boolea
   const query = createDeleteQuery('messages', {
     id,
   });
+
+  QuickSqliteClient.logger?.('info', 'deleteMessage', {
+    flush,
+    id,
+  });
+
   if (flush) {
     QuickSqliteClient.executeSql.apply(null, query);
   }

package/src/store/apis/deleteMessagesForChannel.ts

@@ -11,6 +11,12 @@ export const deleteMessagesForChannel = ({
   const query = createDeleteQuery('messages', {
     cid,
   });
+
+  QuickSqliteClient.logger?.('info', 'deleteMessagesForChannel', {
+    cid,
+    flush,
+  });
+
   if (flush) {
     QuickSqliteClient.executeSql.apply(null, query);
   }

package/src/store/apis/deletePendingTask.ts

@@ -6,6 +6,10 @@ export const deletePendingTask = ({ id }: { id: number }) => {
     id,
   });
 
+  QuickSqliteClient.logger?.('info', 'deletePendingTask', {
+    id,
+  });
+
   QuickSqliteClient.executeSql.apply(null, query);
 
   return [query];

package/src/store/apis/deleteReaction.ts

@@ -18,6 +18,12 @@ export const deleteReaction = ({
     userId,
   });
 
+  QuickSqliteClient.logger?.('info', 'deleteReaction', {
+    messageId,
+    type: reactionType,
+    userId,
+  });
+
   if (flush) {
     QuickSqliteClient.executeSql.apply(null, query);
   }

package/src/store/apis/deleteReactions.ts

@@ -11,13 +11,12 @@ export const deleteReactionsForMessage = ({
   const query = createDeleteQuery('reactions', {
     messageId,
   });
+  console.log('deleteReactionsForMessage', {
+    flush,
+    messageId,
+  });
   if (flush) {
-    QuickSqliteClient.executeSql.apply(
-      null,
-      createDeleteQuery('reactions', {
-        messageId,
-      }),
-    );
+    QuickSqliteClient.executeSql.apply(null, query);
   }
 
   return [query];

package/src/store/apis/getAllChannelIds.ts

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

package/src/store/apis/getAppSettings.ts

@@ -8,6 +8,9 @@ export const getAppSettings = ({
 }: {
   currentUserId: string;
 }): AppSettingsAPIResponse => {
+  QuickSqliteClient.logger?.('info', 'getAppSettings', {
+    currentUserId,
+  });
   const result = QuickSqliteClient.executeSql.apply(
     null,
     createSelectQuery('userSyncStatus', ['*'], {

package/src/store/apis/getChannelMessages.ts

@@ -7,6 +7,7 @@ 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 type { TableRowJoinedUser } from '../types';
 
 export const getChannelMessages = <
@@ -18,6 +19,10 @@ export const getChannelMessages = <
   channelIds: string[];
   currentUserId: string;
 }) => {
+  QuickSqliteClient.logger?.('info', 'getChannelMessages', {
+    channelIds,
+    currentUserId,
+  });
   const messageRows = selectMessagesForChannels(channelIds);
   const messageIds = messageRows.map(({ id }) => id);
 

package/src/store/apis/getChannels.ts

@@ -7,6 +7,7 @@ import { selectChannels } from './queries/selectChannels';
 
 import type { DefaultStreamChatGenerics } from '../../types/types';
 import { mapStorableToChannel } from '../mappers/mapStorableToChannel';
+import { QuickSqliteClient } from '../QuickSqliteClient';
 
 /**
  * Returns the list of channels with state enriched for given channel ids.
@@ -26,6 +27,7 @@ export const getChannels = <
   channelIds: string[];
   currentUserId: string;
 }): Omit<ChannelAPIResponse<StreamChatGenerics>, 'duration'>[] => {
+  QuickSqliteClient.logger?.('info', 'getChannels', { channelIds, currentUserId });
   const channels = selectChannels({ channelIds });
 
   const cidVsMembers = getMembers<StreamChatGenerics>({ channelIds });

package/src/store/apis/getChannelsForFilterSort.ts

@@ -4,6 +4,8 @@ import type { ChannelAPIResponse, ChannelFilters, ChannelSort } from 'stream-cha
 import { getChannels } from './getChannels';
 import { selectChannelIdsForFilterSort } from './queries/selectChannelIdsForFilterSort';
 
+import { QuickSqliteClient } from '../QuickSqliteClient';
+
 /**
  * Gets the channels from database for given filter and sort query.
  *
@@ -30,6 +32,8 @@ export const getChannelsForFilterSort = <
     return null;
   }
 
+  QuickSqliteClient.logger?.('info', 'getChannelsForFilterSort', { filters, sort });
+
   const channelIds = selectChannelIdsForFilterSort({ filters, sort });
 
   if (!channelIds) return null;

package/src/store/apis/getLastSyncedAt.ts

@@ -6,6 +6,7 @@ export const getLastSyncedAt = ({
 }: {
   currentUserId: string;
 }): number | undefined => {
+  QuickSqliteClient.logger?.('info', 'getLastSyncedAt', { currentUserId });
   const result = QuickSqliteClient.executeSql.apply(
     null,
     createSelectQuery('userSyncStatus', ['*'], {

package/src/store/apis/getMembers.ts

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

package/src/store/apis/getPendingTasks.ts

@@ -8,6 +8,7 @@ export const getPendingTasks = (conditions: { messageId?: string } = {}) => {
     createdAt: 1,
   });
 
+  QuickSqliteClient.logger?.('info', 'getPendingTasks', { conditions });
   const result = QuickSqliteClient.executeSql.apply(null, query);
 
   return result.map((r: TableRowJoinedUser<'pendingTasks'>) => mapStorableToTask(r));

package/src/store/apis/getReads.ts

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

package/src/store/apis/insertReaction.ts

@@ -14,13 +14,20 @@ export const insertReaction = ({
 }) => {
   const queries: PreparedQueries[] = [];
 
-  queries.push(createUpsertQuery('reactions', mapReactionToStorable(reaction)));
+  const storableReaction = mapReactionToStorable(reaction);
+
+  queries.push(createUpsertQuery('reactions', storableReaction));
 
   queries.push([
     'UPDATE messages SET reactionCounts = reactionCounts + 1 WHERE id = ?',
     [reaction.message_id],
   ]);
 
+  QuickSqliteClient.logger?.('info', 'insertReaction', {
+    flush,
+    reaction: storableReaction,
+  });
+
   if (flush) {
     QuickSqliteClient.executeSqlBatch(queries);
   }

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

@@ -26,6 +26,11 @@ export const selectChannelIdsForFilterSort = <
   sort?: ChannelSort<StreamChatGenerics>;
 }): string[] | null => {
   const query = convertFilterSortToQuery({ filters, sort });
+
+  QuickSqliteClient.logger?.('info', 'selectChannelIdsForFilterSort', {
+    query,
+  });
+
   const results = QuickSqliteClient.executeSql.apply(
     null,
     createSelectQuery('channelQueries', ['*'], {

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

@@ -15,6 +15,10 @@ export const selectChannels = ({
       : undefined,
   );
 
+  QuickSqliteClient.logger?.('info', 'selectChannels', {
+    channelIds,
+  });
+
   const result = QuickSqliteClient.executeSql.apply(null, query);
 
   if (channelIds) {

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

@@ -12,6 +12,10 @@ export const selectMembersForChannels = (cids: string[]): TableRowJoinedUser<'me
     .map((name) => `'${name}', b.${name}`)
     .join(', ');
 
+  QuickSqliteClient.logger?.('info', 'selectMembersForChannels', {
+    cids,
+  });
+
   const result = QuickSqliteClient.executeSql(
     `SELECT
       json_object(

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

@@ -11,6 +11,10 @@ export const selectMessagesForChannels = (cids: string[]): TableRowJoinedUser<'m
     .map((name) => `'${name}', b.${name}`)
     .join(', ');
 
+  QuickSqliteClient.logger?.('info', 'selectMessagesForChannels', {
+    cids,
+  });
+
   const result = QuickSqliteClient.executeSql(
     `SELECT
       json_object(

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

@@ -13,6 +13,10 @@ export const selectReactionsForMessages = (
     .map((name) => `'${name}', b.${name}`)
     .join(', ');
 
+  QuickSqliteClient.logger?.('info', 'selectReactionsForMessages', {
+    messageIds,
+  });
+
   const result = QuickSqliteClient.executeSql(
     `SELECT
       json_object(

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

@@ -10,6 +10,11 @@ export const selectReadsForChannels = (cids: string[]): TableRowJoinedUser<'read
   const userColumnNames = Object.keys(tables.users.columns)
     .map((name) => `'${name}', b.${name}`)
     .join(', ');
+
+  QuickSqliteClient.logger?.('info', 'selectReadsForChannels', {
+    cids,
+  });
+
   const result = QuickSqliteClient.executeSql(
     `SELECT
       json_object(

package/src/store/apis/updateMessage.ts

@@ -30,14 +30,20 @@ export const updateMessage = ({
     return queries;
   }
 
+  const storableMessage = mapMessageToStorable(message);
+
   queries.push(
-    createUpdateQuery('messages', mapMessageToStorable(message), {
+    createUpdateQuery('messages', storableMessage, {
       id: message.id,
     }),
   );
 
+  const storableUsers: Array<ReturnType<typeof mapUserToStorable>> = [];
+
   if (message.user) {
-    queries.push(createUpsertQuery('users', mapUserToStorable(message.user)));
+    const storableUser = mapUserToStorable(message.user);
+    storableUsers.push(storableUser);
+    queries.push(createUpsertQuery('users', storableUser));
   }
 
   queries.push(
@@ -49,12 +55,24 @@ export const updateMessage = ({
   const latestReactions = message.latest_reactions || [];
   const ownReactions = message.own_reactions || [];
 
+  const storableReactions: Array<ReturnType<typeof mapReactionToStorable>> = [];
+
   [...latestReactions, ...ownReactions].forEach((r) => {
     if (r.user) {
-      queries.push(createUpsertQuery('users', mapUserToStorable(r.user)));
+      const storableUser = mapUserToStorable(r.user);
+      storableUsers.push(storableUser);
+      queries.push(createUpsertQuery('users', storableUser));
     }
 
-    queries.push(createUpsertQuery('reactions', mapReactionToStorable(r)));
+    const storableReaction = mapReactionToStorable(r);
+    storableReactions.push(storableReaction);
+    queries.push(createUpsertQuery('reactions', storableReaction));
+  });
+
+  QuickSqliteClient.logger?.('info', 'updateMessage', {
+    message: storableMessage,
+    reactions: storableReactions,
+    users: storableUsers,
   });
 
   if (flush) {

package/src/store/apis/updateReaction.ts

@@ -18,20 +18,27 @@ export const updateReaction = ({
   flush?: boolean;
 }) => {
   const queries: PreparedQueries[] = [];
+  let storableUser: ReturnType<typeof mapUserToStorable> | undefined;
 
   if (reaction.user) {
+    storableUser = mapUserToStorable(reaction.user);
     queries.push(createUpsertQuery('users', mapUserToStorable(reaction.user)));
   }
 
+  const storableReaction = mapReactionToStorable(reaction);
+
   queries.push(
-    createUpdateQuery('reactions', mapReactionToStorable(reaction), {
+    createUpdateQuery('reactions', storableReaction, {
       messageId: reaction.message_id,
       userId: reaction.user_id,
     }),
   );
 
+  let updatedReactionCounts: string | undefined;
+
   if (message.reaction_counts) {
     const { reactionCounts } = mapMessageToStorable(message);
+    updatedReactionCounts = reactionCounts;
 
     queries.push(
       createUpdateQuery(
@@ -46,6 +53,13 @@ export const updateReaction = ({
     );
   }
 
+  QuickSqliteClient.logger?.('info', 'updateReaction', {
+    addedUser: storableUser,
+    flush,
+    updatedReaction: storableReaction,
+    updatedReactionCounts,
+  });
+
   if (flush) {
     QuickSqliteClient.executeSqlBatch(queries);
   }

package/src/store/apis/upsertAppSettings.ts

@@ -12,8 +12,15 @@ export const upsertAppSettings = ({
   currentUserId: string;
   flush?: boolean;
 }) => {
+  const storableAppSettings = JSON.stringify(appSettings);
   const query = createUpsertQuery('userSyncStatus', {
-    appSettings: JSON.stringify(appSettings),
+    appSettings: storableAppSettings,
+    userId: currentUserId,
+  });
+
+  QuickSqliteClient.logger?.('info', 'upsertAppSettings', {
+    appSettings: storableAppSettings,
+    flush,
     userId: currentUserId,
   });
 

package/src/store/apis/upsertChannelData.ts

@@ -11,7 +11,12 @@ export const upsertChannelData = ({
   channel: ChannelResponse;
   flush?: boolean;
 }) => {
-  const query = createUpsertQuery('channels', mapChannelDataToStorable(channel));
+  const storableChannel = mapChannelDataToStorable(channel);
+  const query = createUpsertQuery('channels', storableChannel);
+  QuickSqliteClient.logger?.('info', 'upsertChannelData', {
+    channel: storableChannel,
+    flush,
+  });
   if (flush) {
     QuickSqliteClient.executeSqlBatch([query]);
   }

package/src/store/apis/upsertChannels.ts

@@ -27,8 +27,13 @@ export const upsertChannels = ({
   // Update the database only if the query is provided.
   let queries: PreparedQueries[] = [];
 
+  const channelIds = channels.map((channel) => channel.channel.cid);
+
+  QuickSqliteClient.logger?.('info', 'upsertChannels', {
+    channelIds,
+  });
+
   if (filters || sort) {
-    const channelIds = channels.map((channel) => channel.channel.cid);
     queries = queries.concat(
       upsertCidsForQuery({
         cids: channelIds,

package/src/store/apis/upsertCidsForQuery.ts

@@ -17,9 +17,17 @@ export const upsertCidsForQuery = ({
   sort?: ChannelSort;
 }) => {
   // Update the database only if the query is provided.
+  const cidsString = JSON.stringify(cids);
+  const id = convertFilterSortToQuery({ filters, sort });
   const query = createUpsertQuery('channelQueries', {
-    cids: JSON.stringify(cids),
-    id: convertFilterSortToQuery({ filters, sort }),
+    cids: cidsString,
+    id,
+  });
+
+  QuickSqliteClient.logger?.('info', 'upsertCidsForQuery', {
+    cids: cidsString,
+    flush,
+    id,
   });
 
   if (flush) {

package/src/store/apis/upsertMembers.ts

@@ -17,20 +17,26 @@ export const upsertMembers = ({
 }) => {
   const queries: PreparedQueries[] = [];
 
+  const storableUsers: Array<ReturnType<typeof mapUserToStorable>> = [];
+  const storableMembers: Array<ReturnType<typeof mapMemberToStorable>> = [];
+
   members?.forEach((member) => {
     if (member.user) {
-      queries.push(createUpsertQuery('users', mapUserToStorable(member.user)));
+      const storableUser = mapUserToStorable(member.user);
+      storableUsers.push(storableUser);
+      queries.push(createUpsertQuery('users', storableUser));
     }
+    const storableMember = mapMemberToStorable({ cid, member });
+    storableMembers.push(storableMember);
+
+    queries.push(createUpsertQuery('members', storableMember));
+  });
 
-    queries.push(
-      createUpsertQuery(
-        'members',
-        mapMemberToStorable({
-          cid,
-          member,
-        }),
-      ),
-    );
+  QuickSqliteClient.logger?.('info', 'upsertMembers', {
+    cid,
+    flush,
+    storableMembers,
+    storableUsers,
   });
 
   if (flush) {

package/src/store/apis/upsertMessages.ts

@@ -5,7 +5,6 @@ import { mapReactionToStorable } from '../mappers/mapReactionToStorable';
 import { mapUserToStorable } from '../mappers/mapUserToStorable';
 import { QuickSqliteClient } from '../QuickSqliteClient';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
-import type { PreparedQueries } from '../types';
 
 export const upsertMessages = ({
   flush = true,
@@ -14,26 +13,37 @@ export const upsertMessages = ({
   messages: MessageResponse[];
   flush?: boolean;
 }) => {
-  const usersToUpsert: PreparedQueries[] = [];
-  const messagesToUpsert: PreparedQueries[] = [];
-  const reactionsToUpsert: PreparedQueries[] = [];
+  const storableMessages: Array<ReturnType<typeof mapMessageToStorable>> = [];
+  const storableUsers: Array<ReturnType<typeof mapUserToStorable>> = [];
+  const storableReactions: Array<ReturnType<typeof mapReactionToStorable>> = [];
 
   messages?.forEach((message: MessageResponse) => {
-    messagesToUpsert.push(createUpsertQuery('messages', mapMessageToStorable(message)));
+    storableMessages.push(mapMessageToStorable(message));
     if (message.user) {
-      usersToUpsert.push(createUpsertQuery('users', mapUserToStorable(message.user)));
+      storableUsers.push(mapUserToStorable(message.user));
     }
-
     [...(message.latest_reactions || []), ...(message.own_reactions || [])].forEach((r) => {
       if (r.user) {
-        usersToUpsert.push(createUpsertQuery('users', mapUserToStorable(r.user)));
+        storableUsers.push(mapUserToStorable(r.user));
       }
-
-      reactionsToUpsert.push(createUpsertQuery('reactions', mapReactionToStorable(r)));
+      storableReactions.push(mapReactionToStorable(r));
     });
   });
 
-  const finalQueries = [...messagesToUpsert, ...reactionsToUpsert, ...usersToUpsert];
+  const finalQueries = [
+    ...storableMessages.map((storableMessage) => createUpsertQuery('messages', storableMessage)),
+    ...storableUsers.map((storableUser) => createUpsertQuery('users', storableUser)),
+    ...storableReactions.map((storableReaction) =>
+      createUpsertQuery('reactions', storableReaction),
+    ),
+  ];
+
+  QuickSqliteClient.logger?.('info', 'upsertMessages', {
+    flush,
+    messages: storableMessages,
+    reactions: storableReactions,
+    users: storableUsers,
+  });
 
   if (flush) {
     QuickSqliteClient.executeSqlBatch(finalQueries);

package/src/store/apis/upsertReads.ts

@@ -17,20 +17,23 @@ export const upsertReads = ({
 }) => {
   const queries: PreparedQueries[] = [];
 
+  const storableReads: Array<ReturnType<typeof mapReadToStorable>> = [];
+  const storableUsers: Array<ReturnType<typeof mapUserToStorable>> = [];
+
   reads?.forEach((read) => {
     if (read.user) {
-      queries.push(createUpsertQuery('users', mapUserToStorable(read.user)));
+      storableUsers.push(mapUserToStorable(read.user));
     }
+    storableReads.push(mapReadToStorable({ cid, read }));
+  });
+
+  queries.push(...storableUsers.map((storableUser) => createUpsertQuery('users', storableUser)));
+  queries.push(...storableReads.map((storableRead) => createUpsertQuery('reads', storableRead)));
 
-    queries.push(
-      createUpsertQuery(
-        'reads',
-        mapReadToStorable({
-          cid,
-          read,
-        }),
-      ),
-    );
+  QuickSqliteClient.logger?.('info', 'upsertReads', {
+    flush,
+    reads: storableReads,
+    users: storableUsers,
   });
 
   if (flush) {

package/src/store/apis/upsertUserSyncStatus.ts

@@ -13,5 +13,10 @@ export const upsertUserSyncStatus = ({
     userId: currentUserId,
   });
 
+  QuickSqliteClient.logger?.('info', 'upsertUserSyncStatus', {
+    lastSyncedAt,
+    userId: currentUserId,
+  });
+
   QuickSqliteClient.executeSql.apply(null, query);
 };

package/src/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "5.26.0-beta.6"
+  "version": "5.26.0"
 }