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

package/src/community/observers/tests/liveCommunities.test.ts

@@ -0,0 +1,304 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  communityQueryResponse,
+  communityQueryResponsePage2,
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  communityUser11,
+  emptyCommunityPayload,
+} from '~/utils/tests';
+
+import { liveCommunities } from '../liveCommunities';
+import { prepareCommunityPayload } from '../../utils';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.Community[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+const { paging, ...payload } = communityQueryResponse.data;
+
+const community1 = prepareCommunityPayload(payload).communities[0];
+const community2 = prepareCommunityPayload(payload).communities[1];
+
+describe('liveCommunities', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return community collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+    liveCommunities({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: prepareCommunityPayload(payload).communities,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  test('it should return data from cache', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+    liveCommunities({}, () => undefined);
+    await pause();
+    liveCommunities({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining(
+        getSnapshot({
+          data: prepareCommunityPayload(payload).communities,
+        }),
+      ),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: prepareCommunityPayload(payload).communities,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  const filters: [string, Amity.CommunityLiveCollection, Amity.Community[]][] = [
+    ['not deleted', { includeDeleted: false }, [community2]],
+    ['categoryId', { categoryId: 'test-category-id' }, [community1]],
+    ['displayName', { displayName: 'community 1' }, [community1]],
+    ['tagged', { tags: ['test-community-tag'] }, [community1]],
+    ['member', { membership: 'member' }, [community1]],
+    ['not member', { membership: 'notMember' }, [community2]],
+    ['all membership', { membership: 'all' }, [community1, community2]],
+  ];
+
+  test.each(filters)('it should filter by %s communities', async (filter, params, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+    liveCommunities(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('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(communityQueryResponse)
+      .mockResolvedValueOnce(communityQueryResponsePage2);
+
+    liveCommunities({}, 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: prepareCommunityPayload(payload).communities,
+        }),
+      ),
+    );
+  });
+
+  describe('events', () => {
+    const newCommunityPayload = {
+      ...communityQueryResponse.data.communities[0],
+      communityId: 'new-community',
+      isDeleted: false,
+    };
+
+    const newCommunity = prepareCommunityPayload({
+      ...emptyCommunityPayload,
+      communities: [newCommunityPayload],
+    }).communities[0];
+
+    const communityPayload = {
+      ...emptyCommunityPayload,
+      communities: [communityQueryResponse.data.communities[0]],
+      communityUsers: [communityUser11],
+    };
+
+    const cases: [string, keyof Amity.Events, Amity.CommunityPayload, Amity.Community[]][] = [
+      [
+        'it should add new community to collection onCreate',
+        'community.created',
+        {
+          ...emptyCommunityPayload,
+          communities: [newCommunityPayload],
+        },
+        [newCommunity, community2],
+      ],
+      [
+        'it should update community in collection onUpdate',
+        'community.updated',
+        {
+          ...emptyCommunityPayload,
+          communities: [{ ...newCommunityPayload, communityId: community1.communityId }],
+        },
+        [{ ...newCommunity, communityId: community1.communityId }, community2],
+      ],
+      [
+        'it should remove community from collection onDelete',
+        'community.deleted',
+        communityPayload,
+        [community2],
+      ],
+    ];
+
+    test.each(cases)('%s', async (test, event, communityPayload, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+      liveCommunities({ includeDeleted: false }, callback);
+      await pause();
+
+      client.emitter.emit(event, communityPayload);
+      await pause();
+
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining(
+          getSnapshot({
+            data: expected,
+            loading: false,
+          }),
+        ),
+      );
+    });
+
+    const joinCommunityPayload = {
+      ...communityQueryResponse.data.communities[0],
+      communityId: 'joining-community',
+      isDeleted: false,
+    };
+
+    const joinedCommunity = prepareCommunityPayload({
+      ...emptyCommunityPayload,
+      communities: [joinCommunityPayload],
+    }).communities[0];
+
+    const joiningUser: Amity.RawMembership<'community'> = {
+      ...communityUser11,
+      userId: 'test',
+      communityId: 'joining-community',
+      communityMembership: 'member',
+    };
+
+    const memberEvents: [
+      string,
+      Amity.CommunityLiveCollection,
+      keyof Amity.Events,
+      Amity.CommunityPayload,
+      Amity.Community[],
+    ][] = [
+      [
+        'it should add new community to collection onJoin',
+        { membership: 'member' },
+        'community.joined',
+        {
+          ...emptyCommunityPayload,
+          communities: [joinCommunityPayload],
+          communityUsers: [joiningUser],
+        },
+        [joinedCommunity, community1],
+      ],
+      [
+        'it should not add new member to community collection onJoin if membership:not member',
+        { membership: 'notMember' },
+        'community.joined',
+        {
+          ...emptyCommunityPayload,
+          communities: [joinCommunityPayload],
+          communityUsers: [joiningUser],
+        },
+        [],
+      ],
+      [
+        'it should update community in collection onLeft',
+        { membership: 'member' },
+        'community.left',
+        { ...communityPayload, communities: [{ ...community1, isJoined: false }] },
+        [],
+      ],
+      [
+        'it should add new community in collection onLeft and if membership:not member',
+        { membership: 'notMember' },
+        'community.left',
+        { ...communityPayload, communities: [{ ...community1, isJoined: false }] },
+        [{ ...community1, isJoined: false }],
+      ],
+    ];
+
+    test.each(memberEvents)('%s', async (test, params, event, communityPayload, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(communityQueryResponsePage2);
+
+      liveCommunities(params, callback);
+      await pause();
+
+      client.emitter.emit(event, communityPayload);
+      await pause();
+
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining(
+          getSnapshot({
+            data: expected,
+            loading: false,
+          }),
+        ),
+      );
+    });
+  });
+});

package/src/community/observers/tests/liveCommunity.test.ts

@@ -0,0 +1,147 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  user11,
+  communityUser11,
+  communityUser12,
+} from '~/utils/tests';
+import { getFutureDate } from '~/core/model';
+
+import { liveCommunity } from '../liveCommunity';
+
+const { communityId } = community11;
+const response = {
+  data: {
+    communities: [community11],
+    communityUsers: [communityUser11],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('liveCommunity events', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const events: [string, keyof Amity.MqttCommunityEvents][] = [
+    ['it should get update on community.updated event', 'community.updated'],
+    ['it should get update on community.deleted event', 'community.deleted'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const update =
+      event === 'community.updated'
+        ? {
+            ...community11,
+            displayName: 'updated-name',
+            updatedAt: getFutureDate(community11.updatedAt),
+          }
+        : {
+            ...community11,
+            isDeleted: true,
+            updatedAt: getFutureDate(community11.updatedAt),
+          };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    const unsub = liveCommunity(communityId, callback);
+    await pause();
+
+    client.emitter.emit(event, {
+      communities: [update],
+      communityUsers: [],
+      categories: [],
+      feeds: [],
+      users: [user11],
+      files: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: update,
+        loading: false,
+      }),
+    );
+
+    unsub();
+  });
+
+  const communityUserEvents: [string, keyof Amity.MqttCommunityUserEvents][] = [
+    ['it should add user on community.joined event', 'community.joined'],
+    ['should get update on community.left event', 'community.left'],
+    ['should get update on community.userChanged event', 'community.userChanged'],
+    ['should get update on community.userBanned event', 'community.userBanned'],
+    ['should get update on community.userUnbanned event', 'community.userUnbanned'],
+  ];
+
+  test.each(communityUserEvents)('%s', async (test, event) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    const community = {
+      ...community11,
+      updatedAt: getFutureDate(community11.updatedAt),
+    };
+    let communityUsers: Amity.RawMembership<'community'>[];
+    let communities: Amity.RawCommunity[];
+
+    switch (event) {
+      case 'community.userChanged':
+      case 'community.left':
+        communityUsers = [communityUser11];
+        communities = [{ ...community, isJoined: true }];
+        break;
+
+      case 'community.userBanned':
+        communities = [{ ...community, isJoined: true }];
+        communityUsers = [{ ...communityUser11, communityMembership: 'banned' }];
+        break;
+
+      case 'community.userUnbanned':
+        communityUsers = [communityUser11];
+        communities = [{ ...community, isJoined: true }];
+        break;
+
+      // community.joined
+      default:
+        communities = [community];
+        communityUsers = [communityUser12];
+    }
+
+    const unsub = liveCommunity(communityId, callback);
+    await pause();
+
+    client.emitter.emit(event, {
+      communities,
+      communityUsers,
+      categories: [],
+      feeds: [],
+      users: [user11],
+      files: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: communities[0],
+      }),
+    );
+
+    unsub();
+  });
+});

