@amityco/ts-sdk 0.0.1-beta.32 → 0.0.1-beta.36

package/src/core/subscription.ts

@@ -27,6 +27,8 @@ const getCommunityUserTopic = (
   }
 };
 
+const getNetworkId = (user: { path: string }): string => user.path.split('/user/')[0];
+
 export const getCommunityTopic = (
   { path }: Amity.Subscribable,
   level: Exclude<SubscriptionLevels, SubscriptionLevels.USER> = SubscriptionLevels.COMMUNITY,
@@ -60,26 +62,62 @@ export const getCommentTopic = ({ path }: Amity.Subscribable): string => {
 export const getMyFollowersTopic = (): string => {
   const user = getActiveUser();
 
-  const [networkId] = user.path.split('/user/');
-
-  return `${networkId}/membership/${user._id}/+/+`;
+  return `${getNetworkId(user)}/membership/${user._id}/+/+`;
 };
 
 export const getMyFollowingsTopic = (): string => {
   const user = getActiveUser();
 
-  const [networkId] = user.path.split('/user/');
-
-  return `${networkId}/membership/+/${user._id}/+`;
+  return `${getNetworkId(user)}/membership/+/${user._id}/+`;
 };
 
-/** @hidden */
+export const getChannelTopic = (channel: Amity.Subscribable): string => `${channel.path}/#`;
+
+export const getSubChannelTopic = (subChannel: Amity.Subscribable): string =>
+  `${subChannel.path}/#`;
+
+export const getMessageTopic = (message: Amity.Subscribable): string => message.path;
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to network level events like 'user is deleted from the network'
+ */
 export const getNetworkTopic = (): string => {
+  return getNetworkId(getActiveUser());
+};
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to channel events for 'conversation', 'community' channel
+ */
+export const getSmartFeedChannelTopic = (): string => {
   const user = getActiveUser();
 
-  const [networkId] = user.path.split('/user/');
+  return `${getNetworkId(user)}/smartfeed/${user._id}/channels`;
+};
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to sub channel events for 'conversation', 'community' channel
+ */
+export const getSmartFeedSubChannelTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/smartfeed/${user._id}/messagefeeds`;
+};
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to message events for 'conversation', 'community' channel
+ */
+export const getSmartFeedMessageTopic = (): string => {
+  const user = getActiveUser();
 
-  return networkId;
+  return `${getNetworkId(user)}/smartfeed/${user._id}/messages`;
 };
 
 let mqttAccessToken: string;

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

@@ -1,10 +1,10 @@
-import { ASCApiError } from '~/core/errors';
+import { ASCApiError, ASCError } 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';
+import { posts, client, pause } from '~/utils/tests';
 
 const createPostArgs: Parameters<typeof createPost> = [
   {
@@ -20,6 +20,10 @@ const post = { postId: posts.page1[0] };
 const deletingMsgId = 'deletingId';
 
 describe('Core/Query/runQuery', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
   test('should call query with arguments', () => {
     const createPostMock = jest.fn().mockResolvedValue('test');
 
@@ -30,8 +34,6 @@ describe('Core/Query/runQuery', () => {
   });
 
   test('should call callback with cache when valid', () => {
-    enableCache();
-
     const callback = jest.fn();
 
     const cachedAt = Date.now();
@@ -48,13 +50,9 @@ describe('Core/Query/runQuery', () => {
       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] } });
 
@@ -83,13 +81,9 @@ describe('Core/Query/runQuery', () => {
         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();
@@ -100,8 +94,6 @@ describe('Core/Query/runQuery', () => {
     expect(createMessage.optimistically).toHaveBeenCalled();
     // should call server right after
     expect(createMessage).toHaveBeenCalled();
-
-    disableCache();
   });
 
   /*
@@ -111,8 +103,6 @@ describe('Core/Query/runQuery', () => {
    * 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();
@@ -120,14 +110,10 @@ describe('Core/Query/runQuery', () => {
     const query = createQuery(deleteMessage, deletingMsgId);
     runQuery(query);
 
-    expect(client.http.delete).toHaveBeenCalledWith(`/api/v3/messages/${deletingMsgId}`);
-
-    disableCache();
+    expect(client.http.delete).toHaveBeenCalledWith(`/api/v5/messages/${deletingMsgId}`);
   });
 
   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
@@ -144,13 +130,9 @@ describe('Core/Query/runQuery', () => {
       loading: true,
       data: undefined,
     });
-
-    disableCache();
   });
 
   test('should return error if call to server fails', async () => {
-    enableCache();
-
     client.http.delete = jest
       .fn()
       .mockRejectedValueOnce(
@@ -160,23 +142,18 @@ describe('Core/Query/runQuery', () => {
 
     const query = createQuery(deleteMessage, deletingMsgId);
     runQuery(query, callback);
+    await pause();
 
-    expect(callback).toHaveBeenCalledWith({
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, {
       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();
+    expect(callback).toHaveBeenNthCalledWith(2, {
+      origin: 'server',
+      loading: false,
+      error: expect.any(Error),
+    });
   });
 });

package/src/core/tests/subscription.test.ts

@@ -0,0 +1,15 @@
+import { getChannelTopic, getMessageTopic } from '../subscription';
+
+describe('Subscription', () => {
+  test('should generate channel topic', () => {
+    const channel = { path: 'channel-path' };
+
+    expect(getChannelTopic(channel)).toEqual('channel-path/#');
+  });
+
+  test('should generate channel topic', () => {
+    const message = { path: 'message-path' };
+
+    expect(getMessageTopic(message)).toEqual('message-path');
+  });
+});

package/src/feed/api/queryGlobalFeed.ts

@@ -78,7 +78,7 @@ export const queryGlobalFeed = async (query?: {
  * @async
  * */
 queryGlobalFeed.locally = (
-  query: Parameters<typeof queryGlobalFeed>[0],
+  query?: Parameters<typeof queryGlobalFeed>[0],
 ): Amity.Cached<Amity.Paged<Amity.Post>> | undefined => {
   const client = getActiveClient();
   client.log('post/queryGlobalFeed.locally', query);

package/src/feed/api/test/queryGlobalFeed.test.ts

@@ -0,0 +1,138 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { client, post11, post12 } from '~/utils/tests';
+
+import { queryGlobalFeed } from '../queryGlobalFeed';
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const postsToQuery = [post11, post12];
+const postIdsToQuery = postsToQuery.map(post => post.postId);
+const pagingCriteria = { limit: 10 };
+const queryCriteriaWithoutPage = { useCustomRanking: false };
+const queryCriteria = { ...queryCriteriaWithoutPage, page: pagingCriteria };
+
+const resolvedQueryFeedValue = {
+  data: {
+    posts: postsToQuery,
+    postChildren: [],
+    categories: [],
+    comments: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    polls: [],
+    users: [],
+    paging: pagingToken,
+  },
+};
+
+describe('queryGlobalFeed', () => {
+  test('should return fetched feed with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedQueryFeedValue);
+
+    await expect(queryGlobalFeed(queryCriteria)).resolves.toEqual(
+      expect.objectContaining({
+        data: postsToQuery,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should accept undefined query param', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedQueryFeedValue);
+
+    await expect(queryGlobalFeed()).resolves.not.toThrow();
+  });
+
+  test('should update cache after fetching feed', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedQueryFeedValue);
+
+    await queryGlobalFeed(queryCriteria);
+
+    const recieved = pullFromCache([
+      'globalFeed',
+      'query',
+      { ...queryCriteriaWithoutPage, options: pagingCriteria },
+    ])?.data;
+
+    expect(recieved).toEqual({
+      posts: postIdsToQuery,
+      paging: pagingToken,
+    });
+
+    disableCache();
+  });
+
+  test('should switch endpoint correctly according to the `useCustomRanking` condition', async () => {
+    expect.assertions(2);
+    const resolver = jest.fn().mockResolvedValue(resolvedQueryFeedValue);
+    client.http.get = resolver;
+
+    await queryGlobalFeed({ ...queryCriteria, useCustomRanking: true });
+
+    expect(resolver).toHaveBeenCalledWith(`/api/v5/me/global-feeds`, expect.any(Object));
+
+    await queryGlobalFeed({ ...queryCriteria, useCustomRanking: false });
+
+    expect(resolver).toHaveBeenCalledWith(`/api/v4/me/global-feeds`, expect.any(Object));
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryGlobalFeed(queryCriteria)).rejects.toThrow('error');
+  });
+});
+
+describe('queryGlobalFeed.locally', () => {
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  test('should return cached feed', () => {
+    postsToQuery.forEach(post => pushToCache(['post', 'get', post.postId], post));
+
+    pushToCache(['globalFeed', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+      posts: postIdsToQuery,
+      paging: pagingToken,
+    });
+
+    expect(queryGlobalFeed.locally(queryCriteria)).toEqual(
+      expect.objectContaining({
+        data: postsToQuery,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should accept undefined query param', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedQueryFeedValue);
+
+    expect(() => queryGlobalFeed.locally()).not.toThrow();
+  });
+
+  test(`shouldn't return if individual feed cache not exist`, () => {
+    pushToCache(['globalFeed', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+      posts: postIdsToQuery,
+      paging: pagingToken,
+    });
+
+    expect(queryGlobalFeed.locally(queryCriteria)).toBeUndefined();
+  });
+
+  test('it should return undefined if feed not in cache', () => {
+    expect(queryGlobalFeed.locally({})).toBeUndefined();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(queryGlobalFeed.locally({})).toBeUndefined();
+  });
+});

