@amityco/ts-sdk 0.0.1-003998f.0

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,205 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channelUser1,
+  channelUser4,
+  channelUserQueryResponse,
+  channelUserQueryResponsePage3,
+  channelUserQueryResponsePage2,
+  channel11,
+  pause,
+  deepCopy,
+} from '~/utils/tests';
+import { liveChannelMembers } from '../liveChannelMembers';
+import { prepareChannelPayload } from '../../utils';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.Membership<'channel'>[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+describe('liveChannelMembers', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const { channelId } = channel11;
+
+  test('it should return channel members collection', async () => {
+    // mock response of queryChannels and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    liveChannelMembers({ channelId }, callback);
+    await pause();
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+
+    const snapshot = getSnapshot();
+    snapshot.data = channelUserQueryResponse.data.channelUsers;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+  });
+
+  const filters: [string, Amity.ChannelMembersLiveCollection, Amity.Membership<'channel'>[]][] = [
+    [
+      'roles',
+      { channelId, roles: channelUserQueryResponsePage3.data.channelUsers[0].roles },
+      [channelUserQueryResponsePage3.data.channelUsers[0]],
+    ],
+    [
+      'searched term',
+      { channelId, search: 'use' },
+      [channelUserQueryResponsePage3.data.channelUsers[0]],
+    ],
+    [
+      'member',
+      { channelId, memberships: ['member'] },
+      [channelUserQueryResponsePage3.data.channelUsers[0]],
+    ],
+    [
+      'muted members',
+      { channelId, memberships: ['muted'] },
+      [channelUserQueryResponsePage3.data.channelUsers[1]],
+    ],
+    [
+      'banned members',
+      { channelId, memberships: ['banned'] },
+      [channelUserQueryResponsePage3.data.channelUsers[1]],
+    ],
+  ];
+
+  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();
+
+    const snapshot = getSnapshot();
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(snapshot));
+
+    snapshot.loading = false;
+    snapshot.data = expected;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+  });
+
+  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.Membership<'channel'>][] = [
+    ['it should add new member to collection onMemberAdded', 'channel.membersAdded', channelUser4],
+    [
+      'it should remove channel member from collection onMemberRemoved',
+      'channel.membersRemoved',
+      channelUser1,
+    ],
+    [
+      'it should update channel memeber membership on onChannelMemberBanned',
+      'channel.banned',
+      { ...channelUser1, membership: 'banned', isBanned: true },
+    ],
+    [
+      'it should update channel memeber membership on onChannelMemberUnbanned',
+      'channel.unbanned',
+      { ...channelUser1, membership: 'none', isBanned: false },
+    ],
+  ];
+
+  test.each(events)('%s', async (test, event, channelUser) => {
+    const snapshot = getSnapshot();
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    liveChannelMembers({ channelId }, callback);
+    await pause();
+
+    client.emitter.emit(event, {
+      channels: [channel11],
+      channelUsers: [channelUser],
+      users: [],
+      files: [],
+    });
+
+    const payload = prepareChannelPayload(channelUserQueryResponse.data);
+
+    snapshot.loading = false;
+    // get data based on event
+    switch (event) {
+      case 'channel.membersAdded':
+        snapshot.data = [channelUser, ...payload.channelUsers];
+        break;
+
+      case 'channel.banned': {
+        const bannedUserIdx = payload.channelUsers.findIndex(u => u.userId === channelUser.userId);
+        payload.channelUsers[bannedUserIdx] = channelUser;
+
+        snapshot.data = payload.channelUsers;
+        break;
+      }
+
+      case 'channel.unbanned': {
+        const unbannedUserIdx = payload.channelUsers.findIndex(
+          u => u.userId === channelUser.userId,
+        );
+        payload.channelUsers[unbannedUserIdx] = channelUser;
+
+        snapshot.data = payload.channelUsers;
+        break;
+      }
+
+      default:
+        // delete payload
+        snapshot.data = payload.channelUsers.filter(u => u.userId !== channelUser.userId);
+    }
+
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

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

@@ -0,0 +1,245 @@
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+import {
+  client,
+  pause,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  channelQueryResponse,
+  channelQueryResponsePage2,
+} from '~/utils/tests';
+import { liveChannels } from '../liveChannels';
+import { prepareChannelPayload } from '../../utils/prepareChannelPayload';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.Channel[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+describe('liveChannels', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return channel collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    liveChannels({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: prepareChannelPayload(channelQueryResponse.data).channels,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  test('it should return data from cache', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    liveChannels({}, () => undefined);
+    await pause();
+    liveChannels({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining(
+        getSnapshot({
+          data: prepareChannelPayload(channelQueryResponse.data).channels,
+        }),
+      ),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: prepareChannelPayload(channelQueryResponse.data).channels,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  // table for channel filters
+  const filters: [string, Amity.ChannelLiveCollection, number?][] = [
+    ['deleted', { isDeleted: false }],
+    ['tagged', { tags: ['tag2'] }],
+    ['out excluded tags', { excludeTags: ['tag1'] }],
+    ['member', { membership: 'member' }],
+    ['not member', { membership: 'notMember' }, 1],
+    ['all membership', { membership: 'all' }],
+  ];
+
+  test.each(filters)(
+    'it should filter by %s channels',
+    async (filter, params, expectedChannelIdx = 0) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+      const payload = prepareChannelPayload(channelQueryResponse.data);
+      let snapshotData = [payload.channels[expectedChannelIdx]];
+
+      // add channel users to cache for testing membership filter
+      if (params.membership) {
+        pushToCache(
+          [
+            'channelUsers',
+            'get',
+            getResolver('channelUsers')({
+              channelId: channelQueryResponse.data.channels[0].channelId,
+              userId: channelUser1.userId,
+            }),
+          ],
+          channelUser1,
+        );
+
+        if (params.membership === 'all') {
+          snapshotData = payload.channels;
+        }
+      }
+
+      liveChannels(params, callback);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      const snapshot = getSnapshot();
+      // check if cache data returned (should be empty)
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(2);
+
+      snapshot.loading = false;
+      snapshot.data = snapshotData;
+
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+    },
+  );
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(channelQueryResponse)
+      .mockResolvedValueOnce(channelQueryResponsePage2);
+
+    liveChannels({}, 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();
+
+    // 4 -> because 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: [
+            ...prepareChannelPayload(channelQueryResponsePage2.data).channels,
+            ...prepareChannelPayload(channelQueryResponse.data).channels,
+          ],
+        }),
+      ),
+    );
+  });
+
+  describe('events', () => {
+    const newChannel = { ...channel11, channelId: 'new-channel-id' };
+    const payload = prepareChannelPayload(channelQueryResponse.data);
+
+    const cases: [string, keyof Amity.Events, Amity.Channel, Amity.Channel[]][] = [
+      [
+        'it should add new channel to collection onCreate',
+        'channel.created',
+        { ...channel11, channelId: 'new-channel-id' },
+        [newChannel, ...payload.channels],
+      ],
+      [
+        'it should update channel in collection onUpdate',
+        'channel.updated',
+        channel11,
+        payload.channels,
+      ],
+      [
+        'it should update channel in collection onMuted',
+        'channel.setMuted',
+        channel11,
+        payload.channels,
+      ],
+      [
+        'it should remove channel from collection onDelete',
+        'channel.deleted',
+        channel11,
+        payload.channels.filter(channel => channel.channelId !== channel11.channelId),
+      ],
+    ];
+
+    type testHandlerType = (
+      test: typeof cases[number][0],
+      event: typeof cases[number][1],
+      channel: typeof cases[number][2],
+      expected: typeof cases[number][3],
+    ) => Promise<void>;
+    const testHandler: testHandlerType = async (test, event, channel, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+      liveChannels({}, callback);
+      await pause();
+
+      client.emitter.emit(event, {
+        channels: [channel],
+        channelUsers: [channelUser1],
+        users: [],
+        files: [],
+      });
+
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining(
+          getSnapshot({
+            data: expected,
+            loading: false,
+          }),
+        ),
+      );
+    };
+
+    test.each(cases)('%s', testHandler);
+  });
+});

