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

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-beta.7"
 }