@amityco/ts-sdk 0.0.1-beta.27 → 0.0.1-beta.29

package/src/client/api/index.ts

@@ -6,3 +6,5 @@ export * from './connectClient';
 export * from './disconnectClient';
 
 export * from './isConnected';
+
+export * from './getFeedSettings';

package/src/community/api/createCommunity.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+import { packCommunityPayload, unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { createCommunity } from '@amityco/ts-sdk'
@@ -25,8 +27,7 @@ export const createCommunity = async (
     | 'description'
     | 'isPublic'
     | 'isOfficial'
-    | 'onlyAdminCanPost'
-    | 'needApprovalOnPostCreation'
+    | 'postSetting'
     | 'tags'
     | 'metadata'
   > & {
@@ -38,7 +39,12 @@ export const createCommunity = async (
   const client = getActiveClient();
   client.log('user/createCommunity', bundle);
 
-  const { data } = await client.http.post<Amity.CommunityPayload>('/api/v3/communities/', bundle);
+  const { data: payload } = await client.http.post<Amity.CommunityPayload>(
+    '/api/v3/communities/',
+    packCommunityPayload(bundle),
+  );
+
+  const data = unpackCommunityPayload(payload);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/community/api/getCommunities.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { getCommunities } from '@amityco/ts-sdk'
@@ -24,9 +26,14 @@ export const getCommunities = async (
   client.log('community/getCommunities', communityIds);
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.CommunityPayload>(`/api/v3/communities/list`, {
-    params: { communityIds },
-  });
+  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
+    `/api/v3/communities/list`,
+    {
+      params: { communityIds },
+    },
+  );
+
+  const data = unpackCommunityPayload(payload);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/community/api/getCommunity.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { getCommunity } from '@amityco/ts-sdk'
@@ -24,10 +26,12 @@ export const getCommunity = async (
   client.log('community/getCommunity', communityId);
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.CommunityPayload>(
+  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/${communityId}`,
   );
 
+  const data = unpackCommunityPayload(payload);
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 

package/src/community/api/getRecommendedCommunities.ts

@@ -4,6 +4,8 @@ import { getResolver } from '~/core/model';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { getRecommendedCommunities } from '@amityco/ts-sdk'
@@ -27,12 +29,13 @@ export const getRecommendedCommunities = async (
   const { limit = 5 } = query ?? {};
 
   // API-FIX: backend doesnt answer Amity.Response
-  // const { data } = await client.http.get<Amity.Response<CommunityPayload>>(
-  const { data } = await client.http.get<Amity.CommunityPayload>(
+  // const { data: payload } = await client.http.get<Amity.Response<CommunityPayload>>(
+  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/recommended`,
     { params: { options: { limit } } },
   );
 
+  const data = unpackCommunityPayload(payload);
   const { communities } = data;
 
   const cachedAt = client.cache && Date.now();

package/src/community/api/getTopTrendingCommunities.ts

@@ -4,6 +4,8 @@ import { getResolver } from '~/core/model';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { getTopTrendingCommunities } from '@amityco/ts-sdk'
@@ -28,11 +30,12 @@ export const getTopTrendingCommunities = async (
 
   // API-FIX: backend doesnt answer Amity.Response
   // const { data } = await client.http.get<Amity.Response<CommunityPayload>>(
-  const { data } = await client.http.get<Amity.CommunityPayload>(
+  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/top-trending`,
     { params: { options: { limit } } },
   );
 
+  const data = unpackCommunityPayload(payload);
   const { communities } = data;
 
   const cachedAt = client.cache && Date.now();

package/src/community/api/queryCommunities.ts

@@ -5,6 +5,8 @@ import { pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
+import { unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { queryCommunities } from '@amityco/ts-sdk'
@@ -54,12 +56,13 @@ export const queryCommunities = async (query?: {
   );
 
   const { paging, ...payload } = data;
-  const { communities } = payload;
+  const unpackedPayload = unpackCommunityPayload(payload);
+  const { communities } = unpackedPayload;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.CommunityPayload, { cachedAt });
+    ingestInCache(unpackedPayload as Amity.CommunityPayload, { cachedAt });
 
     const cacheKey = [
       'community',

package/src/community/api/updateCommunity.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+import { packCommunityPayload, unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { updateCommunity } from '@amityco/ts-sdk'
@@ -22,17 +24,19 @@ export const updateCommunity = async (
   communityId: Amity.Community['communityId'],
   patch: Patch<
     Amity.Community,
-    'displayName' | 'description' | 'avatarFileId' | 'tags' | 'metadata'
+    'displayName' | 'description' | 'avatarFileId' | 'postSetting' | 'tags' | 'metadata'
   >,
 ): Promise<Amity.Cached<Amity.Community>> => {
   const client = getActiveClient();
   client.log('community/updateCommunity', communityId, patch);
 
-  const { data } = await client.http.put<Amity.CommunityPayload>(
+  const { data: payload } = await client.http.put<Amity.CommunityPayload>(
     `/api/v3/communities/${communityId}`,
-    patch,
+    packCommunityPayload(patch),
   );
 
+  const data = unpackCommunityPayload(payload);
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 

package/src/community/events/utils.ts

@@ -4,6 +4,8 @@ import { createEventSubscriber } from '~/core/events';
 import { pullFromCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
 
+import { unpackCommunityPayload } from '../utils';
+
 export const createCommunityEventSubscriber = (
   event: keyof Amity.MqttCommunityMessageEvents,
   callback: Amity.Listener<Amity.Community>,
@@ -11,16 +13,18 @@ export const createCommunityEventSubscriber = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.CommunityPayload) => {
+    const unpackedPayload = unpackCommunityPayload(payload);
+
     if (!client.cache) {
       // TODO: here we are missing specific properties here!
-      callback(payload.communities[0]);
+      callback(unpackedPayload.communities[0]);
     } else {
-      ingestInCache(payload);
+      ingestInCache(unpackedPayload);
 
       const community = pullFromCache<Amity.Community>([
         'community',
         'get',
-        payload.communities[0].communityId,
+        unpackedPayload.communities[0].communityId,
       ])!;
 
       callback(community.data);
@@ -77,21 +81,23 @@ export const createCommunityMemberEventSubscriber = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.CommunityMembershipPayload) => {
+    const unpackedPayload = unpackCommunityPayload(payload);
+
     if (!client.cache) {
       // TODO: here we are missing specific properties here!
-      callback(payload.communities[0], getEventRelatedMember(event, payload));
+      callback(unpackedPayload.communities[0], getEventRelatedMember(event, unpackedPayload));
     } else {
-      ingestInCache(payload);
+      ingestInCache(unpackedPayload);
 
       const community = pullFromCache<Amity.Community>([
         'community',
         'get',
-        payload.communities[0].communityId,
+        unpackedPayload.communities[0].communityId,
       ])!;
       const member = pullFromCache<Amity.Membership<'community'>>([
         'communityUsers',
         'get',
-        getResolver('communityUsers')(getEventRelatedMember(event, payload)),
+        getResolver('communityUsers')(getEventRelatedMember(event, unpackedPayload)),
       ])!;
 
       callback(community.data, member.data);

package/src/community/utils/index.ts

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

package/src/community/utils/payload.ts

@@ -0,0 +1,44 @@
+import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
+
+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;
+
+/*
+ * 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>(
+    ({ needApprovalOnPostCreation, onlyAdminCanPost, ...restCommunityPayload }) => ({
+      postSetting: getMatchPostSetting({
+        needApprovalOnPostCreation,
+        onlyAdminCanPost,
+      }),
+      ...restCommunityPayload,
+    }),
+  ),
+  ...restPayload,
+});
+
+/*
+ * Repack community payload by mapping postSetting to the actual value.
+ */
+export const packCommunityPayload = <
+  T extends { postSetting?: Amity.Community['postSetting']; [k: string]: any },
+>({
+  postSetting = undefined,
+  ...restParam
+}: T) => ({
+  ...restParam,
+  ...(postSetting ? CommunityPostSettingMaps[postSetting] : undefined),
+});

package/src/core/events.ts

@@ -13,8 +13,9 @@ const WS_EVENTS = [
   'reconnect_error',
   'reconnect_failed',
 
+  'v3.channel.didCreate',
   'v3.channel.didUpdate',
-  'v3.channel.didUpdate',
+  'v3.channel.didDelete',
   'v3.channel.didJoin',
   'v3.channel.didLeave',
   'v3.channel.didAddUsers',

package/src/core/model/identifyModel.ts

@@ -26,7 +26,7 @@ const CRITERIAS: Criterias = {
   channel: ['channelId', 'rateLimit'],
   channelUsers: ['channelId', 'userId', 'membership'],
   message: ['messageId'],
-  community: ['communityId', 'onlyAdminCanPost'],
+  community: ['communityId', 'postSetting'],
   category: ['categoryId'],
   communityUsers: ['userId', 'communityId', 'communityMembership'],
   post: ['postId', 'feedId'],

package/src/core/query/query.ts

@@ -85,7 +85,7 @@ export const isFresh = (model?: Amity.Cachable, lifeSpan = 0) => {
  * This wrapper is necessary to create for optimistically calls
  *
  *
- * @param fn A compatible API function from the ts sdk
+ * @param func A compatible API function from the ts sdk
  * @param args The arguments to pass to the function passed as `fn`
  * @returns A wrapper containing both the function and its future arguments
  *
@@ -221,8 +221,8 @@ export const runQuery = <Args extends any[], Returned extends any>(
        * the modal key in the param itself
        * For update & delete the first argument is always an id which is of type
        * string, whereas for create the first and only argument is the param object
-       * 
-       * When creating an AmityObject optimistically we need to pass the modal key 
+       *
+       * When creating an AmityObject optimistically we need to pass the modal key
        * on to the server. ex: for create message modal key will be 'messageId`
        */
       if (typeof args[0] !== 'string') {

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

@@ -0,0 +1,182 @@
+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 } from '~/utils/tests';
+
+const createPostArgs: Parameters<typeof createPost> = [
+  {
+    tags: ['a', 'b'],
+    data: {
+      text: 'hello!',
+    },
+    targetType: 'user',
+    targetId: 'userId1',
+  },
+];
+const post = { postId: posts.page1[0] };
+const deletingMsgId = 'deletingId';
+
+describe('Core/Query/runQuery', () => {
+  test('should call query with arguments', () => {
+    const createPostMock = jest.fn().mockResolvedValue('test');
+
+    const query = createQuery(createPostMock, createPostArgs);
+    runQuery(query);
+
+    expect(createPostMock).toBeCalledTimes(1);
+  });
+
+  test('should call callback with cache when valid', () => {
+    enableCache();
+
+    const callback = jest.fn();
+
+    const cachedAt = Date.now();
+    pushToCache(['post', 'get', post.postId], post, { cachedAt });
+
+    const query = createQuery(getPost, post.postId);
+    runQuery(query, callback);
+
+    expect(callback).toBeCalled();
+    expect(callback).toBeCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith({
+      cachedAt,
+      origin: 'local',
+      loading: false,
+      data: post,
+    });
+
+    disableCache();
+  });
+
+  test('should call callback with server data for invalid cache', async () => {
+    enableCache();
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({ data: { 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');
+    pushToCache(['post', 'get', post.postId], post, { cachedAt: expiredDate });
+
+    const query = createQuery(getPost, post.postId);
+    runQuery(query, callback);
+
+    expect(callback).toHaveBeenCalledWith({
+      cachedAt: expiredDate,
+      origin: 'local',
+      loading: true,
+      data: post,
+    });
+
+    await expect(getPost(post.postId)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    // checking object containing as expiredAt cannot be predicted :D
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        origin: 'server',
+        loading: false,
+        data: post,
+      }),
+    );
+
+    disableCache();
+  });
+
+  test('should execute mutators optimistically', () => {
+    enableCache();
+
+    const createMessage: any = jest.fn().mockResolvedValue('test');
+    // mutators are defined as having a property called optimistically
+    createMessage.optimistically = jest.fn();
+
+    const query = createQuery(createMessage);
+    runQuery(query);
+
+    expect(createMessage.optimistically).toHaveBeenCalled();
+    // should call server right after
+    expect(createMessage).toHaveBeenCalled();
+
+    disableCache();
+  });
+
+  /*
+   * NOTE: del not tested as the args are exactly the same as update
+   *
+   * Tested due to bug where optimistic args was modifying args for del &
+   * update when it does not need to
+   */
+  test('should not change args optimistically for update', () => {
+    enableCache();
+
+    client.http.delete = jest.fn().mockResolvedValue(true);
+    // 'get', gets called after delete to verify delete
+    client.http.get = jest.fn();
+
+    const query = createQuery(deleteMessage, deletingMsgId);
+    runQuery(query);
+
+    expect(client.http.delete).toHaveBeenCalledWith(`/api/v3/messages/${deletingMsgId}`);
+
+    disableCache();
+  });
+
+  test('should throw error if optimistic execution fails', async () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const createMessage: any = jest.fn().mockResolvedValue('test');
+    // mutators are defined as having a property called optimistically
+    createMessage.optimistically = jest.fn().mockImplementation(() => {
+      throw new Error();
+    });
+
+    const query = createQuery(createMessage);
+    runQuery(query, callback);
+
+    expect(createMessage.optimistically).toThrow();
+    expect(callback).toBeCalledWith({
+      origin: 'local',
+      loading: true,
+      data: undefined,
+    });
+
+    disableCache();
+  });
+
+  test('should return error if call to server fails', async () => {
+    enableCache();
+
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+    const callback = jest.fn();
+
+    const query = createQuery(deleteMessage, deletingMsgId);
+    runQuery(query, callback);
+
+    expect(callback).toHaveBeenCalledWith({
+      origin: 'local',
+      loading: true,
+      data: undefined,
+    });
+
+    await expect(deleteMessage(deletingMsgId)).rejects.toThrow();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        origin: 'server',
+        loading: false,
+      }),
+    );
+
+    disableCache();
+  });
+});

package/src/file/api/createVideo.ts

@@ -11,6 +11,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * Creates an {@link Amity.File<'video'>}
  *
  * @param formData The data necessary to create a new {@link Amity.File<'video'>}
+ * @param feedType The {@link Amity.File<'video'>} feed type
  * @param onProgress The callback to track the upload progress
  * @returns The newly created {@link Amity.File<'video'>}
  *
@@ -19,6 +20,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const createVideo = async (
   formData: FormData,
+  feedType?: Amity.ContentFeedType,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File<'video'>[]>> => {
   const client = getActiveClient();
@@ -27,6 +29,10 @@ export const createVideo = async (
   if (!formData.getAll('files').length)
     throw new Error('The formData object must have a `files` key.');
 
+  if (feedType) {
+    formData.append('feedType', feedType);
+  }
+
   const headers =
     'getHeaders' in formData
       ? (formData as any).getHeaders()

package/src/follow/api/queryFollowers.ts

@@ -14,11 +14,9 @@ import { queryFollows } from './utils';
  * @category Follow API
  * @async
  */
-export const queryFollowers = async (query: {
-  userId: Amity.User['userId'];
-  status?: Exclude<Amity.FollowStatusType, 'none'>;
-  page?: Amity.PageRaw;
-}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+export const queryFollowers = async (
+  query: Amity.QueryFollowers,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
   queryFollows('followers', query);
 
 /**

package/src/follow/api/queryFollowings.ts

@@ -14,11 +14,9 @@ import { queryFollows } from './utils';
  * @category Follow API
  * @async
  */
-export const queryFollowings = async (query: {
-  userId: Amity.User['userId'];
-  status?: Exclude<Amity.FollowStatusType, 'none'>;
-  page?: Amity.PageRaw;
-}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+export const queryFollowings = async (
+  query: Amity.QueryFollowings,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
   queryFollows('following', query);
 
 /**

package/src/follow/api/utils.ts

@@ -36,9 +36,9 @@ export const queryFollows = async (
     ingestInCache(payload as Amity.FollowersPayload, { cachedAt });
 
     const cacheKey = [
-      key,
+      'follow',
       'query',
-      { ...params, userId, options: { ...page } } as Amity.Serializable,
+      { ...params, userId, options: { ...page }, type: key } as Amity.Serializable,
     ];
     pushToCache(cacheKey, { follows: follows.map(getResolver('follow')), paging });
   }
@@ -60,7 +60,11 @@ queryFollows.locally = (
 
   const { page, ...params } = query;
 
-  const queryKey = [key, 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const queryKey = [
+    'follow',
+    'query',
+    { ...params, options: { ...page }, type: key } as Amity.Serializable,
+  ];
   const { data, cachedAt } =
     pullFromCache<{ follows: string[] } & Amity.Pagination>(queryKey) ?? {};
 

package/src/follow/observers/index.ts

@@ -1,3 +1,6 @@
 export * from './observeFollowInfo';
 export * from './observeFollowers';
 export * from './observeFollowings';
+
+export * from './liveFollowers';
+export * from './liveFollowings';