package/src/community/observers/tests/liveCommunityMembers.test.ts

@@ -0,0 +1,195 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  user11,
+  user13,
+  community11,
+  communityUser11,
+  communityUser13,
+  withRoleCommunityUser,
+  bannedCommunityUser,
+  communityUserQueryResponse,
+  communityUserQueryResponsePage2,
+  convertedCommunityUser1,
+  convertedCommunityUser2,
+  convertedCommunityUser3,
+} from '~/utils/tests';
+
+import { liveCommunityMembers } from '../liveCommunityMembers';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.Membership<'community'>[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+describe('liveCommunityMembers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const { communityId } = community11;
+
+  test('it should return community members collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityUserQueryResponse);
+
+    liveCommunityMembers({ communityId }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({ data: [convertedCommunityUser2, convertedCommunityUser1], loading: false }),
+      ),
+    );
+  });
+
+  const filters: [string, Amity.CommunityMemberLiveCollection, Amity.Membership<'community'>[]][] =
+    [
+      ['roles', { communityId, roles: ['test-role'] }, [withRoleCommunityUser]],
+      [
+        'searched term',
+        { communityId, search: 'use' },
+        [withRoleCommunityUser, bannedCommunityUser],
+      ],
+      ['member', { communityId, membership: ['member'] }, [withRoleCommunityUser]],
+      ['banned members', { communityId, membership: ['banned'] }, [bannedCommunityUser]],
+    ];
+
+  test.each(filters)('it should filter channelUsers by %s', async (filter, params, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityUserQueryResponsePage2);
+
+    liveCommunityMembers(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(communityUserQueryResponse)
+      .mockResolvedValueOnce(communityUserQueryResponsePage2);
+
+    liveCommunityMembers({ communityId, sortBy: 'firstCreated' }, 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 = [convertedCommunityUser1, convertedCommunityUser2];
+    const payload2 = [withRoleCommunityUser, bannedCommunityUser];
+
+    const snapshot = getSnapshot();
+    snapshot.loading = false;
+    snapshot.data = [...payload2, ...payload];
+
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const events: [
+    string,
+    keyof Amity.Events,
+    Amity.RawMembership<'community'>,
+    Amity.User,
+    Amity.Membership<'community'>[],
+  ][] = [
+    [
+      'it should add new member to collection onJoined',
+      'community.joined',
+      communityUser13,
+      user13,
+      [convertedCommunityUser1, convertedCommunityUser3, convertedCommunityUser2],
+    ],
+    [
+      'it should remove member from collection onLeft',
+      'community.left',
+      { ...communityUser11, communityMembership: 'none' },
+      user11,
+      [{ ...convertedCommunityUser1, communityMembership: 'none' }, convertedCommunityUser2],
+    ],
+    [
+      'it should add new member to collection onMemberCountChanged',
+      'community.userChanged',
+      communityUser13,
+      user13,
+      [convertedCommunityUser1, convertedCommunityUser3, convertedCommunityUser2],
+    ],
+    [
+      'it should update member in collection onMemberCountChanged',
+      'community.userChanged',
+      { ...communityUser13, communityMembership: 'none' },
+      user13,
+      [
+        convertedCommunityUser1,
+        { ...convertedCommunityUser3, communityMembership: 'none' },
+        convertedCommunityUser2,
+      ],
+    ],
+    [
+      'it should update member membership on ban',
+      'community.userBanned',
+      { ...communityUser11, communityMembership: 'banned' },
+      user11,
+      [{ ...convertedCommunityUser1, communityMembership: 'banned' }, convertedCommunityUser2],
+    ],
+    [
+      'it should update membership on Unban',
+      'community.userUnbanned',
+      communityUser13,
+      user13,
+      [convertedCommunityUser1, convertedCommunityUser3, convertedCommunityUser2],
+    ],
+  ];
+
+  test.each(events)('%s', async (test, event, communityUserRaw, user, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityUserQueryResponse);
+
+    liveCommunityMembers({ communityId, sortBy: 'firstCreated' }, callback);
+    await pause();
+
+    client.emitter.emit(event, {
+      communities: [community11],
+      communityUsers: [communityUserRaw],
+      users: [user],
+      files: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining(
+        getSnapshot({
+          data: expected,
+          loading: false,
+        }),
+      ),
+    );
+  });
+});

package/src/community/utils/index.ts

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

package/src/community/utils/payload.ts

@@ -0,0 +1,50 @@
+import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
+import { withUsers } from '~/group/utils';
+
+const getMatchPostSetting = (value: {
+  needApprovalOnPostCreation: Amity.RawCommunity['needApprovalOnPostCreation'];
+  onlyAdminCanPost: Amity.RawCommunity['onlyAdminCanPost'];
+}): Amity.Community['postSetting'] =>
+  Object.keys(CommunityPostSettingMaps).find(
+    key =>
+      value.needApprovalOnPostCreation ===
+        CommunityPostSettingMaps[key].needApprovalOnPostCreation &&
+      value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost,
+  ) ?? DefaultCommunityPostSetting;
+
+export const prepareCommunityPayload = (
+  rawPayload: Amity.CommunityPayload,
+): Amity.ProcessedCommunityPayload => {
+  // Unpack community payload by mapping payload field to postSetting value.
+  const communities = rawPayload.communities.map<Amity.Community>(
+    ({ needApprovalOnPostCreation, onlyAdminCanPost, ...restCommunityPayload }) => ({
+      postSetting: getMatchPostSetting({
+        needApprovalOnPostCreation,
+        onlyAdminCanPost,
+      }),
+      ...restCommunityPayload,
+    }),
+  );
+
+  const communityUsers = withUsers(rawPayload.communityUsers);
+
+  return {
+    ...rawPayload,
+    communities,
+    communityUsers,
+  };
+};
+
+export const prepareCommunityRequest = <
+  T extends { postSetting?: Amity.Community['postSetting']; [k: string]: any },
+>(
+  params: T,
+) => {
+  const { postSetting = undefined, ...restParam } = params;
+
+  return {
+    ...restParam,
+    // Repack community payload by mapping postSetting to the actual value.
+    ...(postSetting ? CommunityPostSettingMaps[postSetting] : undefined),
+  };
+};