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

package/src/components/Chat/hooks/handleEventToSyncDB.ts

@@ -1,290 +0,0 @@
-import type { Event, StreamChat } from 'stream-chat';
-
-import { deleteChannel } from '../../../store/apis/deleteChannel';
-import { deleteMember } from '../../../store/apis/deleteMember';
-import { deleteMessagesForChannel } from '../../../store/apis/deleteMessagesForChannel';
-import { updateMessage } from '../../../store/apis/updateMessage';
-import { updatePollMessage } from '../../../store/apis/updatePollMessage';
-import { upsertChannelData } from '../../../store/apis/upsertChannelData';
-import { upsertChannelDataFromChannel } from '../../../store/apis/upsertChannelDataFromChannel';
-import { upsertChannels } from '../../../store/apis/upsertChannels';
-import { upsertMembers } from '../../../store/apis/upsertMembers';
-import { upsertMessages } from '../../../store/apis/upsertMessages';
-import { upsertReads } from '../../../store/apis/upsertReads';
-import { createSelectQuery } from '../../../store/sqlite-utils/createSelectQuery';
-import { SqliteClient } from '../../../store/SqliteClient';
-import { PreparedQueries } from '../../../store/types';
-
-export const handleEventToSyncDB = async (event: Event, client: StreamChat, flush?: boolean) => {
-  const { type } = event;
-
-  // This function is used to guard the queries that require channel to be present in the db first
-  // If channel is not present in the db, we first fetch the channel data from the channel object
-  // and then add the queries with a channel create query first
-  const queriesWithChannelGuard = async (
-    createQueries: (flushOverride?: boolean) => Promise<PreparedQueries[]>,
-  ) => {
-    const cid = event.cid || event.channel?.cid;
-
-    if (!cid) {
-      return await createQueries(flush);
-    }
-    const channels = await SqliteClient.executeSql.apply(
-      null,
-      createSelectQuery('channels', ['cid'], {
-        cid,
-      }),
-    );
-    // a channel is not present in the db, we first fetch the channel data from the channel object.
-    // this can happen for example when a message.new event is received for a channel that is not in the db due to a channel being hidden.
-    if (channels.length === 0) {
-      const channel =
-        event.channel_type && event.channel_id
-          ? client.channel(event.channel_type, event.channel_id)
-          : undefined;
-      if (channel && channel.initialized && !channel.disconnected) {
-        const channelQuery = await upsertChannelDataFromChannel({
-          channel,
-          flush,
-        });
-        if (channelQuery) {
-          const createdQueries = await createQueries(false);
-          const newQueries = [...channelQuery, ...createdQueries];
-          if (flush !== false) {
-            await SqliteClient.executeSqlBatch(newQueries);
-          }
-          return newQueries;
-        } else {
-          console.warn(
-            `Couldnt create channel queries on ${type} event for an initialized channel that is not in DB, skipping event`,
-            { event },
-          );
-          return [];
-        }
-      } else {
-        console.warn(
-          `Received ${type} event for a non initialized channel that is not in DB, skipping event`,
-          { event },
-        );
-        return [];
-      }
-    }
-    return createQueries(flush);
-  };
-
-  if (type === 'message.read' || type === 'notification.mark_read') {
-    const cid = event.cid;
-    const user = event.user;
-    if (user?.id && cid) {
-      return await queriesWithChannelGuard((flushOverride) =>
-        upsertReads({
-          cid,
-          flush: flushOverride,
-          reads: [
-            {
-              last_read: event.received_at as string,
-              last_read_message_id: event.last_read_message_id,
-              unread_messages: 0,
-              user,
-            },
-          ],
-        }),
-      );
-    }
-  }
-
-  if (type === 'notification.mark_unread') {
-    const cid = event.cid;
-    const user = event.user;
-    if (user?.id && cid) {
-      return await queriesWithChannelGuard((flushOverride) =>
-        upsertReads({
-          cid,
-          flush: flushOverride,
-          reads: [
-            {
-              last_read: event.received_at as string,
-              last_read_message_id: event.last_read_message_id,
-              unread_messages: event.unread_messages,
-              user,
-            },
-          ],
-        }),
-      );
-    }
-  }
-
-  if (type === 'message.new') {
-    const { cid, message, user } = event;
-
-    if (message && (!message.parent_id || message.show_in_channel)) {
-      return await queriesWithChannelGuard(async (flushOverride) => {
-        let queries = await upsertMessages({
-          flush: flushOverride,
-          messages: [message],
-        });
-        if (cid && client.user && client.user.id !== user?.id) {
-          const userId = client.user.id;
-          const channel = client.activeChannels[cid];
-          if (channel) {
-            const ownReads = channel.state.read[userId];
-            const unreadCount = channel.countUnread();
-            const upsertReadsQueries = await upsertReads({
-              cid,
-              flush: flushOverride,
-              reads: [
-                {
-                  last_read: ownReads.last_read.toString() as string,
-                  last_read_message_id: ownReads.last_read_message_id,
-                  unread_messages: unreadCount,
-                  user: client.user,
-                },
-              ],
-            });
-            queries = [...queries, ...upsertReadsQueries];
-          }
-        }
-        return queries;
-      });
-    }
-  }
-
-  if (type === 'message.updated' || type === 'message.deleted') {
-    const message = event.message;
-    if (message && !message.parent_id) {
-      // Update only if it exists, otherwise event could be related
-      // to a message which is not in database.
-      return await queriesWithChannelGuard((flushOverride) =>
-        updateMessage({
-          flush: flushOverride,
-          message,
-        }),
-      );
-    }
-  }
-
-  if (type === 'reaction.updated') {
-    const message = event.message;
-    if (message && event.reaction) {
-      // We update the entire message to make sure we also update reaction_groups
-      return await queriesWithChannelGuard((flushOverride) =>
-        updateMessage({
-          flush: flushOverride,
-          message,
-        }),
-      );
-    }
-  }
-
-  if (type === 'reaction.new' || type === 'reaction.deleted') {
-    const message = event.message;
-    if (message && !message.parent_id) {
-      // Here we are relying on the fact message.latest_reactions always includes
-      // the new reaction. So we first delete all the existing reactions and populate
-      // the reactions table with message.latest_reactions
-      return await queriesWithChannelGuard((flushOverride) =>
-        updateMessage({
-          flush: flushOverride,
-          message,
-        }),
-      );
-    }
-  }
-
-  if (
-    type === 'channel.updated' ||
-    type === 'channel.visible' ||
-    type === 'notification.added_to_channel' ||
-    type === 'notification.message_new'
-  ) {
-    if (event.channel) {
-      return upsertChannelData({
-        channel: event.channel,
-        flush,
-      });
-    }
-  }
-
-  if (
-    type === 'channel.hidden' ||
-    type === 'channel.deleted' ||
-    type === 'notification.removed_from_channel'
-  ) {
-    if (event.channel) {
-      return deleteChannel({
-        cid: event.channel.cid,
-        flush,
-      });
-    }
-  }
-
-  if (type === 'channel.truncated') {
-    if (event.channel) {
-      return deleteMessagesForChannel({
-        cid: event.channel.cid,
-        flush,
-      });
-    }
-  }
-
-  if (type === 'channels.queried') {
-    if (event.queriedChannels?.channels?.length) {
-      return upsertChannels({
-        channels: event.queriedChannels?.channels,
-        flush,
-        isLatestMessagesSet: event.queriedChannels?.isLatestMessageSet,
-      });
-    }
-  }
-
-  if (type === 'member.added' || type === 'member.updated') {
-    const member = event.member;
-    const cid = event.cid;
-    if (member && cid) {
-      return await queriesWithChannelGuard((flushOverride) =>
-        upsertMembers({
-          cid,
-          flush: flushOverride,
-          members: [member],
-        }),
-      );
-    }
-  }
-
-  if (type === 'member.removed') {
-    const member = event.member;
-    const cid = event.cid;
-    if (member && cid) {
-      return await queriesWithChannelGuard((flushOverride) =>
-        deleteMember({
-          cid,
-          flush: flushOverride,
-          member,
-        }),
-      );
-    }
-  }
-
-  if (
-    [
-      'poll.closed',
-      'poll.updated',
-      'poll.vote_casted',
-      'poll.vote_changed',
-      'poll.vote_removed',
-    ].includes(type)
-  ) {
-    const { poll, poll_vote, type } = event;
-    if (poll) {
-      return updatePollMessage({
-        eventType: type,
-        flush,
-        poll,
-        poll_vote,
-        userID: client?.userID || '',
-      });
-    }
-  }
-
-  return [];
-};

