@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

package/src/channelRepository/observers/getChannels/ChannelLiveCollectionController.ts

@@ -1,606 +0,0 @@
-/* eslint-disable no-use-before-define */
-import hash from 'object-hash';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { ChannelPaginationController } from './ChannelPaginationController';
-import { ChannelQueryStreamController } from './ChannelQueryStreamController';
-import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
-import {
-  onChannelCreated,
-  onChannelDeleted,
-  onChannelJoined,
-  onChannelLeft,
-  onChannelMemberAdded,
-  onChannelMemberRemoved,
-  onChannelUpdated,
-} from '~/channelRepository/events';
-import {
-  onMessageCreatedLocal,
-  onMessageCreatedMqtt,
-} 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 { onChannelFetched } from '~/channelRepository/events/onChannelFetched';
-import { convertEventPayload } from '~/utils/event';
-import { onChannelMarkerFetched } from '~/marker/events';
-import {
-  filterByChannelMembership,
-  filterByPropEquality,
-  filterByStringComparePartially,
-  sortByDisplayName,
-  sortByFirstCreated,
-  sortByLastActivity,
-  sortByLastCreated,
-} from '~/core/query';
-import { updateChannelCache } from '~/channelRepository/utils/updateChannelCache';
-import { onChannelMarkerUpdated } from '~/marker/events/onChannelMarkerUpdated';
-import {
-  getChannelMessagePreview,
-  getChannelMessagePreviewWithUser,
-  handleMessageCreated,
-  handleMessageUpdated,
-  handleSubChannelUpdated,
-} from '~/messagePreview/utils';
-import { getChannel } from '~/channelRepository/internalApi/getChannel';
-import { getActiveClient } from '~/client';
-import { prepareChannelPayload } from '~/channelRepository/utils';
-import { ChannelPaginationNoPageController } from './ChannelPagnationNoPageController';
-import { PaginationController } from '~/core/liveCollection/PaginationController';
-import { onSubChannelCreated } from '~/subChannelRepository';
-
-import ObjectResolverEngine from '~/client/utils/ObjectResolver/objectResolverEngine';
-import { prepareUnreadCountInfo } from '~/channelRepository/utils/prepareUnreadCountInfo';
-import { resolveUnreadInfoOnChannelEvent } from '~/channelRepository/utils/resolveUnreadInfoOnChannelEvent';
-import { onChannelResolved } from '~/channelRepository/events/onChannelResolved';
-import { onUserMessageFeedMarkerResolved } from '~/marker/events/onUserMessageFeedMarkerResolved';
-import { onChannelUnreadInfoUpdatedLocal } from '~/marker/events/onChannelUnreadInfoUpdatedLocal';
-import { constructChannelObject } from '~/channelRepository/utils/constructChannelObject';
-import { onChannelUnreadUpdatedLocal } from '~/channelRepository/events/onChannelUnreadUpdatedLocal';
-import { onChannelSetMuted } from '~/channelRepository/events/onChannelSetMuted';
-
-export class ChannelLiveCollectionController extends LiveCollectionController<
-  'channel',
-  Amity.ChannelLiveCollection,
-  Amity.Channel,
-  ChannelPaginationController | ChannelPaginationNoPageController
-> {
-  private queryStreamController: ChannelQueryStreamController;
-
-  private query: Amity.ChannelLiveCollection;
-
-  constructor(
-    query: Amity.ChannelLiveCollection,
-    callback: Amity.LiveCollectionCallback<Amity.Channel>,
-  ) {
-    const queryStreamId = hash(query);
-    const cacheKey = ['channel', 'collection', queryStreamId];
-    const paginationController = ChannelLiveCollectionController.getPaginationController(query);
-
-    super(paginationController, queryStreamId, cacheKey, callback);
-
-    this.query = query;
-    this.queryStreamController = new ChannelQueryStreamController(
-      this.query,
-      this.cacheKey,
-      this.notifyChange.bind(this),
-      async (channel: Amity.ChannelPayload) => {
-        try {
-          const client = getActiveClient();
-          if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-            await prepareUnreadCountInfo(channel);
-          }
-        } catch (e) {
-          console.error('Error while preparing unread count info', e);
-        }
-        return prepareChannelPayload(channel);
-      },
-      paginationController,
-    );
-
-    this.paginationController = paginationController;
-    this.callback = callback.bind(this);
-    this.loadPage({ initial: true });
-  }
-
-  protected setup() {
-    const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(this.cacheKey)?.data;
-    if (!collection) {
-      pushToCache(this.cacheKey, {
-        data: [],
-        params: {},
-      });
-    }
-  }
-
-  protected async persistModel(response: Amity.ChannelPayload & Amity.Pagination) {
-    await this.queryStreamController.saveToMainDB(response);
-  }
-
-  protected persistQueryStream({
-    response,
-    direction,
-    refresh,
-  }: Amity.LiveCollectionPersistQueryStreamParams<'channel'>) {
-    this.queryStreamController.appendToQueryStream(response, direction, refresh);
-  }
-
-  startSubscription() {
-    return this.queryStreamController.subscribeRTE(this.getSubscriptions());
-  }
-
-  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
-    const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(this.cacheKey)?.data;
-    if (!collection) return;
-
-    let data: Amity.Channel[] =
-      collection.data
-        .map(
-          channelId => pullFromCache<Amity.StaticInternalChannel>(['channel', 'get', channelId])!,
-        )
-        .filter(Boolean)
-        .map(({ data }) => data)
-        .map(constructChannelObject) ?? [];
-
-    if (this.paginationController instanceof ChannelPaginationController) {
-      data = this.applyFilter(data);
-    }
-
-    if (!this.shouldNotify(data) && origin === 'event') return;
-
-    this.callback({
-      onNextPage:
-        this.paginationController instanceof ChannelPaginationController
-          ? () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT })
-          : undefined,
-      data,
-      hasNextPage:
-        this.paginationController instanceof ChannelPaginationController
-          ? !!this.paginationController.getNextToken()
-          : false,
-      loading,
-      error,
-    });
-  }
-
-  private applyFilter(data: Amity.Channel[]) {
-    const { userId } = getActiveClient();
-
-    let channels = data;
-
-    channels = filterByPropEquality(channels, 'isDeleted', this.query.isDeleted);
-
-    channels = filterByStringComparePartially(channels, 'displayName', this.query.displayName);
-
-    if (this.query.types) {
-      channels = channels.filter(c => this.query.types?.includes(c.type));
-    }
-
-    if (this.query.tags) {
-      channels = channels.filter(c => c.tags?.some(t => this.query.tags?.includes(t)));
-    }
-
-    if (this.query.excludeTags) {
-      channels = channels.filter(c => !c.tags?.some(t => this.query.excludeTags?.includes(t)));
-    }
-
-    // userId is required to be able to filter channel by current active user
-    if (this.query.membership && userId) {
-      channels = filterByChannelMembership(channels, this.query.membership, userId);
-    }
-
-    switch (this.query.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 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: '' }) as Amity.Channel & {
-                displayName: string;
-              },
-          )
-          .sort(sortByDisplayName);
-        break;
-
-      default:
-        channels = channels.sort(sortByLastActivity);
-        break;
-    }
-    return channels;
-  }
-
-  private shouldAbort(targetChannelId: string) {
-    const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(this.cacheKey)?.data;
-    if (!collection) return true;
-
-    const channelId = collection?.data?.find(channel => channel === targetChannelId);
-    return !channelId;
-  }
-
-  private static getMessagePreviewSetting() {
-    const client = getActiveClient();
-    return client.getMessagePreviewSetting(false);
-  }
-
-  private static getPaginationController(query: Amity.ChannelLiveCollection) {
-    if (query.channelIds && query.channelIds.length > 0) {
-      return new ChannelPaginationNoPageController(query);
-    }
-
-    return new ChannelPaginationController(query);
-  }
-
-  private getSubscriptions() {
-    const subscriptions = [
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.InternalMessage>) => {
-            return onMessageCreatedMqtt(message => {
-              const objectResolverEngine = ObjectResolverEngine.getInstance();
-
-              const cachedSubChannelUnread = pullFromCache<Amity.SubChannelUnreadInfo>([
-                'subChannelUnreadInfo',
-                'get',
-                message.subChannelId,
-              ])?.data;
-
-              if (!cachedSubChannelUnread)
-                objectResolverEngine.resolve(
-                  message.subChannelId,
-                  Amity.ReferenceType.USER_MESSAGE_FEED_MARKER,
-                );
-
-              const channelCache = pullFromCache<Amity.StaticInternalChannel>([
-                'channel',
-                'get',
-                message.channelId,
-              ])?.data;
-
-              if (!channelCache) {
-                // channelId from message event payload is channelInternalId
-                objectResolverEngine.resolve(message.channelId, Amity.ReferenceType.CHANNEL);
-              } else {
-                updateChannelCache(channelCache, {
-                  lastActivity: message.createdAt,
-                });
-
-                callback(message);
-              }
-            });
-          },
-          'channelId',
-          'channel',
-        ),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.InternalMessage>) => {
-            return onMessageCreatedLocal(message => {
-              const cacheData = pullFromCache<Amity.StaticInternalChannel>([
-                'channel',
-                'get',
-                message.channelId,
-              ])?.data;
-
-              if (!cacheData) return;
-
-              updateChannelCache(cacheData, {
-                lastActivity: message.createdAt,
-              });
-
-              callback(message);
-            });
-          },
-          'channelId',
-          'channel',
-        ),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      { fn: onChannelDeleted, action: Amity.ChannelActionType.OnDelete },
-      { fn: onChannelUpdated, action: Amity.ChannelActionType.OnUpdate },
-      { fn: onChannelSetMuted, action: Amity.ChannelActionType.OnMute },
-      {
-        fn: (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
-          return onChannelJoined(channel => {
-            resolveUnreadInfoOnChannelEvent(channel);
-
-            callback(channel);
-          });
-        },
-        action: Amity.ChannelActionType.OnJoin,
-      },
-      {
-        fn: (reactor: Amity.Listener<Amity.StaticInternalChannel>) => {
-          const callback = (
-            channel: Amity.StaticInternalChannel,
-            member: Amity.Membership<'channel'>,
-          ) => {
-            const { userId } = getActiveClient();
-            // if query for channel member and user is not a member, remove channelId from curren collection
-            if (this.query.membership === 'member' && userId === member.userId) {
-              const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(
-                this.cacheKey,
-              )?.data;
-
-              pushToCache(this.cacheKey, {
-                ...collection,
-                data: collection?.data.filter(c => c !== channel.channelId) ?? [],
-              });
-            }
-            return reactor(channel);
-          };
-          return onChannelLeft(callback);
-        },
-        action: Amity.ChannelActionType.OnLeft,
-      },
-      { fn: onChannelMemberAdded, action: Amity.ChannelActionType.OnMemberAdded },
-      { fn: onChannelMemberRemoved, action: Amity.ChannelActionType.OnMemberRemoved },
-      {
-        fn: convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      {
-        fn: convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.InternalMessage>) => {
-            const updateMessagePreview = async (message: Amity.InternalMessage) => {
-              const messagePreviewSetting =
-                await ChannelLiveCollectionController.getMessagePreviewSetting();
-              if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-              handleMessageCreated(message);
-
-              if (this.shouldAbort(message.channelId)) return;
-
-              const channel = pullFromCache<Amity.StaticInternalChannel>([
-                'channel',
-                'get',
-                message.channelId,
-              ])?.data;
-              if (!channel) return;
-
-              updateChannelCache(channel, {
-                messagePreviewId: message.messageId,
-              });
-
-              callback(message);
-            };
-
-            return onMessageCreatedMqtt(updateMessagePreview);
-          },
-
-          'channelId',
-          'channel',
-        ),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.InternalMessage>) => {
-            const updateMessagePreview = async (message: Amity.InternalMessage) => {
-              const messagePreviewSetting =
-                await ChannelLiveCollectionController.getMessagePreviewSetting();
-              if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-              handleMessageCreated(message);
-
-              if (this.shouldAbort(message.channelId)) return;
-
-              const channel = pullFromCache<Amity.StaticInternalChannel>([
-                'channel',
-                'get',
-                message.channelId,
-              ])?.data;
-              if (!channel) return;
-
-              updateChannelCache(channel, {
-                messagePreviewId: message.messageId,
-              });
-
-              callback(message);
-            };
-
-            return onMessageCreatedLocal(updateMessagePreview);
-          },
-
-          'channelId',
-          'channel',
-        ),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.InternalMessage>) => {
-            const updateMessagePreview = async (message: Amity.InternalMessage) => {
-              const messagePreviewSetting =
-                await ChannelLiveCollectionController.getMessagePreviewSetting();
-              if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-              handleMessageUpdated(message);
-
-              if (this.shouldAbort(message.channelId)) return;
-
-              callback(message);
-            };
-
-            return onMessageUpdated(updateMessagePreview);
-          },
-          'channelId',
-          'channel',
-        ),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.InternalMessage>) => {
-            const updateMessagePreview = async (message: Amity.InternalMessage) => {
-              const messagePreviewSetting =
-                await ChannelLiveCollectionController.getMessagePreviewSetting();
-
-              if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-              if (
-                messagePreviewSetting ===
-                Amity.MessagePreviewSetting.MESSAGE_PREVIEW_INCLUDE_DELETED
-              )
-                await handleMessageUpdated(message);
-
-              if (this.shouldAbort(message.channelId)) return;
-
-              if (
-                messagePreviewSetting ===
-                Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED
-              ) {
-                await getChannel(message.channelId);
-              }
-
-              callback(message);
-            };
-
-            return onMessageDeleted(updateMessagePreview);
-          },
-          'channelId',
-          'channel',
-        ),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.SubChannel>) => {
-            const updateMessagePreview = async (subChannel: Amity.SubChannel) => {
-              const collections = pullFromCache<Amity.ChannelLiveCollectionCache>(
-                this.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',
-        ),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.SubChannel>) => {
-            const updateMessagePreview = async (subChannel: Amity.SubChannel) => {
-              const messagePreviewSetting =
-                await ChannelLiveCollectionController.getMessagePreviewSetting();
-              if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-              const collections = pullFromCache<Amity.ChannelLiveCollectionCache>(
-                this.cacheKey,
-              )?.data;
-              if (!collections) return;
-
-              await handleSubChannelUpdated(subChannel);
-              if (this.shouldAbort(subChannel.channelId)) return;
-
-              callback(subChannel);
-            };
-
-            return onSubChannelUpdated(updateMessagePreview);
-          },
-          'channelId',
-          'channel',
-        ),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      {
-        fn: convertEventPayload(onSubChannelCreated, 'channelId', 'channel'),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      {
-        fn: onChannelResolved,
-        action: Amity.ChannelActionType.OnResolveChannel,
-      },
-      {
-        fn: (callback: Amity.Listener<Amity.StaticInternalChannel[]>) => {
-          const handleUserFeedMarkerResolved = async (
-            marker: Amity.Events['local.userMessageFeedMarkers.resolved'],
-          ) => {
-            if (marker.feedMarkers) {
-              const channels = marker.feedMarkers
-                .map(
-                  feedMarker =>
-                    pullFromCache<Amity.StaticInternalChannel>([
-                      'channel',
-                      'get',
-                      feedMarker.entityId,
-                    ])?.data,
-                )
-                .filter(Boolean) as Amity.StaticInternalChannel[];
-
-              callback(channels);
-            }
-          };
-          return onUserMessageFeedMarkerResolved(handleUserFeedMarkerResolved);
-        },
-        action: Amity.ChannelActionType.OnResolveUnread,
-      },
-      {
-        fn: convertEventPayload(onChannelUnreadInfoUpdatedLocal, 'channelId', 'channel'),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.ChannelUnread>) => {
-            const processPayload = (payloads: Amity.ChannelUnread[]) => {
-              payloads.forEach(callback);
-            };
-            return onChannelUnreadUpdatedLocal(processPayload);
-          },
-          'channelId',
-          'channel',
-        ),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
-    ];
-
-    if (this.paginationController instanceof PaginationController) {
-      return [
-        ...subscriptions,
-        {
-          fn: (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
-            return onChannelCreated(channel => {
-              resolveUnreadInfoOnChannelEvent(channel);
-              callback(channel);
-            });
-          },
-          action: Amity.ChannelActionType.OnCreate,
-        },
-      ];
-    }
-
-    return subscriptions;
-  }
-}

