@amityco/ts-sdk-react-native 6.14.1 → 6.15.0

package/src/channelRepository/observers/getChannels.ts

@@ -1,53 +1,9 @@
 /* eslint-disable no-use-before-define */
-import { getResolver } from '~/core/model';
-import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { dropFromCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
-import {
-  createQuery,
-  filterByChannelMembership,
-  filterByPropEquality,
-  queryOptions,
-  runQuery,
-  sortByDisplayName,
-  sortByFirstCreated,
-  sortByLastActivity,
-  sortByLastCreated,
-} from '~/core/query';
-import { onChannelMarkerFetched } from '~/marker/events';
-import {
-  COLLECTION_DEFAULT_CACHING_POLICY,
-  COLLECTION_DEFAULT_PAGINATION_LIMIT,
-  ENABLE_CACHE_MESSAGE,
-} from '~/utils/constants';
-import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
-import { convertEventPayload } from '~/utils/event';
-import { uuid } from '~/core/uuid';
-import { onMessageCreated } from '~/messageRepository/events/onMessageCreated';
-import { onMessageUpdated } from '~/messageRepository/events/onMessageUpdated';
-import { onMessageDeleted } from '~/messageRepository/events/onMessageDeleted';
-import { onSubChannelUpdated } from '~/subChannelRepository/events/onSubChannelUpdated';
-import { onSubChannelDeleted } from '~/subChannelRepository/events/onSubChannelDeleted';
-import {
-  handleMessageCreated,
-  handleMessageUpdated,
-  handleSubChannelUpdated,
-} from '~/messagePreview/utils/updateMessagePreviewFromMessage';
-import { onChannelMarkerUpdated } from '~/marker/events/onChannelMarkerUpdated';
-import { getChannel } from '../api/getChannel';
-import { getChannelMessagePreviewWithUser } from '../../messagePreview/utils/getChannelMessagePreviewWithUser';
-import { updateChannelCache } from '../utils/updateChannelCache';
-import { getChannelMessagePreview } from '../../messagePreview/utils/getChannelMessagePreview';
-import {
-  onChannelCreated,
-  onChannelDeleted,
-  onChannelJoined,
-  onChannelLeft,
-  onChannelMemberAdded,
-  onChannelMemberRemoved,
-  onChannelMuted,
-  onChannelUpdated,
-} from '../events';
-import { queryChannels } from '../api/queryChannels';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { ChannelLiveCollectionController } from './liveCollection/ChannelLiveCollectionController';
 
 /* begin_public_function
   id: channel.query
@@ -84,275 +40,13 @@ export const getChannels = (
   const timestamp = Date.now();
   log(`getChannels(tmpid: ${timestamp}) > listen`);
 
-  const { limit: queryLimit, ...queryParams } = params;
-
-  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
-  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
-
-  const disposers: Amity.Unsubscriber[] = [];
-  const cacheKey = ['channel', 'collection', uuid()];
-
-  const responder = (data: Amity.ChannelLiveCollectionCache) => {
-    let channels: Amity.Channel[] =
-      data.data
-        .map(channelId => pullFromCache<Amity.Channel>(['channel', 'get', channelId])!)
-        .filter(Boolean)
-        .map(({ data }) => data)
-        .map(getChannelMessagePreviewWithUser) ?? [];
-
-    channels = filterByPropEquality(channels, 'isDeleted', params.isDeleted);
-    channels = filterByPropEquality(channels, 'displayName', params.displayName);
-
-    if (params.types) {
-      channels = channels.filter(c => params.types?.includes(c.type));
-    }
-
-    if (params.tags) {
-      channels = channels.filter(c => c.tags?.some(t => params.tags?.includes(t)));
-    }
-
-    if (params.excludeTags) {
-      channels = channels.filter(c => !c.tags?.some(t => params.excludeTags?.includes(t)));
-    }
-
-    // userId is required to be able to filter channel by current active user
-    if (params.membership && userId) {
-      channels = filterByChannelMembership(channels, params.membership, userId);
-    }
-
-    switch (params.sortBy) {
-      case 'firstCreated':
-        channels = channels.sort(sortByFirstCreated);
-        break;
-
-      case 'lastCreated':
-        channels = channels.sort(sortByLastCreated);
-        break;
-
-      case 'displayName':
-        /*
-         * The server returns channels with empty | null displayName's first before
-         * returning a sorted list of channels with displayNames
-         *
-         * This section needs to be updated as displayNames can be null as well
-         */
-        channels = channels
-          // this needs to be aligned with the backend data type
-          .map(c => (c.displayName ? c : { ...c, displayName: '' }))
-          // @ts-ignore
-          .sort(sortByDisplayName);
-        break;
-
-      default:
-        channels = channels.sort(sortByLastActivity);
-        break;
-    }
-
-    callback({
-      onNextPage: onFetch,
-      data: channels,
-      hasNextPage: !!data.params?.page,
-      loading: data.loading,
-      error: data.error,
-    });
-  };
-
-  const realtimeRouter = (_: Amity.ChannelActionType) => (channel: Amity.InternalChannel) => {
-    const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
-    if (!collection) return;
-
-    collection.data = [...new Set([channel.channelId, ...collection.data])];
-
-    pushToCache(cacheKey, collection);
-    responder(collection);
-  };
-
-  const onFetch = (initial = false) => {
-    const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
-
-    const channels = collection?.data ?? [];
-
-    if (!initial && channels.length > 0 && !collection?.params.page) return;
-
-    const pagingCondition = initial ? { limit } : { page: collection?.params.page };
-    const query = createQuery(queryChannels, {
-      ...queryParams,
-      ...pagingCondition,
-    });
-
-    runQuery(
-      query,
-      ({ data: result, error, loading, paging }) => {
-        const data = {
-          loading,
-          error,
-          params: { page: paging?.next },
-          data: channels,
-        };
-
-        if (result) {
-          data.data = initial
-            ? result.map(getResolver('channel')) // Replace all collection from BE when initial fetch
-            : [...new Set([...channels, ...result.map(getResolver('channel'))])];
-        }
-
-        pushToCache(cacheKey, data);
-
-        responder(data);
-      },
-      queryOptions(policy, CACHE_SHORTEN_LIFESPAN),
-    );
-  };
-
-  const getMessagePreviewSetting = async () => {
-    const client = getActiveClient();
-    return client.getMessagePreviewSetting(false);
-  };
-
-  const shouldAbort = (targetChannelId: string) => {
-    const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
-    if (!collection) return true;
-
-    const channelId = collection?.data?.find(channel => channel === targetChannelId);
-    return !channelId;
-  };
-
-  disposers.push(
-    onMessageCreated(message => {
-      const cacheData = pullFromCache<Amity.Channel>(['channel', 'get', message.channelId])?.data;
-
-      if (!cacheData) return;
-
-      updateChannelCache(cacheData, {
-        lastActivity: message.createdAt,
-      });
-    }),
-    onChannelCreated(realtimeRouter('onCreate')),
-    onChannelDeleted(realtimeRouter('onDelete')),
-    onChannelUpdated(realtimeRouter('onUpdate')),
-    onChannelMuted(realtimeRouter('onMute')),
-    onChannelJoined(realtimeRouter('onJoin')),
-    onChannelLeft(realtimeRouter('onLeft')),
-    onChannelMemberAdded(realtimeRouter('onMemberAdded')),
-    onChannelMemberRemoved(realtimeRouter('onMemberRemoved')),
-    convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel')(realtimeRouter('onUpdate')),
-    convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel')(realtimeRouter('onUpdate')),
-    convertEventPayload(
-      (callback: Amity.Listener<Amity.Message>) => {
-        const updateMessagePreview = async (message: Amity.Message) => {
-          const messagePreviewSetting = await getMessagePreviewSetting();
-          if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-          handleMessageCreated(message);
-
-          if (shouldAbort(message.channelId)) return;
-
-          const channel = pullFromCache<Amity.Channel>(['channel', 'get', message.channelId])?.data;
-          if (!channel) return;
-
-          updateChannelCache(channel, {
-            messagePreviewId: message.messageId,
-          });
-
-          callback(message);
-        };
-
-        return onMessageCreated(updateMessagePreview);
-      },
-
-      'channelId',
-      'channel',
-    )(realtimeRouter('onUpdate')),
-    convertEventPayload(
-      (callback: Amity.Listener<Amity.Message>) => {
-        const updateMessagePreview = async (message: Amity.Message) => {
-          const messagePreviewSetting = await getMessagePreviewSetting();
-          if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-          handleMessageUpdated(message);
-
-          if (shouldAbort(message.channelId)) return;
-
-          callback(message);
-        };
-
-        return onMessageUpdated(updateMessagePreview);
-      },
-      'channelId',
-      'channel',
-    )(realtimeRouter('onUpdate')),
-    convertEventPayload(
-      (callback: Amity.Listener<Amity.Message>) => {
-        const updateMessagePreview = async (message: Amity.Message) => {
-          const messagePreviewSetting = await getMessagePreviewSetting();
-          if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-          if (messagePreviewSetting === Amity.MessagePreviewSetting.MESSAGE_PREVIEW_INCLUDE_DELETED)
-            await handleMessageUpdated(message);
-
-          if (shouldAbort(message.channelId)) return;
-
-          if (
-            messagePreviewSetting ===
-            Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED
-          ) {
-            await getChannel(message.channelId);
-          }
-
-          callback(message);
-        };
-
-        return onMessageDeleted(updateMessagePreview);
-      },
-      'channelId',
-      'channel',
-    )(realtimeRouter('onUpdate')),
-    convertEventPayload(
-      (callback: Amity.Listener<Amity.SubChannel>) => {
-        const updateMessagePreview = async (subChannel: Amity.SubChannel) => {
-          const collections = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
-          if (!collections) return;
-
-          const channelId = collections.data.find(channel => {
-            const messagePreviewCache = getChannelMessagePreview(channel);
-            return messagePreviewCache?.subChannelId === subChannel.subChannelId;
-          });
-          if (!channelId) return;
-
-          await getChannel(subChannel.channelId);
-
-          callback(subChannel);
-        };
-
-        return onSubChannelDeleted(updateMessagePreview);
-      },
-      'channelId',
-      'channel',
-    )(realtimeRouter('onUpdate')),
-    convertEventPayload(
-      (callback: Amity.Listener<Amity.SubChannel>) => {
-        const updateMessagePreview = async (subChannel: Amity.SubChannel) => {
-          const messagePreviewSetting = await getMessagePreviewSetting();
-          if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-          const collections = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
-          if (!collections) return;
-
-          await handleSubChannelUpdated(subChannel);
-          if (shouldAbort(subChannel.channelId)) return;
-
-          callback(subChannel);
-        };
-
-        return onSubChannelUpdated(updateMessagePreview);
-      },
-      'channelId',
-      'channel',
-    )(realtimeRouter('onUpdate')),
-  );
+  const channelLiveCollection = new ChannelLiveCollectionController(params, callback);
+  const disposers = channelLiveCollection.startSubscription();
+  const cacheKey = channelLiveCollection.getCacheKey();
 
-  onFetch(true);
-  disposers.push(() => dropFromCache(cacheKey));
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
 
   return () => {
     log(`getChannels(tmpid: ${timestamp}) > dispose`);