@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/channel/observers/liveChannels.ts

@@ -0,0 +1,200 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  filterByChannelMembership,
+  sortByLastCreated,
+  sortByDisplayName,
+  sortByLastActivity,
+  sortByFirstCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { onMessageCreated } from '~/message/events';
+import {
+  onChannelCreated,
+  onChannelDeleted,
+  onChannelUpdated,
+  onChannelMuted,
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+} from '../events';
+import { queryChannels } from '../api';
+
+/**
+ * ```js
+ * import { liveChannels } from '@amityco/ts-sdk'
+ *
+ * let channels = []
+ * const unsub = liveChannels({
+ *   displayName: Amity.Channel['displayName'],
+ * }, response => merge(channels, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Channel}s
+ *
+ * @param params for querying channels
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the channels
+ *
+ * @category Channel Live Collection
+ */
+export const liveChannels = (
+  params: Amity.ChannelLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Channel>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache, userId } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveChannels(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', {}];
+
+  const responder = (data: Amity.ChannelLiveCollectionCache) => {
+    let channels: Amity.Channel[] =
+      data.data
+        .map(channelId => pullFromCache<Amity.Channel>(['channel', 'get', channelId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    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 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.Channel) => {
+    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 = () => {
+    const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
+
+    const channels = collection?.data ?? [];
+
+    if (channels.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryChannels, {
+      ...queryParams,
+      page: collection?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: channels,
+        };
+
+        if (result) {
+          data.data = [...new Set([...channels, ...result.map(getResolver('channel'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onChannelCreated(realtimeRouter('onCreate')),
+    onChannelDeleted(realtimeRouter('onDelete')),
+    onChannelUpdated(realtimeRouter('onUpdate')),
+    onChannelMuted(realtimeRouter('onMute')),
+    onChannelJoined(realtimeRouter('onJoin')),
+    onChannelLeft(realtimeRouter('onLeft')),
+    onChannelMemberAdded(realtimeRouter('onMemberAdded')),
+    onChannelMemberRemoved(realtimeRouter('onMemberRemoved')),
+    onMessageCreated(() => null), // watch unread count
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channel/observers/observeChannel.ts

@@ -9,8 +9,9 @@ import {
   onChannelDeleted,
   onChannelJoined,
   onChannelLeft,
-  onMemberAdded,
-  onMemberRemoved,
+  onChannelMuted,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
 } from '../events';
 
 /**
@@ -29,17 +30,7 @@ import {
  *
  * @category Channel Observer
  */
-export const observeChannel = <
-  Events extends [
-    'onFetch',
-    'onUpdate',
-    'onDelete',
-    'onJoin',
-    'onLeft',
-    'onMemberAdded',
-    'onMemberRemoved',
-  ],
->(
+export const observeChannel = <Events extends [Exclude<Amity.ChannelActionType, 'onCreate'>]>(
   channelId: string,
   callback: Amity.ObjectListener<Amity.Snapshot<Amity.Channel>, Events>,
 ): Amity.Unsubscriber => {
@@ -67,8 +58,13 @@ export const observeChannel = <
     onChannelDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
     onChannelJoined(data => router({ data, loading: false, origin: 'event' }, 'onJoin')),
     onChannelLeft(data => router({ data, loading: false, origin: 'event' }, 'onLeft')),
-    onMemberAdded(data => router({ data, loading: false, origin: 'event' }, 'onMemberAdded')),
-    onMemberRemoved(data => router({ data, loading: false, origin: 'event' }, 'onMemberRemoved')),
+    onChannelMuted(data => router({ data, loading: false, origin: 'event' }, 'onMute')),
+    onChannelMemberAdded(data =>
+      router({ data, loading: false, origin: 'event' }, 'onMemberAdded'),
+    ),
+    onChannelMemberRemoved(data =>
+      router({ data, loading: false, origin: 'event' }, 'onMemberRemoved'),
+    ),
   );
 
   runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));

package/src/channel/observers/observeChannels.ts

@@ -0,0 +1,61 @@
+import { getActiveClient } from '~/client/api';
+
+import {
+  onChannelCreated,
+  onChannelUpdated,
+  onChannelDeleted,
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMuted,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeChannels } from '@amityco/ts-sdk'
+ *
+ * let channels = []
+ * const unsub = observeChannels(channel => merge(channels, channel))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Channel} for a current user
+ *
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the channels
+ *
+ * @category Channel Observer
+ */
+export const observeChannels = (
+  callback: Amity.ObjectListener<Amity.Channel, [Exclude<Amity.ChannelActionType, 'onFetch'>]>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeChannels(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const router = (channel: Amity.Channel, action: Exclude<Amity.ChannelActionType, 'onFetch'>) => {
+    if (callback instanceof Function) return callback(channel);
+
+    callback.onEvent?.(action, channel);
+    callback[action]?.(channel);
+  };
+
+  disposers.push(
+    onChannelCreated(data => router(data, 'onCreate')),
+    onChannelUpdated(data => router(data, 'onUpdate')),
+    onChannelDeleted(data => router(data, 'onDelete')),
+    onChannelJoined(data => router(data, 'onJoin')),
+    onChannelLeft(data => router(data, 'onLeft')),
+    onChannelMuted(data => router(data, 'onMute')),
+    onChannelMemberAdded(data => router(data, 'onMemberAdded')),
+    onChannelMemberRemoved(data => router(data, 'onMemberRemoved')),
+  );
+
+  return () => {
+    log(`observeChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channel/observers/tests/liveChannelMembers.test.ts

@@ -0,0 +1,212 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  bannedChannelUser,
+  channel1,
+  channelRaw1,
+  channelUser,
+  channelUser3,
+  channelUserModel,
+  channelUserQueryResponse,
+  channelUserQueryResponsePage2,
+  channelUserQueryResponsePage3,
+  channelUserWithRole,
+  client,
+  connectClient,
+  disconnectClient,
+  emptyChannelUserQueryResponse,
+  mutedChannelUser,
+  pause,
+  rawBannedChannelUser,
+  rawChannelUser,
+  rawChannelUserWithRole,
+  user11,
+  user13,
+  user14,
+} from '~/utils/tests';
+
+import { liveChannelMembers } from '../liveChannelMembers';
+import { prepareChannelPayload } from '../../utils';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.RawMembership<'channel'>[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+describe('liveChannelMembers', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const { channelId } = channel1;
+
+  test('it should return channel members collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    liveChannelMembers({ channelId }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(getSnapshot({ data: channelUserModel, loading: false })),
+    );
+  });
+
+  const filters: [string, Amity.ChannelMembersLiveCollection, Amity.Membership<'channel'>[]][] = [
+    [
+      'roles',
+      { channelId, roles: channelUserQueryResponsePage3.data.channelUsers[0].roles },
+      [channelUserWithRole],
+    ],
+    ['searched term', { channelId, search: 'use' }, [channelUserWithRole, bannedChannelUser]],
+    ['member', { channelId, memberships: ['member'] }, [channelUserWithRole, mutedChannelUser]],
+    ['muted members', { channelId, memberships: ['muted'] }, [mutedChannelUser]],
+    ['banned members', { channelId, memberships: ['banned'] }, [bannedChannelUser]],
+    [
+      'muted and banned members',
+      { channelId, memberships: ['muted', 'banned'] },
+      [mutedChannelUser, bannedChannelUser],
+    ],
+  ];
+
+  test.each(filters)('it should filter channelUsers by %s', async (filter, params, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponsePage3);
+
+    liveChannelMembers(params, callback);
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ data: expected, loading: false }),
+    );
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(channelUserQueryResponse)
+      .mockResolvedValueOnce(channelUserQueryResponsePage2);
+
+    liveChannelMembers({ channelId }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+    await pause();
+
+    const payload = prepareChannelPayload(channelUserQueryResponse.data);
+    const payload2 = prepareChannelPayload(channelUserQueryResponsePage2.data);
+
+    const snapshot = getSnapshot();
+    snapshot.loading = false;
+    snapshot.data = [...payload2.channelUsers, ...payload.channelUsers];
+
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const events: [
+    string,
+    keyof Amity.Events,
+    Amity.RawMembership<'channel'>,
+    Amity.User,
+    Amity.Membership<'channel'>[],
+  ][] = [
+    [
+      'it should add new member to collection onMemberAdded',
+      'channel.membersAdded',
+      rawChannelUserWithRole,
+      user14,
+      [channelUserWithRole, channelUser, channelUser3],
+    ],
+    [
+      'it should remove channel member from collection onMemberRemoved',
+      'channel.membersRemoved',
+      { ...rawChannelUser, membership: 'none' },
+      user11,
+      [channelUser3],
+    ],
+    [
+      'it should update channel member membership on onChannelMemberBanned',
+      'channel.banned',
+      { ...rawChannelUser, membership: 'banned', isBanned: true },
+      user11,
+      [{ ...channelUser, membership: 'banned', isBanned: true }, channelUser3],
+    ],
+    [
+      'it should update channel member membership on onChannelMemberUnbanned',
+      'channel.unbanned',
+      { ...rawChannelUser, membership: 'none', isBanned: false },
+      user11,
+      [channelUser3],
+    ],
+  ];
+
+  test.each(events)('%s', async (test, event, channelUser, user, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    liveChannelMembers({ channelId }, callback);
+    await pause();
+
+    client.emitter.emit(event, {
+      channels: [channelRaw1],
+      channelUsers: [channelUser],
+      users: [user],
+      files: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining(
+        getSnapshot({
+          data: expected,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  it('should add the banned user to the collection if channel.banned event happens', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(emptyChannelUserQueryResponse);
+
+    liveChannelMembers({ channelId, memberships: ['banned'] }, callback);
+    await pause();
+    client.emitter.emit('channel.banned', {
+      channels: [channelRaw1],
+      channelUsers: [rawBannedChannelUser],
+      users: [user13],
+      files: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining(getSnapshot({ data: [bannedChannelUser], loading: false })),
+    );
+  });
+});