package/src/follow/events/utils.ts

@@ -4,7 +4,7 @@ import { createEventSubscriber } from '~/core/events';
 import { queryCache, upsertInCache } from '~/cache/api';
 
 export const createFollowEventSubscriber = (
-  event: keyof Amity.MqttFollowMessageEvents,
+  event: keyof Amity.MqttFollowEvents,
   callback: Amity.Listener<Amity.FollowStatus>,
 ) => {
   const client = getActiveClient();

package/src/follow/observers/liveFollowers.ts

@@ -80,7 +80,7 @@ export const liveFollowers = (
     });
   };
 
-  const realtimeRouter = (followStatus: Amity.FollowStatus, action: Amity.FollowActionType) => {
+  const realtimeRouter = (action: Amity.FollowActionType) => (followStatus: Amity.FollowStatus) => {
     const collection = pullFromCache<Amity.FollowerLiveCollectionCache>(cacheKey)?.data;
 
     if (params.userId !== followStatus.to || !collection) return;
@@ -131,13 +131,13 @@ export const liveFollowers = (
   };
 
   disposers.push(
-    onFollowerRequested(followStatus => realtimeRouter(followStatus, 'onRequested')),
-    onFollowRequestAccepted(followStatus => realtimeRouter(followStatus, 'onAccepted')),
-    onFollowRequestDeclined(followStatus => realtimeRouter(followStatus, 'onDeclined')),
-    onFollowRequestCanceled(followStatus => realtimeRouter(followStatus, 'onCanceled')),
-    onUserFollowed(followStatus => realtimeRouter(followStatus, 'onFollowed')),
-    onUserUnfollowed(followStatus => realtimeRouter(followStatus, 'onUnfollowed')),
-    onFollowerDeleted(followStatus => realtimeRouter(followStatus, 'onDeleted')),
+    onFollowerRequested(realtimeRouter('onRequested')),
+    onFollowRequestAccepted(realtimeRouter('onAccepted')),
+    onFollowRequestDeclined(realtimeRouter('onDeclined')),
+    onFollowRequestCanceled(realtimeRouter('onCanceled')),
+    onUserFollowed(realtimeRouter('onFollowed')),
+    onUserUnfollowed(realtimeRouter('onUnfollowed')),
+    onFollowerDeleted(realtimeRouter('onDeleted')),
   );
 
   onFetch();

package/src/follow/observers/liveFollowings.ts

@@ -80,7 +80,7 @@ export const liveFollowings = (
     });
   };
 
