@amityco/ts-sdk 0.0.1-beta.39 → 0.0.1-beta.40

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

@@ -7,11 +7,11 @@ import {
   disconnectClient,
   pause,
   communityUser11,
+  emptyCommunityPayload,
 } from '~/utils/tests';
 
 import { liveCommunities } from '../liveCommunities';
-
-import { unpackCommunityPayload } from '../../utils';
+import { prepareCommunityPayload } from '../../utils';
 
 const getSnapshot = (params?: Record<string, any>) => {
   return {
@@ -23,10 +23,9 @@ const getSnapshot = (params?: Record<string, any>) => {
 };
 
 const { paging, ...payload } = communityQueryResponse.data;
-const { paging: paging2, ...payload2 } = communityQueryResponsePage2.data;
 
-const community1 = unpackCommunityPayload(payload).communities[0];
-const community2 = unpackCommunityPayload(payload).communities[1];
+const community1 = prepareCommunityPayload(payload).communities[0];
+const community2 = prepareCommunityPayload(payload).communities[1];
 
 describe('liveCommunities', () => {
   beforeAll(connectClient);
@@ -49,7 +48,7 @@ describe('liveCommunities', () => {
       2,
       expect.objectContaining(
         getSnapshot({
-          data: unpackCommunityPayload(payload).communities,
+          data: prepareCommunityPayload(payload).communities,
           loading: false,
         }),
       ),
@@ -70,7 +69,7 @@ describe('liveCommunities', () => {
       1,
       expect.objectContaining(
         getSnapshot({
-          data: unpackCommunityPayload(payload).communities,
+          data: prepareCommunityPayload(payload).communities,
         }),
       ),
     );
@@ -78,7 +77,7 @@ describe('liveCommunities', () => {
       2,
       expect.objectContaining(
         getSnapshot({
-          data: unpackCommunityPayload(payload).communities,
+          data: prepareCommunityPayload(payload).communities,
           loading: false,
         }),
       ),
@@ -146,7 +145,7 @@ describe('liveCommunities', () => {
       expect.objectContaining(
         getSnapshot({
           loading: false,
-          data: unpackCommunityPayload(payload).communities,
+          data: prepareCommunityPayload(payload).communities,
         }),
       ),
     );
@@ -158,10 +157,14 @@ describe('liveCommunities', () => {
       communityId: 'new-community',
       isDeleted: false,
     };
-    const newCommunity = unpackCommunityPayload({ communities: [newCommunityPayload] })
-      .communities[0];
+
+    const newCommunity = prepareCommunityPayload({
+      ...emptyCommunityPayload,
+      communities: [newCommunityPayload],
+    }).communities[0];
 
     const communityPayload = {
+      ...emptyCommunityPayload,
       communities: [communityQueryResponse.data.communities[0]],
       communityUsers: [communityUser11],
     };
@@ -170,13 +173,19 @@ describe('liveCommunities', () => {
       [
         'it should add new community to collection onCreate',
         'community.created',
-        { communities: [newCommunityPayload] },
+        {
+          ...emptyCommunityPayload,
+          communities: [newCommunityPayload],
+        },
         [newCommunity, community2],
       ],
       [
         'it should update community in collection onUpdate',
         'community.updated',
-        { communities: [{ ...newCommunityPayload, communityId: community1.communityId }] },
+        {
+          ...emptyCommunityPayload,
+          communities: [{ ...newCommunityPayload, communityId: community1.communityId }],
+        },
         [{ ...newCommunity, communityId: community1.communityId }, community2],
       ],
       [
@@ -213,10 +222,13 @@ describe('liveCommunities', () => {
       communityId: 'joining-community',
       isDeleted: false,
     };
-    const joinedCommunity = unpackCommunityPayload({ communities: [joinCommunityPayload] })
-      .communities[0];
 
-    const joiningUser: Amity.MembershipRaw<'community'> = {
+    const joinedCommunity = prepareCommunityPayload({
+      ...emptyCommunityPayload,
+      communities: [joinCommunityPayload],
+    }).communities[0];
+
+    const joiningUser: Amity.RawMembership<'community'> = {
       ...communityUser11,
       userId: 'test',
       communityId: 'joining-community',
@@ -234,14 +246,22 @@ describe('liveCommunities', () => {
         'it should add new community to collection onJoin',
         { membership: 'member' },
         'community.joined',
-        { communities: [joinCommunityPayload], communityUsers: [joiningUser] },
+        {
+          ...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',
-        { communities: [joinCommunityPayload], communityUsers: [joiningUser] },
+        {
+          ...emptyCommunityPayload,
+          communities: [joinCommunityPayload],
+          communityUsers: [joiningUser],
+        },
         [],
       ],
       [

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/payload.ts

@@ -1,4 +1,5 @@
 import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
+import { withUsers } from '~/group/utils';
 
 const getMatchPostSetting = (value: {
   needApprovalOnPostCreation: Amity.RawCommunity['needApprovalOnPostCreation'];
@@ -11,14 +12,11 @@ const getMatchPostSetting = (value: {
       value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost,
   ) ?? DefaultCommunityPostSetting;
 
-/*
- * Unpack community payload by mapping payload field to postSetting value.
- */
-export const unpackCommunityPayload = <T extends Amity.CommunityPayload>({
-  communities,
-  ...restPayload
-}: T) => ({
-  communities: communities.map<Amity.Community>(
+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,
@@ -26,19 +24,27 @@ export const unpackCommunityPayload = <T extends Amity.CommunityPayload>({
       }),
       ...restCommunityPayload,
     }),
-  ),
-  ...restPayload,
-});
+  );
 
-/*
- * Repack community payload by mapping postSetting to the actual value.
- */
-export const packCommunityPayload = <
+  const communityUsers = withUsers(rawPayload.communityUsers);
+
+  return {
+    ...rawPayload,
+    communities,
+    communityUsers,
+  };
+};
+
+export const prepareCommunityRequest = <
   T extends { postSetting?: Amity.Community['postSetting']; [k: string]: any },
->({
-  postSetting = undefined,
-  ...restParam
-}: T) => ({
-  ...restParam,
-  ...(postSetting ? CommunityPostSettingMaps[postSetting] : undefined),
-});
+>(
+  params: T,
+) => {
+  const { postSetting = undefined, ...restParam } = params;
+
+  return {
+    ...restParam,
+    // Repack community payload by mapping postSetting to the actual value.
+    ...(postSetting ? CommunityPostSettingMaps[postSetting] : undefined),
+  };
+};

package/src/core/device.ts

@@ -1,9 +1,7 @@
 // TODO: find a way to uniquely identify the device
 // import { getStorage } from './storage'
 import { safeProcess } from '~/utils/env';
-
-/** @hidden */
-const VERSION = '11.0.0';
+import { VERSION } from '~/version';
 
 /** @hidden */
 export const getDeviceId = () => {
@@ -30,9 +28,9 @@ export const getDeviceInfo = (): Amity.Device['deviceInfo'] => {
   const model = getDeviceModel();
 
   return {
-    version: VERSION,
     // TODO: replace with: kind: process.versions ? 'node' : 'web', when backend has fixed this
     kind: 'web',
     model,
+    sdkVersion: VERSION,
   };
 };

package/src/core/model/idResolvers.ts

@@ -4,8 +4,9 @@
  * to avoid using any and give some typing security at the
  * resolver's level.
  */
-type Resolvers<T extends Amity.Domain[] = Amity.Domain[]> = {
-  [K in T[number]]: (model: Amity.Minimal[K]) => string;
+type Resolver<T extends Amity.Domain> = (model: Amity.Minimal[T]) => string;
+type Resolvers<T extends Amity.Domain = Amity.Domain> = {
+  [K in T]: Resolver<K>;
 };
 
 /** @hidden */
@@ -41,4 +42,4 @@ const idResolvers: Resolvers = {
  * @param name the domain name for the resolve
  * @returns an idResolver function for the given domain name
  */
-export const getResolver = <T extends Amity.Domain>(name: T): Resolvers[T] => idResolvers[name];
+export const getResolver = <T extends Amity.Domain>(name: T): Resolver<T> => idResolvers[name];

package/src/core/model/identifyModel.ts

@@ -5,8 +5,8 @@
  * adding new models.
  * @hidden
  */
-type Criterias<T extends Amity.Domain[] = Amity.Domain[]> = {
-  [K in T[number]]: (keyof Amity.Model[K])[];
+type Criterias<T extends Amity.Domain = Amity.Domain> = {
+  [K in T]: (keyof Amity.Models[K])[];
 };
 
 /**
@@ -49,7 +49,7 @@ const hasKeys = (object: Record<string, unknown>, needles: string[]) => {
 /**
  * Finds the name of the store for a given unknown model
  *
- * @param model one of the {@link Amity.Model} to identify
+ * @param model one of the {@link Amity.Models} to identify
  * @returns the name of the corresponding store
  */
 export const identifyModel = (model: Record<string, unknown>) => {

package/src/core/model/index.ts

@@ -23,6 +23,7 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   comments: 'comment',
   polls: 'poll',
   reactions: 'reaction',
+
   videoStreamings: 'stream',
 
   follows: 'follow',

package/src/core/query/query.ts

@@ -165,6 +165,13 @@ export const runQuery = <Args extends any[], Returned extends any>(
   callback?: (args: Amity.Snapshot<Returned>) => void,
   options: Amity.QueryOptions = queryOptions('cache_then_server'),
 ) => {
+  console.warn(
+    'Deprecation Notice: After 1 April 2023, CreateQuery/RunQuery will no longer be supported. You will be able to use the API without either methods. Check https://docs.amity.co/ for details',
+  );
+  console.warn(
+    'Deprecation Notice: After 1 March 2023, individual module imoprts will no longer be supported. All public APIs will need to be imported from their respective repositories. Ex: CommunityRepository, UserRepository, etc. Check https://docs.amity.co/ for detailed info.',
+  );
+
   let local: Returned | undefined;
 
   const { lifeSpan } = queryOptions('cache_then_server', options.lifeSpan);

package/src/core/tests/query/query/runQuery.test.ts

@@ -1,10 +1,10 @@
-import { ASCApiError, ASCError } from '~/core/errors';
+import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache, pushToCache } from '~/cache/api';
 import { runQuery, createQuery } from '~/core/query';
 import { createPost, getPost } from '~/post/api';
 import { deleteMessage } from '~/message/api';
 
-import { posts, client, pause } from '~/utils/tests';
+import { posts, client, pause, emptyPostPayload } from '~/utils/tests';
 
 const createPostArgs: Parameters<typeof createPost> = [
   {
@@ -54,7 +54,12 @@ describe('Core/Query/runQuery', () => {
 
   test('should call callback with server data for invalid cache', async () => {
     const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue({ data: { posts: [post] } });
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        ...emptyPostPayload,
+        posts: [post],
+      },
+    });
 
     // at the time of writing this test, cache is valid for 2 minutes
     const expiredDate = Date.parse('04 Dec 1995 00:12:00 GMT');