package/src/store/apis/updatePollMessage.ts

@@ -1,71 +0,0 @@
-import { isVoteAnswer, PollAnswer, PollResponse, PollVote } from 'stream-chat';
-
-import { mapPollToStorable } from '../mappers/mapPollToStorable';
-import { mapStorableToPoll } from '../mappers/mapStorableToPoll';
-import { createSelectQuery } from '../sqlite-utils/createSelectQuery';
-import { createUpdateQuery } from '../sqlite-utils/createUpdateQuery';
-import { SqliteClient } from '../SqliteClient';
-import type { PreparedQueries, TableRow } from '../types';
-
-export const updatePollMessage = async ({
-  eventType,
-  flush = true,
-  poll,
-  poll_vote,
-  userID,
-}: {
-  eventType: string;
-  poll: PollResponse;
-  userID: string;
-  flush?: boolean;
-  poll_vote?: PollVote | PollAnswer;
-}) => {
-  const queries: PreparedQueries[] = [];
-
-  const pollsFromDB = await SqliteClient.executeSql.apply(
-    null,
-    createSelectQuery('poll', ['*'], {
-      id: poll.id,
-    }),
-  );
-
-  for (const pollFromDB of pollsFromDB) {
-    const serializedPoll = mapStorableToPoll(pollFromDB as unknown as TableRow<'poll'>);
-    const { latest_answers = [], own_votes = [] } = serializedPoll;
-    let newOwnVotes = own_votes;
-    if (poll_vote && poll_vote.user?.id === userID) {
-      newOwnVotes =
-        eventType === 'poll.vote_removed'
-          ? newOwnVotes.filter((vote) => vote.id !== poll_vote.id)
-          : [poll_vote, ...newOwnVotes.filter((vote) => vote.id !== poll_vote.id)];
-    }
-    let newLatestAnswers = latest_answers;
-    if (poll_vote && isVoteAnswer(poll_vote)) {
-      newLatestAnswers =
-        eventType === 'poll.vote_removed'
-          ? newLatestAnswers.filter((answer) => answer.id !== poll_vote?.id)
-          : [poll_vote, ...newLatestAnswers.filter((answer) => answer.id !== poll_vote?.id)];
-    }
-
-    const storablePoll = mapPollToStorable({
-      ...poll,
-      latest_answers: newLatestAnswers,
-      own_votes: newOwnVotes,
-    });
-
-    queries.push(
-      createUpdateQuery('poll', storablePoll, {
-        id: poll.id,
-      }),
-    );
-    SqliteClient.logger?.('info', 'updatePoll', {
-      poll: storablePoll,
-    });
-  }
-
-  if (flush) {
-    SqliteClient.executeSqlBatch(queries);
-  }
-
-  return queries;
-};

