@amityco/ts-sdk 6.12.2-d74459e.0 → 6.12.2-e855934.0

package/src/channelRepsitory/observers/tests/getChannels.test.ts

@@ -18,6 +18,16 @@ import {
   rawChannelUser,
   rawChannelUser2,
   user11,
+  channelDisplayName3,
+  channelDisplayName2,
+  channelDisplayName1,
+  channelCreatedAt3,
+  channelCreatedAt2,
+  channelCreatedAt1,
+  channelLastActivity1,
+  channelLastActivity2,
+  channelLastActivity3,
+  channelDisplayName4,
 } from '~/utils/tests';
 
 import { getChannels } from '../getChannels';
@@ -105,29 +115,25 @@ describe('getChannels', () => {
     );
   });
 
-  const rawDeletedChannel = generateRawChannel({
-    channelId: 'deleted-channel-id',
-    isDeleted: true,
-  });
-  const deletedChannel = convertChannelFromRaw(rawDeletedChannel);
-  const rawTaggedChannel = generateRawChannel({
-    channelId: 'tagged-channel-id',
-    tags: ['tag1', 'tag2'],
-  });
-  const taggedChannel = convertChannelFromRaw(rawTaggedChannel);
-  const rawTaggedChannel2 = generateRawChannel({
-    channelId: 'tagged-channel-id-2',
-    tags: ['tag2'],
-  });
-  const taggedChannel2 = convertChannelFromRaw(rawTaggedChannel2);
+  describe('when querying the channel collection with specific sort and filter options, the result is sorted and filtered correctly.', () => {
+    const rawDeletedChannel = generateRawChannel({
+      channelId: 'deleted-channel-id',
+      isDeleted: true,
+    });
+    const deletedChannel = convertChannelFromRaw(rawDeletedChannel);
+    const rawTaggedChannel = generateRawChannel({
+      channelId: 'tagged-channel-id',
+      tags: ['tag1', 'tag2'],
+    });
+    const taggedChannel = convertChannelFromRaw(rawTaggedChannel);
+    const rawTaggedChannel2 = generateRawChannel({
+      channelId: 'tagged-channel-id-2',
+      tags: ['tag2'],
+    });
+    const taggedChannel2 = convertChannelFromRaw(rawTaggedChannel2);
 
-  const filters: [string, Amity.ChannelLiveCollection, Amity.Channel[]][] = [
-    [
-      'deleted',
-      { isDeleted: false },
-      [
-        channel1,
-        { ...taggedChannel, messagePreview: null },
+    const filterCases: [string, Amity.ChannelLiveCollection, Amity.Channel[]][] = [
+      ['deleted', { isDeleted: false }, [channel1, { ...taggedChannel, messagePreview: null },
         { ...taggedChannel2, messagePreview: null },
       ],
     ],
@@ -152,57 +158,463 @@ describe('getChannels', () => {
      * TODO: skip this test because the behaviour is changed.
      * The member filter is not supported yet. SDK use filter member response from backend, so skip this test
      */
-    ['member', { membership: 'member' }, [channel1]],
-    [
-      'not member',
-      { membership: 'notMember' },
-      [
+      ['member', { membership: 'member' }, [channel1]],
+      ['not member', { membership: 'notMember' }, [
         { ...deletedChannel, messagePreview: null },
         { ...taggedChannel, messagePreview: null },
         { ...taggedChannel2, messagePreview: null },
-      ],
-    ],
-    [
-      'all membership',
-      { membership: 'all' },
+      ],],
       [
+        'all membership',
+        { membership: 'all' },[
         channel1,
         { ...deletedChannel, messagePreview: null },
         { ...taggedChannel, messagePreview: null },
-        { ...taggedChannel2, messagePreview: null },
+        { ...taggedChannel2, messagePreview: null },],
       ],
-    ],
-  ];
+    ];
 
-  test.each(filters)('it should filter by %s channels', async (filter, params, expected) => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue({
-      data: {
-        channels: [channelRaw1, rawDeletedChannel, rawTaggedChannel, rawTaggedChannel2],
-        channelUsers: [rawChannelUser],
-        files: [],
-        users: [user11],
-        ...mockPage,
+    const sortingCases: [
+      string,
+      Amity.ChannelLiveCollection,
+      Amity.RawChannel[],
+      Amity.RawChannel[],
+    ][] = [
+      [
+        'displayName',
+        { sortBy: 'displayName' },
+        [channelDisplayName1, channelDisplayName2, channelDisplayName3],
+        [channelDisplayName1, channelDisplayName2, channelDisplayName3],
+      ],
+      [
+        'displayName + wrong order',
+        { sortBy: 'displayName' },
+        [channelDisplayName3, channelDisplayName2, channelDisplayName1],
+        [channelDisplayName1, channelDisplayName2, channelDisplayName3],
+      ],
+      [
+        'firstCreated',
+        { sortBy: 'firstCreated' },
+        [channelCreatedAt1, channelCreatedAt2, channelCreatedAt3],
+        [channelCreatedAt1, channelCreatedAt2, channelCreatedAt3],
+      ],
+      [
+        'firstCreated + wrong order',
+        { sortBy: 'firstCreated' },
+        [channelCreatedAt3, channelCreatedAt2, channelCreatedAt1],
+        [channelCreatedAt1, channelCreatedAt2, channelCreatedAt3],
+      ],
+      [
+        'lastCreated',
+        { sortBy: 'lastCreated' },
+        [channelCreatedAt3, channelCreatedAt2, channelCreatedAt1],
+        [channelCreatedAt3, channelCreatedAt2, channelCreatedAt1],
+      ],
+      [
+        'lastCreated + wrong order',
+        { sortBy: 'lastCreated' },
+        [channelCreatedAt1, channelCreatedAt2, channelCreatedAt3],
+        [channelCreatedAt3, channelCreatedAt2, channelCreatedAt1],
+      ],
+      [
+        'lastActivity',
+        { sortBy: 'lastActivity' },
+        [channelLastActivity3, channelLastActivity2, channelLastActivity1],
+        [channelLastActivity3, channelLastActivity2, channelLastActivity1],
+      ],
+      [
+        'lastActivity + wrong order',
+        { sortBy: 'lastActivity' },
+        [channelLastActivity1, channelLastActivity2, channelLastActivity3],
+        [channelLastActivity3, channelLastActivity2, channelLastActivity1],
+      ],
+    ];
+
+    const filterAndSortingCases: [
+      string,
+      Amity.ChannelLiveCollection,
+      Amity.RawChannel[],
+      Amity.RawChannel[],
+    ][] = [
+      [
+        'types + displayName',
+        { types: ['community', 'live'], sortBy: 'displayName' },
+        [channelDisplayName2, channelDisplayName1, channelDisplayName3, channelDisplayName4],
+        [channelDisplayName1, channelDisplayName2, channelDisplayName3],
+      ],
+    ];
+
+    test.each(filterCases)('it should filter by %s channels', async (_filter, params, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue({
+        data: {
+          channels: [channelRaw1, rawDeletedChannel, rawTaggedChannel, rawTaggedChannel2],
+          channelUsers: [rawChannelUser],
+          files: [],
+          users: [user11],
+          ...mockPage,
+        },
+      });
+
+      getChannels(params, callback);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+      // check if cache data returned (should be empty)
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(getSnapshot()));
+
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(2);
+      expect(callback).toHaveBeenCalledWith(
+        expect.objectContaining(
+          getSnapshot({
+            loading: false,
+            data: expected,
+          }),
+        ),
+      );
+    });
+
+    test.each(sortingCases)('it should sort by %s', async (_filter, params, returned, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue({
+        data: {
+          channels: returned,
+          channelUsers: [rawChannelUser],
+          files: [],
+          users: [user11],
+          ...mockPage,
+        },
+      });
+
+      getChannels(params, callback);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(2);
+      expect(callback).toHaveBeenCalledWith(
+        expect.objectContaining(
+          getSnapshot({
+            loading: false,
+            data: expected.map(convertChannelFromRaw),
+          }),
+        ),
+      );
+    });
+
+    test.each(filterAndSortingCases)(
+      'it should filter and sort by %s',
+      async (_filter, params, returned, expected) => {
+        const callback = jest.fn();
+        client.http.get = jest.fn().mockResolvedValue({
+          data: {
+            channels: returned,
+            channelUsers: [rawChannelUser],
+            files: [],
+            users: [user11],
+            ...mockPage,
+          },
+        });
+
+        getChannels(params, callback);
+
+        expect(callback).toHaveBeenCalledTimes(1);
+
+        await pause();
+
+        expect(callback).toHaveBeenCalledTimes(2);
+        expect(callback).toHaveBeenCalledWith(
+          expect.objectContaining(
+            getSnapshot({
+              loading: false,
+              data: expected.map(convertChannelFromRaw),
+            }),
+          ),
+        );
       },
+    );
+  });
+
+  test('when querying two channel collections using different parameters, the results from each collection remain distinct and do not overlap', async () => {
+    const callback = jest.fn();
+    const callback2 = jest.fn();
+    const callback1Response = [
+      channelDisplayName2,
+      channelDisplayName1,
+      channelDisplayName3,
+      channelDisplayName4,
+    ];
+    const callback1Expected = [channelDisplayName1, channelDisplayName2, channelDisplayName3];
+    const callback2Response = [channelCreatedAt3, channelCreatedAt2, channelCreatedAt1];
+
+    client.http.get = jest.fn().mockImplementation((_url: string, params) => {
+      if (!params.params.sortBy) {
+        return {
+          data: {
+            channels: callback2Response,
+            channelUsers: [rawChannelUser],
+            files: [],
+            users: [user11],
+            ...mockPage,
+          },
+        };
+      }
+      return {
+        data: {
+          channels: callback1Response,
+          channelUsers: [rawChannelUser],
+          files: [],
+          users: [user11],
+          ...mockPage,
+        },
+      };
     });
 
-    getChannels(params, callback);
+    getChannels({ types: ['community', 'live'], sortBy: 'displayName' }, callback);
+    getChannels({}, callback2);
 
     expect(callback).toHaveBeenCalledTimes(1);
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(getSnapshot()));
 
-    await pause();
+    await pause(100);
 
     expect(callback).toHaveBeenCalledTimes(2);
-    expect(callback).toHaveBeenCalledWith(
+    expect(callback).lastCalledWith(
       expect.objectContaining(
         getSnapshot({
           loading: false,
-          data: expected,
+          data: callback1Expected.map(convertChannelFromRaw),
         }),
       ),
     );
+
+    expect(callback2).lastCalledWith(
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: callback2Response.map(convertChannelFromRaw),
+        }),
+      ),
+    );
+
+    callback.mock.lastCall[0].onNextPage();
+
+    await pause(100);
+
+    expect(callback).lastCalledWith(
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: callback1Expected.map(convertChannelFromRaw),
+        }),
+      ),
+    );
+
+    expect(callback2).lastCalledWith(
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: callback2Response.map(convertChannelFromRaw),
+        }),
+      ),
+    );
+
+    callback2.mock.lastCall[0].onNextPage();
+
+    await pause(100);
+
+    expect(callback).lastCalledWith(
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: callback1Expected.map(convertChannelFromRaw),
+        }),
+      ),
+    );
+
+    expect(callback2).lastCalledWith(
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: callback2Response.map(convertChannelFromRaw),
+        }),
+      ),
+    );
+  });
+
+  test('when querying two channel collections using different parameters, pagination for each collection operates correctly and does not overlap or mix results', async () => {
+    const callback = jest.fn();
+    const callback2 = jest.fn();
+
+    const returnValue1Page1: Amity.RawChannel[] = [
+      generateRawChannel({ channelId: 'channelId1', isDeleted: false, type: 'community' }),
+      generateRawChannel({ channelId: 'channelId2', isDeleted: false, type: 'live' }),
+      generateRawChannel({ channelId: 'channelId3', isDeleted: false, type: 'broadcast' }),
+    ];
+
+    const returnValue1Page2: Amity.RawChannel[] = [
+      generateRawChannel({ channelId: 'channelId4', isDeleted: false }),
+      generateRawChannel({ channelId: 'channelId5', isDeleted: false }),
+    ];
+
+    const returnValue2Page1: Amity.RawChannel[] = [
+      generateRawChannel({ channelId: 'channelId36', tags: ['test'], displayName: '' }),
+      generateRawChannel({ channelId: 'channelId35', tags: ['test'], displayName: '' }),
+    ];
+
+    const returnValue2Page2: Amity.RawChannel[] = [
+      generateRawChannel({ channelId: 'channelId34', tags: ['test'], displayName: '' }),
+      generateRawChannel({ channelId: 'channelId33', tags: ['test'], displayName: '' }),
+    ];
+
+    const returnValue2Page3: Amity.RawChannel[] = [
+      generateRawChannel({ channelId: 'channelId32', tags: ['test'], displayName: '' }),
+      generateRawChannel({ channelId: 'channelId31', tags: ['test'], displayName: '' }),
+    ];
+
+    const spyGet = jest.spyOn(client.http, 'get').mockImplementation((url: string, params) => {
+      if (!params?.params.tags) {
+        if (params?.params?.options.token === 'eyJza2lwIjowLCJsaW1pdCI6MTB9') {
+          return Promise.resolve({
+            data: {
+              channels: returnValue1Page2,
+              channelUsers: [rawChannelUser],
+              files: [],
+              users: [user11],
+              ...mockPage,
+            },
+          });
+        }
+        return Promise.resolve({
+          data: {
+            channels: returnValue1Page1,
+            channelUsers: [rawChannelUser],
+            files: [],
+            users: [user11],
+            ...mockPage,
+          },
+        });
+      }
+      if (params?.params?.options?.token === 'eyJza2lwIjowLCJsaW1pdCI6MTB9') {
+        return Promise.resolve({
+          data: {
+            channels: returnValue2Page2,
+            channelUsers: [rawChannelUser],
+            files: [],
+            users: [user11],
+            paging: {
+              previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+              next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDQ5MTExMTAwMDAwMH0=',
+            },
+          },
+        });
+      }
+      if (params?.params?.options?.token === 'eyJza2lwIjowfQ==') {
+        return Promise.resolve({
+          data: {
+            channels: returnValue2Page3,
+            channelUsers: [rawChannelUser],
+            files: [],
+            users: [user11],
+            paging: {
+              previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+            },
+          },
+        });
+      }
+
+      return Promise.resolve({
+        data: {
+          channels: returnValue2Page1,
+          channelUsers: [rawChannelUser],
+          files: [],
+          users: [user11],
+          ...mockPage,
+        },
+      });
+    });
+
+    getChannels({}, callback);
+    getChannels({ types: ['community', 'live'], tags: ['test'], sortBy: 'displayName' }, callback2);
+
+    expect(spyGet).toHaveBeenCalledWith('/api/v3/channels', {
+      params: {
+        options: { token: 'eyJza2lwIjowLCJsaW1pdCI6NX0=' },
+      },
+    });
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await pause(100);
+
+    expect(callback.mock.calls.length).toBeGreaterThan(1);
+
+    expect(callback).lastCalledWith(
+      expect.objectContaining({
+        data: returnValue1Page1.map(convertChannelFromRaw),
+        error: undefined,
+        loading: false,
+      }),
+    );
+
+    expect(callback2).lastCalledWith(
+      expect.objectContaining({
+        data: returnValue2Page1.map(convertChannelFromRaw),
+        error: undefined,
+        loading: false,
+      }),
+    );
+
+    // get more page for live collection #2
+    callback2.mock.lastCall[0].onNextPage();
+
+    await pause(100);
+
+    callback2.mock.lastCall[0].onNextPage();
+
+    await pause(100);
+
+    expect(callback.mock.calls.length).toBeGreaterThan(1);
+    expect(callback).lastCalledWith(
+      expect.objectContaining({
+        data: returnValue1Page1.map(convertChannelFromRaw),
+        error: undefined,
+        loading: false,
+      }),
+    );
+
+    expect(callback2.mock.calls.length).toBe(6);
+    expect(callback2).lastCalledWith(
+      expect.objectContaining({
+        data: [...returnValue2Page1, ...returnValue2Page2, ...returnValue2Page3].map(
+          convertChannelFromRaw,
+        ),
+        error: undefined,
+        loading: false,
+      }),
+    );
+
+    // get more page for live collection #1
+
+    callback.mock.lastCall[0].onNextPage();
+
+    await pause(100);
+
+    expect(callback).lastCalledWith(
+      expect.objectContaining({
+        data: [...returnValue1Page1, ...returnValue1Page2].map(convertChannelFromRaw),
+        error: undefined,
+        loading: false,
+      }),
+    );
   });
 
   test('it should return method to fetch next page', async () => {

package/src/client/api/getToken.ts

@@ -15,8 +15,8 @@ import { getDeviceInfo } from '~/core/device';
  * @hidden
  */
 export const getToken = async (params: {
-  userId: Amity.User['userId'];
-  displayName: Amity.User['displayName'];
+  userId: Amity.InternalUser['userId'];
+  displayName: Amity.InternalUser['displayName'];
   authToken?: string;
   deviceId: Amity.Device['deviceId'];
 }) => {
@@ -25,7 +25,7 @@ export const getToken = async (params: {
 
   const deviceInfo = getDeviceInfo();
 
-  const { data } = await client.http.post<Amity.Tokens & { users: Amity.User[] }>(
+  const { data } = await client.http.post<Amity.Tokens & { users: Amity.InternalUser[] }>(
     '/api/v4/sessions',
     {
       ...params,

package/src/client/api/login.ts

@@ -149,7 +149,7 @@ export const login = async (
         unsubWatcher();
       }),
 
-      onUserDeleted((user: Amity.User) => {
+      onUserDeleted((user: Amity.InternalUser) => {
         if (user.userId === client.userId) {
           terminateClient(Amity.TokenTerminationReason.USER_DELETED);
 

package/src/communityRepository/communityMembership/api/addMembers.ts

@@ -13,18 +13,18 @@ import { prepareMembershipPayload } from '~/group/utils';
  * const updated = await CommunityRepository.moderation.addMembers(communityId, ['foo', 'bar'])
  * ```
  *
- * Adds a list of {@link Amity.User} to a {@link Amity.Community} to add users to
+ * Adds a list of {@link Amity.InternalUser} to a {@link Amity.Community} to add users to
  *
  * @param communityId The ID of the {@link Amity.Community} to perform
- * @param userIds The list of IDs {@link Amity.User} to add
- * @returns A success boolean if the {@link Amity.User} were added to the {@link Amity.Community}
+ * @param userIds The list of IDs {@link Amity.InternalUser} to add
+ * @returns A success boolean if the {@link Amity.InternalUser} were added to the {@link Amity.Community}
  *
  * @category Community API
  * @async
  */
 export const addMembers = async (
   communityId: Amity.Community['communityId'],
-  userIds: Amity.User['userId'][],
+  userIds: Amity.InternalUser['userId'][],
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('community/moderation/addMembers', communityId, userIds);

package/src/communityRepository/communityMembership/api/removeMembers.ts

@@ -13,18 +13,18 @@ import { prepareMembershipPayload } from '~/group/utils';
  * const updated = await CommunityRepository.moderation.removeMembers(communityId, ['foo', 'bar'])
  * ```
  *
- * Removes a list of {@link Amity.User} from a {@link Amity.Community}
+ * Removes a list of {@link Amity.InternalUser} from a {@link Amity.Community}
  *
  * @param communityId The ID of the {@link Amity.Community} to edit
- * @param userIds The list of IDs {@link Amity.User} to remove
- * @returns A success boolean if the list of {@link Amity.User} were removed from the {@link Amity.Community}
+ * @param userIds The list of IDs {@link Amity.InternalUser} to remove
+ * @returns A success boolean if the list of {@link Amity.InternalUser} were removed from the {@link Amity.Community}
  *
  * @category Community API
  * @async
  */
 export const removeMembers = async (
   communityId: Amity.Community['communityId'],
-  userIds: Amity.User['userId'][],
+  userIds: Amity.InternalUser['userId'][],
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('community/moderation/removeMembers', communityId, userIds);

package/src/communityRepository/communityMembership/events/utils.ts

@@ -47,7 +47,7 @@ export function updateMembershipStatus(
 function hasPermission(
   member: Amity.Membership<'community'>,
   payload: {
-    users: Amity.User[];
+    users: Amity.InternalUser[];
   },
   permission: string,
 ) {
@@ -64,7 +64,7 @@ function getEventRelatedMember(
   event: keyof Amity.MqttCommunityUserEvents,
   payload: {
     communityUsers: Amity.Membership<'community'>[];
-    users: Amity.User[];
+    users: Amity.InternalUser[];
   },
 ) {
   if (event === 'community.joined' || event === 'community.left') {

package/src/communityRepository/communityMembership/observers/tests/getMembers.test.ts

@@ -93,7 +93,7 @@ describe('getMembers', () => {
     string,
     keyof Amity.Events,
     Amity.RawMembership<'community'>,
-    Amity.User,
+    Amity.InternalUser,
     Amity.Membership<'community'>[],
   ][] = [
     [

package/src/communityRepository/communityModeration/api/addRoles.ts

@@ -12,12 +12,12 @@ import { prepareMembershipPayload } from '~/group/utils';
  * const updated = await CommunityRepository.moderation.addRoles(communityId, ['foo', 'bar'])
  * ```
  *
- * Adds a list of {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Community}
+ * Adds a list of {@link Amity.Role} to a list of {@link Amity.InternalUser} on a {@link Amity.Community}
  *
  * @param communityId The ID of the {@link Amity.Community} to perform
  * @param roleIds Array of IDs of the {@link Amity.Role} to apply
- * @param userIds Array of IDs of the {@link Amity.User} to perform
- * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.User} in the {@link Amity.Community}
+ * @param userIds Array of IDs of the {@link Amity.InternalUser} to perform
+ * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.InternalUser} in the {@link Amity.Community}
  *
  * @category Community API
  * @async
@@ -25,7 +25,7 @@ import { prepareMembershipPayload } from '~/group/utils';
 export const addRoles = async (
   communityId: Amity.Community['communityId'],
   roleIds: Amity.Role['roleId'][],
-  userIds: Amity.User['userId'][],
+  userIds: Amity.InternalUser['userId'][],
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('community/moderation/addRoles', communityId, roleIds, userIds);