-  const realtimeRouter = (followStatus: Amity.FollowStatus, action: Amity.FollowActionType) => {
+  const realtimeRouter = (action: Amity.FollowActionType) => (followStatus: Amity.FollowStatus) => {
     const collection = pullFromCache<Amity.FollowingLiveCollectionCache>(cacheKey)?.data;
 
     if (params.userId !== followStatus.from || !collection) return;
@@ -131,13 +131,13 @@ export const liveFollowings = (
   };
 
   disposers.push(
-    onFollowerRequested(followStatus => realtimeRouter(followStatus, 'onRequested')),
-    onFollowRequestAccepted(followStatus => realtimeRouter(followStatus, 'onAccepted')),
-    onFollowRequestDeclined(followStatus => realtimeRouter(followStatus, 'onDeclined')),
-    onFollowRequestCanceled(followStatus => realtimeRouter(followStatus, 'onCanceled')),
-    onUserFollowed(followStatus => realtimeRouter(followStatus, 'onFollowed')),
-    onUserUnfollowed(followStatus => realtimeRouter(followStatus, 'onUnfollowed')),
-    onFollowerDeleted(followStatus => realtimeRouter(followStatus, 'onDeleted')),
+    onFollowerRequested(realtimeRouter('onRequested')),
+    onFollowRequestAccepted(realtimeRouter('onAccepted')),
+    onFollowRequestDeclined(realtimeRouter('onDeclined')),
+    onFollowRequestCanceled(realtimeRouter('onCanceled')),
+    onUserFollowed(realtimeRouter('onFollowed')),
+    onUserUnfollowed(realtimeRouter('onUnfollowed')),
+    onFollowerDeleted(realtimeRouter('onDeleted')),
   );
 
   onFetch();

package/src/group/utils/index.ts

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

package/src/group/utils/test/withUsers.test.ts

@@ -0,0 +1,103 @@
+import { disableCache, enableCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { withUser, withUsers } from '~/group/utils';
+import { baseMembership, user11, user12 } from '~/utils/tests';
+
+const users = [user11, user12];
+
+const member1: Amity.MembershipRaw<Amity.GroupType> = { ...baseMembership, userId: user11.userId };
+const mappedMember1: Amity.Membership<Amity.GroupType> = { ...member1, user: user11 };
+const unmapableMember1: Amity.Membership<Amity.GroupType> = { ...member1, user: undefined };
+
+const member2: Amity.MembershipRaw<Amity.GroupType> = { ...baseMembership, userId: user12.userId };
+const mappedMember2: Amity.Membership<Amity.GroupType> = { ...member2, user: user12 };
+const unmapableMember2: Amity.Membership<Amity.GroupType> = { ...member2, user: undefined };
+
+const members1: Amity.MembershipRaw<Amity.GroupType>[] = [member1, member2];
+const mappedMembers1: Amity.Membership<Amity.GroupType>[] = [mappedMember1, mappedMember2];
+const unmapableMembers1: Amity.Membership<Amity.GroupType>[] = [unmapableMember1, unmapableMember2];
+
+describe('withUser', () => {
+  test('should return mapped member', () => {
+    expect.assertions(2);
+    enableCache();
+    ingestInCache({ users });
+
+    expect(withUser(member1)).toEqual(mappedMember1);
+    expect(withUser(member2)).toEqual(mappedMember2);
+
+    disableCache();
+  });
+
+  test('`.user` should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(withUser(member1)).toEqual(unmapableMember1);
+  });
+
+  test('`.user` should return error member', () => {
+    expect.assertions(2);
+    enableCache();
+    ingestInCache({ users });
+
+    expect(withUser(member1)).toEqual(mappedMember1);
+    expect(withUser(member2)).toEqual(mappedMember2);
+
+    disableCache();
+  });
+
+  test('`.user` should return undefined when user not exist', () => {
+    enableCache();
+    ingestInCache({ users });
+    const member: Amity.MembershipRaw<Amity.GroupType> = {
+      ...member1,
+      userId: 'not-exist-user-id',
+    };
+    const expected: Amity.Membership<Amity.GroupType> = {
+      ...member,
+      user: undefined,
+    };
+
+    expect(withUser(member)).toEqual(expected);
+
+    disableCache();
+  });
+});
+
+describe('withUsers', () => {
+  test('should return mapped members', () => {
+    enableCache();
+    ingestInCache({ users });
+
+    expect(withUsers(members1)).toEqual(mappedMembers1);
+
+    disableCache();
+  });
+
+  test('`.user` should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(withUsers(members1)).toEqual(unmapableMembers1);
+  });
+
+  test('`.user` should return undefined when some user not exist', () => {
+    enableCache();
+    ingestInCache({ users });
+    const members: Amity.MembershipRaw<Amity.GroupType>[] = [
+      ...members1,
+      { ...member1, userId: 'not-exist-user-id' },
+    ];
+    const expected = [
+      ...mappedMembers1,
+      {
+        ...unmapableMember1,
+        userId: 'not-exist-user-id',
+        user: undefined,
+      },
+    ];
+
+    expect(withUsers(members)).toEqual(expected);
+
+    disableCache();
+  });
+});

package/src/group/utils/withUser.ts

@@ -0,0 +1,92 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+/**
+ * Attach user object to membership model
+ * - If cache is not enabled, set user to undefined ({..., user: undefined})
+ * - If user object is not found in cache, set user to undefined
+ * ({..., user: undefined})
+ * - If a user is found in the cache, it attaches the user from the cache
+ * ({..., user: { userId, displayName,... }})
+ *
+ * @param member The membership model object
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The membership model object that is already mapped to user
+ * @hidden
+ */
+export const withUser = <
+  M extends Record<any, any>,
+  I extends keyof M = 'userId',
+  U extends string = 'user',
+>(
+  member: M,
+  userIdProp: I = <I>'userId',
+  userProp: U = <U>'user',
+): Record<U, Amity.User | undefined> & M => ({
+  get [userProp]() {
+    const client = getActiveClient();
+
+    if (!client.cache) return undefined;
+
+    const userCache = pullFromCache<Amity.User>(['user', 'get', member[userIdProp]])?.data;
+
+    if (!userCache) {
+      return undefined;
+    }
+
+    return userCache;
+  },
+  ...member,
+});
+
+/**
+ * Mapping membership model with user object
+ *
+ * @param members The membership model objects
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The membership model objects that is already
+ * mapped to users
+ * @hidden
+ */
+export const withUsers = <
+  M extends Record<any, any>[],
+  I extends keyof M[number] = 'userId',
+  U extends string = 'user',
+>(
+  members: M,
+  userIdProp: I = <I>'userId',
+  userProp: U = <U>'user',
+): (Record<U, Amity.User | undefined> & M[number])[] =>
+  members.map(member => withUser(member, userIdProp, userProp));
+
+/**
+ * Transform members prop in any payload with attached users members
+ *
+ * @param payload The payload contain members prop
+ * @param memberProp A name of members prop
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The transforming payload
+ * @hidden
+ */
+export const prepareMembershipPayload = <
+  P extends Record<any, any>,
+  M extends keyof P,
+  I extends keyof P[M][number] = 'userId',
+  U extends string = 'user',
+>(
+  payload: P,
+  memberProp: M,
+  userIdProp: I = <I>'userId',
+  userProp: U = <U>'user',
+): Omit<P, M> & Record<M, (Record<U, Amity.User | undefined> & P[M][number])[]> => {
+  const { [memberProp]: memberPayload, ...rest } = payload;
+  const members = withUsers(memberPayload, userIdProp, userProp);
+
+  return {
+    ...rest,
+    ...{ [memberProp]: members },
+  };
+};

package/src/index.ts

@@ -34,6 +34,10 @@ export * from './channel/api';
 export * from './channel/events';
 export * from './channel/observers';
 
+export * from './subChannel/api';
+export * from './subChannel/events';
+export * from './subChannel/observers';
+
 export * from './message/api';
 export * from './message/events';
 export * from './message/observers';