stream-chat-react-native-core 7.0.1 → 7.1.0

package/src/store/apis/dropPendingTasks.ts

@@ -0,0 +1,32 @@
+import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
+import { SqliteClient } from '../SqliteClient';
+
+/**
+ * dropPendingTasks - Drops all pending tasks from the DB given a specific messageId.
+ * Useful for when we do some message actions on a failed message and then we decide to
+ * delete it afterwards, removing it from the state.
+ *
+ * @param {Object} param
+ * @param {string} param.messageId The messageId for which we want to remove the pending tasks.
+ * @param {boolean} param.execute Whether we should immediately execute the query or return it as a prepared one.
+ *
+ * @return {() => void} - A function that can be called to remove the task from the database
+ */
+export const dropPendingTasks = async ({
+  messageId,
+  execute = true,
+}: {
+  messageId: string;
+  execute?: boolean;
+}) => {
+  const queries = [createDeleteQuery('pendingTasks', { messageId })];
+  SqliteClient.logger?.('info', 'dropPendingTasks', {
+    messageId,
+  });
+
+  if (execute) {
+    await SqliteClient.executeSqlBatch(queries);
+  }
+
+  return queries;
+};

package/src/store/apis/getChannelMessages.ts

@@ -25,7 +25,7 @@ export const getChannelMessages = async ({
   const messageIds = messageRows.map(({ id }) => id);
 
   // Populate the message reactions.
-  const reactionRows = await selectReactionsForMessages(messageIds);
+  const reactionRows = await selectReactionsForMessages(messageIds, null);
   const messageIdVsReactions: Record<string, TableRowJoinedUser<'reactions'>[]> = {};
   reactionRows.forEach((reaction) => {
     if (!messageIdVsReactions[reaction.messageId]) {

package/src/store/apis/getChannels.ts

@@ -25,19 +25,22 @@ export const getChannels = async ({
   currentUserId: string;
 }): Promise<Omit<ChannelAPIResponse, 'duration'>[]> => {
   SqliteClient.logger?.('info', 'getChannels', { channelIds, currentUserId });
-  const channels = await selectChannels({ channelIds });
 
-  const cidVsMembers = await getMembers({ channelIds });
-  const cidVsReads = await getReads({ channelIds });
-  const cidVsMessages = await getChannelMessages({
-    channelIds,
-    currentUserId,
-  });
+  const [channels, cidVsMembers, cidVsReads, cidVsMessages] = await Promise.all([
+    selectChannels({ channelIds }),
+    getMembers({ channelIds }),
+    getReads({ channelIds }),
+    getChannelMessages({
+      channelIds,
+      currentUserId,
+    }),
+  ]);
 
   // Enrich the channels with state
   return channels.map((c) => ({
     ...mapStorableToChannel(c),
     members: cidVsMembers[c.cid] || [],
+    membership: (cidVsMembers[c.cid] || []).find((member) => member.user_id === currentUserId),
     messages: cidVsMessages[c.cid] || [],
     pinned_messages: [],
     read: cidVsReads[c.cid] || [],

package/src/store/apis/getLastSyncedAt.ts

@@ -5,7 +5,7 @@ export const getLastSyncedAt = async ({
   currentUserId,
 }: {
   currentUserId: string;
-}): Promise<number | undefined> => {
+}): Promise<string | undefined> => {
   SqliteClient.logger?.('info', 'getLastSyncedAt', { currentUserId });
   const result = await SqliteClient.executeSql.apply(
     null,
@@ -14,8 +14,5 @@ export const getLastSyncedAt = async ({
     }),
   );
 
-  if (typeof result[0]?.lastSyncedAt === 'number') {
-    return result[0]?.lastSyncedAt;
-  }
-  return undefined;
+  return result[0]?.lastSyncedAt;
 };

package/src/store/apis/getReactionsforFilterSort.ts

@@ -10,15 +10,18 @@ import { SqliteClient } from '../SqliteClient';
  * @param currentMessageId The message ID for which reactions are to be fetched.
  * @param filters The filters to be applied while fetching reactions.
  * @param sort The sort to be applied while fetching reactions.
+ * @param limit The limit of how many reactions should be returned.
  */
 export const getReactionsForFilterSort = async ({
-  currentMessageId,
+  messageId,
   filters,
   sort,
+  limit,
 }: {
-  currentMessageId: string;
-  filters?: ReactionFilters;
+  messageId: string;
+  filters?: Pick<ReactionFilters, 'type'>;
   sort?: ReactionSort;
+  limit?: number;
 }): Promise<ReactionResponse[] | null> => {
   if (!filters && !sort) {
     console.warn('Please provide the query (filters/sort) to fetch channels from DB');
@@ -27,7 +30,7 @@ export const getReactionsForFilterSort = async ({
 
   SqliteClient.logger?.('info', 'getReactionsForFilterSort', { filters, sort });
 
-  const reactions = await selectReactionsForMessages([currentMessageId]);
+  const reactions = await selectReactionsForMessages([messageId], limit, filters, sort);
 
   if (!reactions) {
     return null;
@@ -37,7 +40,5 @@ export const getReactionsForFilterSort = async ({
     return [];
   }
 
-  const filteredReactions = reactions.filter((reaction) => reaction.type === filters?.type);
-
-  return getReactions({ reactions: filteredReactions });
+  return getReactions({ reactions });
 };

package/src/store/apis/index.ts

@@ -8,11 +8,14 @@ export * from './getAppSettings';
 export * from './getChannelMessages';
 export * from './getChannels';
 export * from './getChannelsForFilterSort';
+export * from './getReactionsforFilterSort';
 export * from './getLastSyncedAt';
 export * from './getMembers';
 export * from './getReads';
 export * from './updateMessage';
 export * from './updateReaction';
+export * from './insertReaction';
+export * from './deleteReaction';
 export * from './upsertAppSettings';
 export * from './upsertChannelData';
 export * from './upsertChannels';
@@ -21,4 +24,10 @@ export * from './upsertUserSyncStatus';
 export * from './upsertMembers';
 export * from './upsertMessages';
 export * from './upsertReads';
-export * from './updatePollMessage';
+export * from './upsertPoll';
+export * from './addPendingTask';
+export * from './deletePendingTask';
+export * from './getPendingTasks';
+export * from './softDeleteMessage';
+export * from './channelExists';
+export * from './dropPendingTasks';

package/src/store/apis/insertReaction.ts

@@ -7,13 +7,13 @@ import { SqliteClient } from '../SqliteClient';
 import type { PreparedQueries } from '../types';
 
 export const insertReaction = async ({
-  flush = true,
+  execute = true,
   message,
   reaction,
 }: {
   message: MessageResponse | LocalMessage;
   reaction: ReactionResponse;
-  flush?: boolean;
+  execute?: boolean;
 }) => {
   const queries: PreparedQueries[] = [];
 
@@ -34,11 +34,11 @@ export const insertReaction = async ({
   );
 
   SqliteClient.logger?.('info', 'insertReaction', {
-    flush,
+    execute,
     reaction: storableReaction,
   });
 
-  if (flush) {
+  if (execute) {
     await SqliteClient.executeSqlBatch(queries);
   }
 

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

@@ -30,7 +30,7 @@ export const selectMessagesForChannels = async (
         *,
         ROW_NUMBER() OVER (
           PARTITION BY cid
-          ORDER BY cast(strftime('%s', createdAt) AS INTEGER) DESC
+          ORDER BY createdAt DESC
         ) RowNum
       FROM messages
       WHERE cid in (${questionMarks})
@@ -39,7 +39,7 @@ export const selectMessagesForChannels = async (
       users b
     ON b.id = a.userId
     WHERE RowNum < 200
-    ORDER BY cast(strftime('%s', a.createdAt) AS INTEGER) ASC`,
+    ORDER BY a.createdAt ASC`,
     cids,
   );
 

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

@@ -1,3 +1,5 @@
+import type { ReactionFilters, ReactionSort } from 'stream-chat';
+
 import { tables } from '../../schema';
 import { SqliteClient } from '../../SqliteClient';
 import type { TableRowJoinedUser } from '../../types';
@@ -5,9 +7,15 @@ 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.
+ * @param limit The limit of how many reactions should be returned.
+ * @param filters A ReactionFilter for the reactions we want to fetch. Only type is currently supported.
+ * @param sort A sort for reactions to be used when querying. Custom data is currently not supported for sorting.
  */
 export const selectReactionsForMessages = async (
   messageIds: string[],
+  limit: number | null = 25,
+  filters?: Pick<ReactionFilters, 'type'>,
+  sort?: ReactionSort,
 ): Promise<TableRowJoinedUser<'reactions'>[]> => {
   const questionMarks = Array(messageIds.length).fill('?').join(',');
   const reactionsColumnNames = Object.keys(tables.reactions.columns)
@@ -16,6 +24,15 @@ export const selectReactionsForMessages = async (
   const userColumnNames = Object.keys(tables.users.columns)
     .map((name) => `'${name}', b.${name}`)
     .join(', ');
+  const filterValue = filters?.type
+    ? [typeof filters.type === 'string' ? filters.type : filters.type.$eq]
+    : [];
+  const createdAtSort = Array.isArray(sort)
+    ? sort.find((s) => !!s.created_at)?.created_at
+    : sort?.created_at;
+  const orderByClause = createdAtSort
+    ? `ORDER BY cast(strftime('%s', a.createdAt) AS INTEGER) ${createdAtSort === 1 ? 'ASC' : 'DESC'}`
+    : '';
 
   SqliteClient.logger?.('info', 'selectReactionsForMessages', {
     messageIds,
@@ -33,8 +50,10 @@ export const selectReactionsForMessages = async (
     LEFT JOIN
       users b
     ON b.id = a.userId
-    WHERE a.messageId in (${questionMarks})`,
-    messageIds,
+    WHERE a.messageId in (${questionMarks}) ${filters?.type ? `AND a.type = ?` : ''}
+    ${orderByClause}
+    ${limit ? 'LIMIT ?' : ''}`,
+    [...messageIds, ...filterValue, ...(limit ? [limit] : [])],
   );
 
   return result.map((r) => JSON.parse(r.value));

package/src/store/apis/softDeleteMessage.ts

@@ -0,0 +1,32 @@
+import { MessageLabel } from 'stream-chat';
+
+import { createUpdateQuery } from '../sqlite-utils/createUpdateQuery';
+import { SqliteClient } from '../SqliteClient';
+
+export const softDeleteMessage = async ({
+  execute = true,
+  id,
+}: {
+  id: string;
+  execute?: boolean;
+}) => {
+  const query = createUpdateQuery(
+    'messages',
+    {
+      deletedAt: new Date().toISOString(),
+      type: 'deleted' as MessageLabel,
+    },
+    { id },
+  );
+
+  SqliteClient.logger?.('info', 'softDeleteMessage', {
+    execute,
+    id,
+  });
+
+  if (execute) {
+    await SqliteClient.executeSql.apply(null, query);
+  }
+
+  return [query];
+};

package/src/store/apis/updateMessage.ts

@@ -3,7 +3,6 @@ import type { LocalMessage, MessageResponse } from 'stream-chat';
 import { mapMessageToStorable } from '../mappers/mapMessageToStorable';
 import { mapReactionToStorable } from '../mappers/mapReactionToStorable';
 import { mapUserToStorable } from '../mappers/mapUserToStorable';
-import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
 import { createSelectQuery } from '../sqlite-utils/createSelectQuery';
 import { createUpdateQuery } from '../sqlite-utils/createUpdateQuery';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
@@ -11,11 +10,11 @@ import { SqliteClient } from '../SqliteClient';
 import type { PreparedQueries } from '../types';
 
 export const updateMessage = async ({
-  flush = true,
+  execute = true,
   message,
 }: {
   message: MessageResponse | LocalMessage;
-  flush?: boolean;
+  execute?: boolean;
 }) => {
   const queries: PreparedQueries[] = [];
 
@@ -48,12 +47,6 @@ export const updateMessage = async ({
     queries.push(createUpsertQuery('users', storableUser));
   }
 
-  queries.push(
-    createDeleteQuery('reactions', {
-      messageId: message.id,
-    }),
-  );
-
   const latestReactions = message.latest_reactions || [];
   const ownReactions = message.own_reactions || [];
 
@@ -77,7 +70,7 @@ export const updateMessage = async ({
     users: storableUsers,
   });
 
-  if (flush) {
+  if (execute) {
     await SqliteClient.executeSqlBatch(queries);
   }
 

package/src/store/apis/updateReaction.ts

@@ -3,19 +3,20 @@ import type { LocalMessage, MessageResponse, ReactionResponse } from 'stream-cha
 import { mapMessageToStorable } from '../mappers/mapMessageToStorable';
 import { mapReactionToStorable } from '../mappers/mapReactionToStorable';
 import { mapUserToStorable } from '../mappers/mapUserToStorable';
+import { createDeleteQuery } from '../sqlite-utils/createDeleteQuery';
 import { createUpdateQuery } from '../sqlite-utils/createUpdateQuery';
 import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
 import { SqliteClient } from '../SqliteClient';
 import type { PreparedQueries } from '../types';
 
 export const updateReaction = async ({
-  flush = true,
+  execute = true,
   message,
   reaction,
 }: {
   message: MessageResponse | LocalMessage;
   reaction: ReactionResponse;
-  flush?: boolean;
+  execute?: boolean;
 }) => {
   const queries: PreparedQueries[] = [];
   let storableUser: ReturnType<typeof mapUserToStorable> | undefined;
@@ -28,11 +29,12 @@ export const updateReaction = async ({
   const storableReaction = mapReactionToStorable(reaction);
 
   queries.push(
-    createUpdateQuery('reactions', storableReaction, {
+    createDeleteQuery('reactions', {
       messageId: reaction.message_id,
       userId: reaction.user_id,
     }),
   );
+  queries.push(createUpsertQuery('reactions', storableReaction));
 
   let updatedReactionGroups: string | undefined;
   if (message.reaction_groups) {
@@ -43,12 +45,12 @@ export const updateReaction = async ({
 
   SqliteClient.logger?.('info', 'updateReaction', {
     addedUser: storableUser,
-    flush,
+    execute,
     updatedReaction: storableReaction,
     updatedReactionGroups,
   });
 
-  if (flush) {
+  if (execute) {
     await SqliteClient.executeSqlBatch(queries);
   }
 

package/src/store/apis/upsertAppSettings.ts

@@ -6,25 +6,29 @@ import { SqliteClient } from '../SqliteClient';
 export const upsertAppSettings = async ({
   appSettings,
   currentUserId,
-  flush = true,
+  execute = true,
 }: {
   appSettings: AppSettingsAPIResponse;
   currentUserId: string;
-  flush?: boolean;
+  execute?: boolean;
 }) => {
   const storableAppSettings = JSON.stringify(appSettings);
-  const query = createUpsertQuery('userSyncStatus', {
-    appSettings: storableAppSettings,
-    userId: currentUserId,
-  });
+  const queries = [
+    createUpsertQuery('userSyncStatus', {
+      appSettings: storableAppSettings,
+      userId: currentUserId,
+    }),
+  ];
 
   SqliteClient.logger?.('info', 'upsertAppSettings', {
     appSettings: storableAppSettings,
-    flush,
+    execute,
     userId: currentUserId,
   });
 
-  if (flush) {
-    await SqliteClient.executeSql.apply(null, query);
+  if (execute) {
+    await SqliteClient.executeSqlBatch(queries);
   }
+
+  return queries;
 };

package/src/store/apis/upsertChannelData.ts

@@ -6,19 +6,19 @@ import { SqliteClient } from '../SqliteClient';
 
 export const upsertChannelData = async ({
   channel,
-  flush = true,
+  execute = true,
 }: {
   channel: ChannelResponse;
-  flush?: boolean;
+  execute?: boolean;
 }) => {
   const storableChannel = mapChannelDataToStorable(channel);
   const query = createUpsertQuery('channels', storableChannel);
   SqliteClient.logger?.('info', 'upsertChannelData', {
     channel: storableChannel,
-    flush,
+    execute,
   });
 
-  if (flush) {
+  if (execute) {
     await SqliteClient.executeSqlBatch([query]);
   }
 

package/src/store/apis/upsertChannelDataFromChannel.ts

@@ -6,17 +6,17 @@ import { SqliteClient } from '../SqliteClient';
 
 export const upsertChannelDataFromChannel = async ({
   channel,
-  flush = true,
+  execute = true,
 }: {
   channel: Channel;
-  flush?: boolean;
+  execute?: boolean;
 }) => {
   const storableChannel = mapChannelToStorable(channel);
   if (!storableChannel) {
     return;
   }
   const query = createUpsertQuery('channels', storableChannel);
-  if (flush) {
+  if (execute) {
     await SqliteClient.executeSqlBatch([query]);
   }
 

package/src/store/apis/upsertChannels.ts

@@ -1,6 +1,5 @@
-import type { ChannelAPIResponse, ChannelFilters, ChannelSort } from 'stream-chat';
+import type { ChannelAPIResponse, ChannelMemberResponse } from 'stream-chat';
 
-import { upsertCidsForQuery } from './upsertCidsForQuery';
 import { upsertMembers } from './upsertMembers';
 
 import { upsertMessages } from './upsertMessages';
@@ -13,16 +12,12 @@ import type { PreparedQueries } from '../types';
 
 export const upsertChannels = async ({
   channels,
-  filters,
-  flush = true,
+  execute = true,
   isLatestMessagesSet,
-  sort,
 }: {
   channels: ChannelAPIResponse[];
-  filters?: ChannelFilters;
-  flush?: boolean;
+  execute?: boolean;
   isLatestMessagesSet?: boolean;
-  sort?: ChannelSort;
 }) => {
   // Update the database only if the query is provided.
   let queries: PreparedQueries[] = [];
@@ -33,25 +28,20 @@ export const upsertChannels = async ({
     channelIds,
   });
 
-  if (filters || sort) {
-    queries = queries.concat(
-      await upsertCidsForQuery({
-        cids: channelIds,
-        filters,
-        flush: false,
-        sort,
-      }),
-    );
-  }
-
   for (const channel of channels) {
     queries.push(createUpsertQuery('channels', mapChannelDataToStorable(channel.channel)));
 
-    const { members, messages, read } = channel;
+    const { members, membership, messages, read } = channel;
+    if (
+      membership &&
+      !members.includes((m: ChannelMemberResponse) => m.user?.id === membership.user?.id)
+    ) {
+      members.push({ ...membership, user_id: membership.user?.id });
+    }
     queries = queries.concat(
       await upsertMembers({
         cid: channel.channel.cid,
-        flush: false,
+        execute: false,
         members,
       }),
     );
@@ -60,7 +50,7 @@ export const upsertChannels = async ({
       queries = queries.concat(
         await upsertReads({
           cid: channel.channel.cid,
-          flush: false,
+          execute: false,
           reads: read,
         }),
       );
@@ -69,14 +59,14 @@ export const upsertChannels = async ({
     if (isLatestMessagesSet) {
       queries = queries.concat(
         await upsertMessages({
-          flush: false,
+          execute: false,
           messages,
         }),
       );
     }
   }
 
-  if (flush) {
+  if (execute) {
     await SqliteClient.executeSqlBatch(queries);
   }
 

package/src/store/apis/upsertCidsForQuery.ts

@@ -8,12 +8,12 @@ import { SqliteClient } from '../SqliteClient';
 export const upsertCidsForQuery = async ({
   cids,
   filters,
-  flush = true,
+  execute = true,
   sort,
 }: {
   cids: string[];
   filters?: ChannelFilters;
-  flush?: boolean;
+  execute?: boolean;
   sort?: ChannelSort;
 }) => {
   // Update the database only if the query is provided.
@@ -26,11 +26,11 @@ export const upsertCidsForQuery = async ({
 
   SqliteClient.logger?.('info', 'upsertCidsForQuery', {
     cids: cidsString,
-    flush,
+    execute,
     id,
   });
 
-  if (flush) {
+  if (execute) {
     await SqliteClient.executeSql.apply(null, query);
   }
 

package/src/store/apis/upsertMembers.ts

@@ -8,12 +8,12 @@ import type { PreparedQueries } from '../types';
 
 export const upsertMembers = async ({
   cid,
-  flush = true,
+  execute = true,
   members,
 }: {
   cid: string;
   members: ChannelMemberResponse[];
-  flush?: boolean;
+  execute?: boolean;
 }) => {
   const queries: PreparedQueries[] = [];
 
@@ -34,12 +34,12 @@ export const upsertMembers = async ({
 
   SqliteClient.logger?.('info', 'upsertMembers', {
     cid,
-    flush,
+    execute,
     storableMembers,
     storableUsers,
   });
 
-  if (flush) {
+  if (execute) {
     await SqliteClient.executeSqlBatch(queries);
   }
 

package/src/store/apis/upsertMessages.ts

@@ -8,11 +8,11 @@ import { createUpsertQuery } from '../sqlite-utils/createUpsertQuery';
 import { SqliteClient } from '../SqliteClient';
 
 export const upsertMessages = async ({
-  flush = true,
+  execute = true,
   messages,
 }: {
   messages: MessageResponse[];
-  flush?: boolean;
+  execute?: boolean;
 }) => {
   const storableMessages: Array<ReturnType<typeof mapMessageToStorable>> = [];
   const storableUsers: Array<ReturnType<typeof mapUserToStorable>> = [];
@@ -45,14 +45,14 @@ export const upsertMessages = async ({
   ];
 
   SqliteClient.logger?.('info', 'upsertMessages', {
-    flush,
+    execute,
     messages: storableMessages,
     polls: storablePolls,
     reactions: storableReactions,
     users: storableUsers,
   });
 
-  if (flush) {
+  if (execute) {
     await SqliteClient.executeSqlBatch(finalQueries);
   }