package/src/utils/DBSyncManager.ts

@@ -1,242 +0,0 @@
-import type { AxiosError } from 'axios';
-import dayjs from 'dayjs';
-import type { APIErrorResponse, StreamChat } from 'stream-chat';
-
-import { handleEventToSyncDB } from '../components/Chat/hooks/handleEventToSyncDB';
-import { getAllChannelIds, getLastSyncedAt, upsertUserSyncStatus } from '../store/apis';
-
-import { addPendingTask } from '../store/apis/addPendingTask';
-
-import { deletePendingTask } from '../store/apis/deletePendingTask';
-import { getPendingTasks } from '../store/apis/getPendingTasks';
-import { SqliteClient } from '../store/SqliteClient';
-import type { PendingTask } from '../store/types';
-
-/**
- * DBSyncManager has the responsibility to sync the channel states
- * within local database whenever possible.
- *
- * Components can get the current sync status using DBSyncManager.getCurrentStatus().
- * Or components can attach a listener for status change as following:
- *
- * ```tsx
- * useEffect(() => {
- *  const unsubscribe = DBSyncManager.onSyncStatusChange((syncStatus) => {
- *    if (syncStatus) {
- *      doSomething();
- *    }
- *  })
- *
- *  return () => unsubscribe();
- * })
- * ```
- */
-const restBeforeNextTask = () => new Promise((resolve) => setTimeout(resolve, 500));
-
-export class DBSyncManager {
-  static syncStatus = false;
-  static listeners: Array<(status: boolean) => void> = [];
-  static client: StreamChat | null = null;
-  static connectionChangedListener: { unsubscribe: () => void } | null = null;
-
-  /**
-   * Returns weather channel states in local DB are synced with backend or not.
-   * @returns boolean
-   */
-  static getSyncStatus = () => this.syncStatus;
-
-  /**
-   * Initializes the DBSyncManager. This function should be called only once
-   * throughout the lifetime of SDK.
-   *
-   * @param client
-   */
-  static init = async (client: StreamChat) => {
-    try {
-      this.client = client;
-      // If the websocket connection is already active, then straightaway
-      // call the sync api and also execute pending api calls.
-      // Otherwise wait for `connection.changed` event.
-      if (client.user?.id && client.wsConnection?.isHealthy) {
-        await this.syncAndExecutePendingTasks();
-        this.syncStatus = true;
-        this.listeners.forEach((l) => l(true));
-      }
-
-      // If a listener has already been registered, unsubscribe from it so
-      // that it can be reinstated. This can happen if we reconnect with a
-      // different user or the component invoking the init() function gets
-      // unmounted and then remounted again. This part of the code makes
-      // sure the stale listener doesn't produce a memory leak.
-      if (this.connectionChangedListener) {
-        this.connectionChangedListener.unsubscribe();
-      }
-
-      this.connectionChangedListener = this.client.on('connection.changed', async (event) => {
-        if (event.online) {
-          await this.syncAndExecutePendingTasks();
-          this.syncStatus = true;
-          this.listeners.forEach((l) => l(true));
-        } else {
-          this.syncStatus = false;
-          this.listeners.forEach((l) => l(false));
-        }
-      });
-    } catch (error) {
-      console.log('Error in DBSyncManager.init: ', error);
-    }
-  };
-
-  /**
-   * Subscribes a listener for sync status change.
-   *
-   * @param listener {function}
-   * @returns {function} to unsubscribe the listener.
-   */
-  static onSyncStatusChange = (listener: (status: boolean) => void) => {
-    this.listeners.push(listener);
-
-    return {
-      unsubscribe: () => {
-        this.listeners = this.listeners.filter((el) => el !== listener);
-      },
-    };
-  };
-
-  static sync = async (client: StreamChat) => {
-    if (!this.client?.user) {
-      return;
-    }
-    const cids = await getAllChannelIds();
-    // If there are no channels, then there is no need to sync.
-    if (cids.length === 0) {
-      return;
-    }
-
-    const lastSyncedAt = await getLastSyncedAt({
-      currentUserId: this.client.user.id,
-    });
-
-    if (lastSyncedAt) {
-      const lastSyncedAtDate = new Date(lastSyncedAt);
-      const lastSyncedAtDayJs = dayjs(lastSyncedAtDate);
-      const nowDayJs = dayjs();
-      const diff = nowDayJs.diff(lastSyncedAtDayJs, 'days');
-      if (diff > 30) {
-        // stream backend will send an error if we try to sync after 30 days.
-        // In that case reset the entire DB and start fresh.
-        await SqliteClient.resetDB();
-      } else {
-        try {
-          const result = await this.client.sync(cids, lastSyncedAtDate.toISOString());
-          const queryPromises = result.events.map(
-            async (event) => await handleEventToSyncDB(event, client),
-          );
-          const queriesArray = await Promise.all(queryPromises);
-          const queries = queriesArray.flat();
-
-          if (queries.length) {
-            await SqliteClient.executeSqlBatch(queries);
-          }
-        } catch (e) {
-          // Error will be raised by the sync API if there are too many events.
-          // In that case reset the entire DB and start fresh.
-          await SqliteClient.resetDB();
-        }
-      }
-    }
-    await upsertUserSyncStatus({
-      currentUserId: this.client.user.id,
-      lastSyncedAt: new Date().toString(),
-    });
-  };
-
-  static syncAndExecutePendingTasks = async () => {
-    if (!this.client) {
-      return;
-    }
-
-    await this.executePendingTasks(this.client);
-    await this.sync(this.client);
-  };
-
-  static queueTask = async ({ client, task }: { client: StreamChat; task: PendingTask }) => {
-    const removeFromApi = await addPendingTask(task);
-
-    let response;
-    try {
-      response = await this.executeTask({ client, task });
-    } catch (e) {
-      if ((e as AxiosError<APIErrorResponse>)?.response?.data?.code === 4) {
-        // Error code 16 - message already exists
-        // ignore
-      } else {
-        throw e;
-      }
-    }
-
-    await removeFromApi();
-
-    return response;
-  };
-
-  static executeTask = async ({ client, task }: { client: StreamChat; task: PendingTask }) => {
-    const channel = client.channel(task.channelType, task.channelId);
-
-    if (task.type === 'send-reaction') {
-      return await channel.sendReaction(...task.payload);
-    }
-
-    if (task.type === 'delete-reaction') {
-      return await channel.deleteReaction(...task.payload);
-    }
-
-    if (task.type === 'delete-message') {
-      return await client.deleteMessage(...task.payload);
-    }
-
-    throw new Error('Invalid task type');
-  };
-
-  static executePendingTasks = async (client: StreamChat) => {
-    const queue = await getPendingTasks();
-    for (const task of queue) {
-      if (!task.id) {
-        continue;
-      }
-
-      try {
-        await this.executeTask({
-          client,
-          task,
-        });
-      } catch (e) {
-        if ((e as AxiosError<APIErrorResponse>)?.response?.data?.code === 4) {
-          // Error code 16 - message already exists
-          // ignore
-        } else {
-          throw e;
-        }
-      }
-
-      await deletePendingTask({
-        id: task.id,
-      });
-      await restBeforeNextTask();
-    }
-  };
-
-  static dropPendingTasks = async (conditions: { messageId: string }) => {
-    const tasks = await getPendingTasks(conditions);
-
-    for (const task of tasks) {
-      if (!task.id) {
-        continue;
-      }
-
-      await deletePendingTask({
-        id: task.id,
-      });
-    }
-  };
-}