@amityco/ts-sdk-react-native 6.14.2-5d7d534.0 → 6.15.1-fee6c8f.0

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

@@ -0,0 +1,413 @@
+/* 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,
+  onChannelMuted,
+  onChannelUpdated,
+} from '~/channelRepository/events';
+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 { convertEventPayload } from '~/utils/event';
+import { onChannelMarkerFetched } from '~/marker/events';
+import {
+  filterByChannelMembership,
+  filterByPropEquality,
+  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/api/getChannel';
+import { getActiveClient } from '~/client';
+import { prepareChannelPayload } from '~/channelRepository/utils';
+import { ChannelPaginationNoPageController } from './ChannelPagnationNoPageController';
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+
+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),
+      prepareChannelPayload,
+      paginationController,
+    );
+
+    this.paginationController = paginationController;
+    this.callback = callback.bind(this);
+    this.loadPage(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 =
+      collection.data
+        .map(channelId => pullFromCache<Amity.Channel>(['channel', 'get', channelId])!)
+        .filter(Boolean)
+        .map(({ data }) => data)
+        .map(getChannelMessagePreviewWithUser) ?? [];
+
+    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(false, 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 = filterByPropEquality(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 = [
+      {
+        // TODO: merge this code to another onMessageCreated in this file
+        fn: convertEventPayload(
+          (callback: Amity.Listener<Amity.Message>) => {
+            return onMessageCreated(message => {
+              const cacheData = pullFromCache<Amity.Channel>([
+                'channel',
+                'get',
+                message.channelId,
+              ])?.data;
+
+              if (!cacheData) return;
+
+              updateChannelCache(cacheData, {
+                lastActivity: message.createdAt,
+              });
+
+              callback(message);
+            });
+          },
+          'messageId',
+          'channel',
+        ),
+        action: 'onUpdate',
+      },
+      { fn: onChannelDeleted, action: 'onDelete' },
+      { fn: onChannelUpdated, action: 'onUpdate' },
+      { fn: onChannelMuted, action: 'onMute' },
+      { fn: onChannelJoined, action: 'onJoin' },
+      { fn: onChannelLeft, action: 'onLeft' },
+      { fn: onChannelMemberAdded, action: 'onMemberAdded' },
+      { fn: onChannelMemberRemoved, action: 'onMemberRemoved' },
+      {
+        fn: convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
+        action: 'onUpdate',
+      },
+      {
+        fn: convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
+        action: 'onUpdate',
+      },
+      {
+        fn: convertEventPayload(
+          (callback: Amity.Listener<Amity.Message>) => {
+            const updateMessagePreview = async (message: Amity.Message) => {
+              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.Channel>([
+                'channel',
+                'get',
+                message.channelId,
+              ])?.data;
+              if (!channel) return;
+
+              updateChannelCache(channel, {
+                messagePreviewId: message.messageId,
+              });
+
+              callback(message);
+            };
+
+            return onMessageCreated(updateMessagePreview);
+          },
+
+          'channelId',
+          'channel',
+        ),
+        action: 'onUpdate',
+      },
+      {
+        fn: convertEventPayload(
+          (callback: Amity.Listener<Amity.Message>) => {
+            const updateMessagePreview = async (message: Amity.Message) => {
+              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: 'onUpdate',
+      },
+      {
+        fn: convertEventPayload(
+          (callback: Amity.Listener<Amity.Message>) => {
+            const updateMessagePreview = async (message: Amity.Message) => {
+              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: '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: '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: 'onUpdate',
+      },
+    ];
+
+    if (this.paginationController instanceof PaginationController) {
+      return [...subscriptions, { fn: onChannelCreated, action: 'onCreate' }];
+    }
+
+    return subscriptions;
+  }
+}

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

@@ -0,0 +1,36 @@
+/* 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/liveCollection/ChannelPagnationNoPageController.ts

@@ -0,0 +1,20 @@
+/* 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;
+  }
+}

package/src/channelRepository/observers/liveCollection/ChannelQueryStreamController.ts

@@ -0,0 +1,89 @@
+/* eslint-disable no-use-before-define */
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+
+import { ChannelPaginationController } from './ChannelPaginationController';
+import { ChannelPaginationNoPageController } from './ChannelPagnationNoPageController';
+
+export class ChannelQueryStreamController extends QueryStreamController<
+  Amity.ChannelPayload,
+  Amity.ChannelLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.ChannelPayload,
+  ) => Promise<Amity.ProcessedChannelPayload>;
+
+  private paginationController: ChannelPaginationController | ChannelPaginationNoPageController;
+
+  constructor(
+    query: Amity.ChannelLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.ChannelPayload) => Promise<Amity.ProcessedChannelPayload>,
+    paginationController: ChannelPaginationController | ChannelPaginationNoPageController,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+    this.paginationController = paginationController;
+  }
+
+  async saveToMainDB(response: Amity.ChannelPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.ChannelPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.channels.map(getResolver('channel')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(this.cacheKey)?.data;
+      const channels = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...channels, ...response.channels.map(getResolver('channel'))])],
+      });
+    }
+  }
+
+  reactor(action: string) {
+    return (payload: Amity.Channel) => {
+      const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      if (this.paginationController instanceof ChannelPaginationController) {
+        collection.data = [...new Set([payload.channelId, ...collection.data])];
+        pushToCache(this.cacheKey, collection);
+      }
+
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: Amity.Listener<Amity.Channel>) => Amity.Unsubscriber;
+      action: string;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/channelRepository/observers/tests/getChannel.test.ts

@@ -35,7 +35,10 @@ describe('getChannel (observer)', () => {
     expect(callback).toHaveBeenNthCalledWith(
       2,
       expect.objectContaining({
-        data: convertRawChannelPayload(channelQueryResponse.data).channels[0],
+        data: {
+          ...convertRawChannelPayload(channelQueryResponse.data).channels[0],
+          messagePreview: null,
+        },
         loading: false,
         error: undefined,
       }),