package/src/channel/utils/index.ts

@@ -0,0 +1 @@
+export * from './prepareChannelPayload';

package/src/channel/utils/prepareChannelPayload.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api';
+
+/** @hidden */
+export const prepareChannelPayload = (
+  payload: Amity.ChannelPayload,
+): Amity.ChannelPayload<any, Amity.Channel> => {
+  const client = getActiveClient();
+
+  const channels: Amity.Channel[] = payload.channels.map(channel => {
+    const channelUser = payload.channelUsers.find(
+      channelUser =>
+        channelUser.userId === client.userId && channel.channelId === channelUser.channelId,
+    )!;
+
+    const hasMention = channelUser
+      ? channelUser.readToSegment < channelUser.lastMentionedSegment
+      : false;
+    const unreadCount =
+      channelUser && channelUser.membership === 'member' && channel.messageCount
+        ? Math.max(0, channel.messageCount - channelUser.readToSegment)
+        : 0;
+
+    return {
+      ...channel,
+      hasMention,
+      unreadCount,
+    };
+  });
+
+  return { ...payload, channels };
+};

package/src/channel/utils/tests/prepareChannelPayload.test.ts

@@ -0,0 +1,120 @@
+import {
+  connectClient,
+  disconnectClient,
+  channel11,
+  channel12,
+  channelRaw1,
+  channelRaw2,
+  channelUser1,
+  channelUser2,
+} from '~/utils/tests';
+
+import { prepareChannelPayload } from '../prepareChannelPayload';
+
+beforeAll(async () => {
+  await connectClient();
+});
+
+afterAll(async () => {
+  await disconnectClient();
+});
+
+const responseSchema = {
+  channels: [],
+  channelUsers: [],
+  files: [],
+  users: [],
+};
+
+const tests = [
+  {
+    id: 1,
+    desc: 'hasMention: false, unreadCount: 0, if channelUsers is empty',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+    },
+  },
+  {
+    id: 2,
+    desc: 'hasMention: false, if channelUser.readToSegment >= channelUser.lastMentionedSegment',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+      channelUsers: [channelUser1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+      channelUsers: [channelUser1],
+    },
+  },
+  {
+    id: 3,
+    desc: 'unreadCount: 0, if channelUser.readToSegment = channel.messageCount',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+      channelUsers: [channelUser1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+      channelUsers: [channelUser1],
+    },
+  },
+  {
+    id: 4,
+    desc: 'hasMention: true, if channelUser.readToSegment < channelUser.lastMentionedSegment',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+  {
+    id: 5,
+    desc: 'unreadCount: > 0, if channelUser.readToSegment < channel.messageCount',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+  {
+    id: 4,
+    desc: 'hasMention: true, unreadCount: > 0, if 4 / 5 ',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+];
+
+describe('channel/utils/prepareChannelPayload', () => {
+  tests.forEach(({ id, desc, before, after }) => {
+    test(`${id} - ${desc}`, () => {
+      expect(prepareChannelPayload(before)).toEqual(after);
+    });
+  });
+});

package/src/client/api/activeClient.ts

@@ -0,0 +1,33 @@
+import { ASCError } from '~/core/errors';
+
+let activeClient: Amity.Client | null = null;
+
+/**
+ * Get the active client
+ *
+ * @returns the active client instance
+ *
+ * @hidden
+ */
+export const getActiveClient = () => {
+  if (!activeClient) {
+    throw new ASCError(
+      'There is no active client',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.FATAL,
+    );
+  }
+
+  return activeClient!;
+};
+
+/**
+ * Sets the active client
+ *
+ * @param client the client to assume as currently active client
+ *
+ * @hidden
+ */
+export const setActiveClient = (client: Amity.Client) => {
+  activeClient = client;
+};