package/src/channelRepository/observers/getChannels/ChannelPaginationController.ts

@@ -1,36 +0,0 @@
-/* eslint-disable no-use-before-define */
-
-import { PaginationController } from '~/core/liveCollection/PaginationController';
-import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
-
-/**
- * TODO: handle cache receive cache option, and cache policy
- * TODO: check if querybyIds is supported
- */
-export class ChannelPaginationController extends PaginationController<
-  'channel',
-  Amity.ChannelLiveCollection
-> {
-  async getRequest(queryParams: Amity.ChannelLiveCollection, token: string | undefined) {
-    const {
-      limit = COLLECTION_DEFAULT_PAGINATION_LIMIT,
-      displayName,
-      membership,
-      ...params
-    } = queryParams;
-    const options = token ? { token } : { limit };
-
-    const { data: queryResponse } = await this.http.get<Amity.ChannelPayload & Amity.Pagination>(
-      `/api/v3/channels`,
-      {
-        params: {
-          ...params,
-          keyword: displayName,
-          filter: membership,
-          options,
-        },
-      },
-    );
-    return queryResponse;
-  }
-}

package/src/channelRepository/observers/getChannels/ChannelPagnationNoPageController.ts

@@ -1,20 +0,0 @@
-/* eslint-disable no-use-before-define */
-
-import { PaginationController } from '~/core/liveCollection/PaginationController';
-import { PaginationNoPageController } from '~/core/liveCollection/PaginationNoPageController';
-import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
-
-export class ChannelPaginationNoPageController extends PaginationNoPageController<
-  'channel',
-  Pick<Amity.ChannelLiveCollection, 'channelIds'>
-> {
-  async getRequest(queryParams: Pick<Amity.ChannelLiveCollection, 'channelIds'>) {
-    const { data: queryResponse } = await this.http.get<Amity.ChannelPayload>(
-      `/api/v3/channels/list`,
-      {
-        params: { ...queryParams },
-      },
-    );
-    return queryResponse;
-  }
-}