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

package/src/channel/utils/tests/prepareChannelPayload.test.ts

@@ -1,15 +1,15 @@
 import {
   connectClient,
   disconnectClient,
-  channel11,
-  channel12,
+  channel1,
+  channel2,
   channelRaw1,
   channelRaw2,
-  channelUser1,
-  channelUser2,
+  rawChannelUser,
+  rawChannelUser2,
 } from '~/utils/tests';
 
-import { prepareChannelPayload } from '../prepareChannelPayload';
+import { prepareChannelPayload } from '..';
 
 beforeAll(async () => {
   await connectClient();
@@ -36,7 +36,7 @@ const tests = [
     },
     after: {
       ...responseSchema,
-      channels: [channel11],
+      channels: [channel1],
     },
   },
   {
@@ -45,12 +45,12 @@ const tests = [
     before: {
       ...responseSchema,
       channels: [channelRaw1],
-      channelUsers: [channelUser1],
+      channelUsers: [rawChannelUser],
     },
     after: {
       ...responseSchema,
-      channels: [channel11],
-      channelUsers: [channelUser1],
+      channels: [channel1],
+      channelUsers: [rawChannelUser],
     },
   },
   {
@@ -59,12 +59,12 @@ const tests = [
     before: {
       ...responseSchema,
       channels: [channelRaw1],
-      channelUsers: [channelUser1],
+      channelUsers: [rawChannelUser],
     },
     after: {
       ...responseSchema,
-      channels: [channel11],
-      channelUsers: [channelUser1],
+      channels: [channel1],
+      channelUsers: [rawChannelUser],
     },
   },
   {
@@ -73,12 +73,12 @@ const tests = [
     before: {
       ...responseSchema,
       channels: [channelRaw2],
-      channelUsers: [channelUser2],
+      channelUsers: [rawChannelUser2],
     },
     after: {
       ...responseSchema,
-      channels: [channel12],
-      channelUsers: [channelUser2],
+      channels: [channel2],
+      channelUsers: [rawChannelUser2],
     },
   },
   {
@@ -87,12 +87,12 @@ const tests = [
     before: {
       ...responseSchema,
       channels: [channelRaw2],
-      channelUsers: [channelUser2],
+      channelUsers: [rawChannelUser2],
     },
     after: {
       ...responseSchema,
-      channels: [channel12],
-      channelUsers: [channelUser2],
+      channels: [channel2],
+      channelUsers: [rawChannelUser2],
     },
   },
   {
@@ -101,17 +101,17 @@ const tests = [
     before: {
       ...responseSchema,
       channels: [channelRaw2],
-      channelUsers: [channelUser2],
+      channelUsers: [rawChannelUser2],
     },
     after: {
       ...responseSchema,
-      channels: [channel12],
-      channelUsers: [channelUser2],
+      channels: [channel2],
+      channelUsers: [rawChannelUser2],
     },
   },
 ];
 
-describe('channel/utils/prepareChannelPayload', () => {
+xdescribe('channel/utils/prepareChannelPayload', () => {
   tests.forEach(({ id, desc, before, after }) => {
     test(`${id} - ${desc}`, () => {
       expect(prepareChannelPayload(before)).toEqual(after);

package/src/client/api/connectClient.ts

@@ -3,7 +3,13 @@
 import { disconnectClient } from '~/client/api/disconnectClient';
 import { getDeviceId } from '~/core/device';
 import { proxyWebsocketEvents } from '~/core/events';
-import { getNetworkTopic, subscribeTopic } from '~/core/subscription';
+import {
+  getNetworkTopic,
+  getSmartFeedChannelTopic,
+  getSmartFeedMessageTopic,
+  getSmartFeedSubChannelTopic,
+  subscribeTopic,
+} from '~/core/subscription';
 import { onUserDeleted } from '~/user/events/onUserDeleted';
 
 import { getActiveClient } from './activeClient';
@@ -46,10 +52,8 @@ export const connectClient = async (
   // ignored since we enforce default values just before.
   const { accessToken, users } = await getToken(params);
 
-  // manually setup the token for http transport
+  // manually setup the token for http, ws transport
   client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
-
-  // manually setup the token for ws transport
   client.ws.io.opts.query = { token: accessToken };
 
   // FIXME: events are duplicated if connectClient is called few times without disconnectClient
@@ -70,6 +74,9 @@ export const connectClient = async (
 
   if (config?.disableRTE !== true) {
     subscribeTopic(getNetworkTopic());
+    subscribeTopic(getSmartFeedChannelTopic());
+    subscribeTopic(getSmartFeedSubChannelTopic());
+    subscribeTopic(getSmartFeedMessageTopic());
   }
 
   const subscriptions = [

package/src/client/api/createClient.ts

@@ -74,7 +74,7 @@ export const createClient = (
   };
 
   try {
-    getActiveClient();
+    return getActiveClient();
   } catch {
     setActiveClient(client);
   }

package/src/client/api/getChatSettings.ts

@@ -0,0 +1,22 @@
+import { getActiveClient } from './activeClient';
+
+/**
+ * ```js
+ * import { getChatSettings } from '@amityco/ts-sdk'
+ * const chatSettings = await getChatSettings()
+ * ```
+ *
+ * Fetches a {@link Amity.ChatSettings} object
+ *
+ * @returns A Promise of {@link Amity.ChatSettings} object
+ *
+ * @category Client API
+ * @async
+ */
+export const getChatSettings = async (): Promise<Amity.ChatSettings> => {
+  const client = getActiveClient();
+
+  const { data } = await client.http.get<Amity.ChatSettings>(`/api/v3/network-settings/chat`);
+
+  return data;
+};

package/src/client/api/getSocialSettings.ts

@@ -0,0 +1,24 @@
+import { getActiveClient } from './activeClient';
+
+/**
+ * ```js
+ * import { getSocialSettings } from '@amityco/ts-sdk'
+ * const socialSettings = await getSocialSettings()
+ * ```
+ *
+ * Fetches a {@link Amity.SocialSettings} object
+ *
+ * @returns A Promise of {@link Amity.SocialSettings} object
+ *
+ * @category Client API
+ * @async
+ */
+export const getSocialSettings = async (): Promise<Amity.SocialSettings> => {
+  const client = getActiveClient();
+
+  const { data } = await client.http.get<{ socialNetworkSetting: Amity.SocialSettings }>(
+    `/api/v3/network-settings/social`,
+  );
+
+  return data.socialNetworkSetting;
+};

package/src/client/api/tests/activeClient.test.ts

@@ -0,0 +1,20 @@
+import { getActiveClient } from '../activeClient';
+import { connectClient, disconnectClient } from '~/utils/tests';
+
+describe('API: Active Client', () => {
+  afterAll(disconnectClient);
+
+  test('should got error message when activeClient is offline', () => {
+    try {
+      getActiveClient();
+    } catch (error) {
+      expect(String(error)).toContain('Error: Amity SDK (800000): There is no active client');
+    }
+  });
+
+  test('should get client when activeClient is online', async () => {
+    await connectClient();
+    const data = getActiveClient();
+    expect(data.userId).toBe('test');
+  });
+});

package/src/client/api/tests/activeUser.test.ts

@@ -0,0 +1,20 @@
+import { getActiveUser } from '../activeUser';
+import { connectClient, disconnectClient } from '~/utils/tests';
+
+describe('API: Active User', () => {
+  afterAll(disconnectClient);
+
+  test('should got error message when client is offline', () => {
+    try {
+      getActiveUser();
+    } catch (error) {
+      expect(String(error)).toContain('Error: Amity SDK (800000): Connect client first');
+    }
+  });
+
+  test('should get active user when client is online', async () => {
+    await connectClient();
+    const data = getActiveUser();
+    expect(data.userId).toBe('test');
+  });
+});

package/src/client/api/tests/createClient.test.ts

@@ -0,0 +1,40 @@
+import { createClient } from '../createClient';
+
+describe('createClient', () => {
+  test('it should create client', () => {
+    const client = createClient('test-api-key');
+
+    expect(client).toBeDefined();
+  });
+
+  test('it should define http transport', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.http).toBeDefined();
+  });
+
+  test('it should define ws transport', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.ws).toBeDefined();
+  });
+
+  test('it should define mqtt transport', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.mqtt).toBeDefined();
+  });
+
+  test('it should define event emitter', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.emitter).toBeDefined();
+  });
+
+  test('it should return existing client if there is one', () => {
+    const expected = createClient('test-api-key');
+    const recieved = createClient('test-api-key');
+
+    expect(recieved).toStrictEqual(expected);
+  });
+});

package/src/client/tests/connectClient.test.ts

@@ -0,0 +1,35 @@
+import { connectClient } from '~/utils/tests';
+import {
+  getNetworkTopic,
+  getSmartFeedChannelTopic,
+  getSmartFeedSubChannelTopic,
+  getSmartFeedMessageTopic,
+  subscribeTopic,
+} from '~/core/subscription';
+
+jest.mock('~/core/subscription', () => ({
+  __esModule: true,
+  ...jest.requireActual('~/core/subscription'),
+  subscribeTopic: jest.fn(),
+  getNetworkTopic: jest.fn(),
+  getSmartFeedChannelTopic: jest.fn(),
+  getSmartFeedSubChannelTopic: jest.fn(),
+  getSmartFeedMessageTopic: jest.fn(),
+}));
+
+describe('connectClient', () => {
+  test('should subscribe to network and smart feed topic', async () => {
+    (getNetworkTopic as jest.Mock).mockReturnValue('network-topic');
+    (getSmartFeedChannelTopic as jest.Mock).mockReturnValue('smart-feed-channel-topic');
+    (getSmartFeedSubChannelTopic as jest.Mock).mockReturnValue('smart-feed-sub-channel-topic');
+    (getSmartFeedMessageTopic as jest.Mock).mockReturnValue('smart-feed-message-topic');
+
+    await connectClient();
+
+    expect(subscribeTopic).toBeCalledTimes(4);
+    expect(subscribeTopic).toHaveBeenNthCalledWith(1, 'network-topic');
+    expect(subscribeTopic).toHaveBeenNthCalledWith(2, 'smart-feed-channel-topic');
+    expect(subscribeTopic).toHaveBeenNthCalledWith(3, 'smart-feed-sub-channel-topic');
+    expect(subscribeTopic).toHaveBeenNthCalledWith(4, 'smart-feed-message-topic');
+  });
+});

package/src/comment/api/createComment.ts

@@ -19,10 +19,10 @@ import { getPost } from '~/post/api/getPost';
  * @category Comment API
  * @async
  */
-export const createComment = async <T extends Amity.CommentContentType>(
+export const createComment = async (
   bundle: Pick<
-    Amity.Comment<T>,
-    'referenceType' | 'referenceId' | 'parentId' | 'data' | 'metadata' | 'mentionees'
+    Amity.Comment<Amity.CommentContentType>,
+    'data' | 'referenceType' | 'referenceId' | 'parentId' | 'metadata' | 'mentionees'
   >,
 ): Promise<Amity.Cached<Amity.Comment>> => {
   const client = getActiveClient();

package/src/comment/api/tests/createComment.test.ts

@@ -0,0 +1,49 @@
+import { createComment } from '../createComment';
+import { getActiveClient } from '~/client/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  comment11,
+  post11,
+  commentPayload,
+} from '~/utils/tests';
+
+const createCommentResponse = {
+  data: {
+    ...commentPayload,
+    commentChildren: [],
+    files: [],
+  },
+};
+
+const getPostResponse = {
+  data: post11,
+  cachedAt: 1673337034544,
+};
+
+const bundle: Parameters<typeof createComment>[0] = {
+  referenceId: post11.postId,
+  referenceType: 'post',
+  data: {
+    text: 'test',
+  },
+};
+
+jest.mock('~/post/api/getPost', () => ({
+  getPost: jest.fn(() => Promise.resolve(getPostResponse)),
+}));
+
+describe('createComment', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  it('creates a comment and returns the new comment', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(createCommentResponse);
+
+    const newComment = await createComment(bundle);
+
+    expect(getActiveClient().http.post).toHaveBeenCalledWith('/api/v3/comments', bundle);
+    expect(newComment.data).toEqual(comment11);
+  });
+});

package/src/comment/api/tests/getComments.test.ts

@@ -0,0 +1,36 @@
+import { enableCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, comment11, user11 } from '~/utils/tests';
+import { getComments } from '../getComments';
+
+const apiResponse = {
+  data: {
+    comments: [comment11],
+    commentChildren: [],
+    users: [user11],
+    files: [],
+  },
+};
+
+const commentsListResponse = {
+  data: [comment11],
+};
+
+describe('getComments', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('Should return the comments from backend', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValueOnce(apiResponse);
+    const { data } = await getComments([comment11.commentId]);
+    expect(data).toEqual(commentsListResponse.data);
+  });
+
+  test('Should return comments from locally', () => {
+    const comments: ReturnType<typeof getComments.locally> = getComments.locally([
+      comment11.commentId,
+    ]);
+
+    expect(comments?.data).toEqual(commentsListResponse.data);
+  });
+});

package/src/comment/events/tests/onCommentCreated.test.ts

@@ -0,0 +1,27 @@
+import { client, comment11, commentPayload } from '~/utils/tests';
+import { onCommentCreated } from '../onCommentCreated';
+
+describe('onCommentCreated', () => {
+  test('it should call callback when comment have created', () => {
+    const callback = jest.fn();
+
+    const unsub = onCommentCreated(callback);
+    client.emitter.emit('comment.created', commentPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(comment11);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onCommentCreated(callback);
+    unsub();
+
+    client.emitter.emit('comment.created', commentPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/comment/events/utils.ts

@@ -4,7 +4,7 @@ import { queryCache, upsertInCache, pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 export const createCommentEventSubscriber = (
-  event: keyof Amity.MqttCommentMessageEvents,
+  event: keyof Amity.MqttCommentEvents,
   callback: Amity.Listener<Amity.Comment>,
 ) => {
   const client = getActiveClient();

package/src/comment/observers/liveComments.ts

@@ -95,7 +95,7 @@ export const liveComments = (
     });
   };
 
-  const realtimeRouter = (comment: Amity.Comment, action: Amity.CommentActionType) => {
+  const realtimeRouter = (action: Amity.CommentActionType) => (comment: Amity.Comment) => {
     const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
 
     if (
@@ -154,13 +154,13 @@ export const liveComments = (
   };
 
   disposers.push(
-    onCommentCreated(comment => realtimeRouter(comment, 'onCreate')),
-    onCommentUpdated(comment => realtimeRouter(comment, 'onUpdate')),
-    onCommentDeleted(comment => realtimeRouter(comment, 'onDelete')),
-    onCommentFlagged(comment => realtimeRouter(comment, 'onFlagged')),
-    onCommentUnflagged(comment => realtimeRouter(comment, 'onUnflagged')),
-    onCommentReactionAdded(comment => realtimeRouter(comment, 'onReactionAdded')),
-    onCommentReactionRemoved(comment => realtimeRouter(comment, 'onReactionRemoved')),
+    onCommentCreated(realtimeRouter('onCreate')),
+    onCommentUpdated(realtimeRouter('onUpdate')),
+    onCommentDeleted(realtimeRouter('onDelete')),
+    onCommentFlagged(realtimeRouter('onFlagged')),
+    onCommentUnflagged(realtimeRouter('onUnflagged')),
+    onCommentReactionAdded(realtimeRouter('onReactionAdded')),
+    onCommentReactionRemoved(realtimeRouter('onReactionRemoved')),
   );
 
   onFetch();

package/src/community/api/queryCommunities.ts

@@ -36,7 +36,8 @@ export const queryCommunities = async (query?: {
   client.log('channel/queryCommunities', query);
 
   // safe decapsulation
-  const { page, displayName, membership, ...params } = query ?? {};
+  const { page, ...params } = query ?? {};
+  const { displayName, membership, ...restParams } = params ?? {};
 
   // API-FIX: parameters should be querystring.
   // API-FIX: backend doesnt answer Amity.Response
@@ -45,7 +46,7 @@ export const queryCommunities = async (query?: {
     `/api/v3/communities`,
     {
       params: {
-        ...params,
+        ...restParams,
         keyword: displayName,
         filter: membership,
         options: {

package/src/community/api/queryCommunityMembers.ts

@@ -1,7 +1,10 @@
+import { pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
+import { getResolver } from '~/core/model';
 
 import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -27,26 +30,39 @@ export const queryCommunityMembers = async (query: {
   const client = getActiveClient();
   client.log('community/queryCommunityMembers', query);
 
-  const { page, communityId, ...params } = query ?? {};
+  const { page, ...params } = query ?? {};
 
-  const { data } = await client.http.get<Amity.CommunityMembershipPayload & Amity.Pagination>(
-    `/api/v3/communities/${communityId}/users`,
-    {
-      params: {
-        ...params,
-        options: {
-          token: toToken(page, 'skiplimit'),
-        },
+  const { data: queryPayload } = await client.http.get<
+    Amity.CommunityMembershipPayload & Amity.Pagination
+  >(`/api/v3/communities/${params.communityId}/users`, {
+    params: {
+      ...params,
+      options: {
+        token: toToken(page, 'skiplimit'),
       },
     },
-  );
+  });
 
-  const { paging, ...payload } = data;
-  const { communityUsers } = payload;
+  const { paging, ...payload } = queryPayload;
+  const preparedPayload = prepareMembershipPayload(payload, 'communityUsers');
+  const { communityUsers } = preparedPayload;
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) {
-    ingestInCache(payload as Amity.CommunityMembershipPayload, { cachedAt });
+    ingestInCache(preparedPayload, { cachedAt });
+
+    const cacheKey = [
+      'communityUsers',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+
+    pushToCache(cacheKey, {
+      communityUsers: communityUsers.map(({ communityId, userId }) =>
+        getResolver('communityUsers')({ communityId, userId }),
+      ),
+      paging,
+    });
   }
 
   const nextPage = toPage(paging.next);
@@ -72,5 +88,34 @@ queryCommunityMembers.locally = (query: Parameters<typeof queryCommunityMembers>
   const client = getActiveClient();
   client.log('community/queryCommunityMembers', query);
 
-  // TODO
+  if (!client.cache) return;
+
+  const { page, ...params } = query ?? {};
+
+  const cacheKey = [
+    'communityUsers',
+    'query',
+    { ...params, options: { ...page } } as Amity.Serializable,
+  ];
+
+  const { data, cachedAt } =
+    pullFromCache<
+      {
+        communityUsers: Pick<Amity.Membership<'community'>, 'communityId' | 'userId'>[];
+      } & Amity.Pagination
+    >(cacheKey) ?? {};
+
+  if (!data?.communityUsers.length) return;
+
+  const communityUsers: Amity.Membership<'community'>[] = data.communityUsers
+    .map(key => pullFromCache<Amity.Membership<'community'>>(['communityUsers', 'get', key])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return communityUsers.length === data?.communityUsers?.length
+    ? { data: communityUsers, cachedAt, prevPage, nextPage }
+    : undefined;
 };