@amityco/ts-sdk 0.0.1-beta.33 → 0.0.1-beta.37

package/src/client/events/onClientBanned.ts

@@ -1,4 +1,6 @@
-import { onConnectionError } from './onConnectionError';
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
 
 /**
  * ```js
@@ -15,8 +17,13 @@ import { onConnectionError } from './onConnectionError';
  *
  * @category Client Events
  */
-export const onClientBanned = (callback: Amity.Listener<void>): Amity.Unsubscriber => {
-  return onConnectionError(({ code }) => {
-    code === Amity.ServerError.GLOBAL_BAN && callback();
-  });
+export const onClientBanned = (callback: Amity.Listener<Amity.UserPayload>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(
+    client,
+    `client/onConnectionError(user.didGlobalBan)`,
+    'user.didGlobalBan',
+    callback,
+  );
 };

package/src/client/events/onSessionStateChange.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onSessionStateChange } from '@amityco/ts-sdk'
+ * const dispose = onSessionStateChange((state: Amity.SessionStates) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} has a session state change
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+export const onSessionStateChange = (
+  callback: Amity.Listener<Amity.SessionStates>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(
+    client,
+    `client/onSessionStateChange`,
+    'sessionStateChange',
+    callback,
+  );
+};

package/src/client/events/onTokenExpired.ts

@@ -0,0 +1,26 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onTokenExpired } from '@amityco/ts-sdk'
+ * const dispose = onTokenExpired((state: Amity.SessionStates.TOKEN_EXPIRED) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} session state has expired
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category private
+ */
+export const onTokenExpired = (
+  callback: Amity.Listener<Amity.SessionStates.TOKEN_EXPIRED>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(client, `client/onTokenExpired`, 'tokenExpired', callback);
+};

package/src/client/events/onTokenTerminated.ts

@@ -0,0 +1,20 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ *
+ * Fired when any {@link Amity.Client} session state has terminated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category private
+ */
+export const onTokenTerminated = (
+  callback: Amity.Listener<Amity.SessionStates.TERMINATED>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(client, `client/onTokenTerminated`, 'tokenTerminated', callback);
+};

package/src/client/events/tests/onSessionStateChange.test.ts

@@ -0,0 +1,37 @@
+import { client, connectClient, disconnectClient } from '~/utils/tests';
+
+import { onSessionStateChange } from '../onSessionStateChange';
+
+describe('onSessionStateChange', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should call callback on event', () => {
+    const callback = jest.fn();
+    const expected = Amity.SessionStates.ESTABLISHED;
+
+    const unsub = onSessionStateChange(callback);
+    client.emitter.emit('sessionStateChange', expected);
+
+    expect(callback).toHaveBeenCalledWith(expected);
+
+    unsub();
+  });
+
+  test('it should not call callback if unsubscribed', () => {
+    const callback = jest.fn();
+    const state = Amity.SessionStates.ESTABLISHED;
+
+    const unsub = onSessionStateChange(callback);
+    unsub();
+
+    client.emitter.emit('sessionStateChange', state);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/client/events/tests/onTokenTerminated.test.ts

@@ -0,0 +1,37 @@
+import { client, connectClient, disconnectClient } from '~/utils/tests';
+
+import { onTokenTerminated } from '../onTokenTerminated';
+
+describe('onTokenTerminated', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should call callback on event', () => {
+    const callback = jest.fn();
+    const expected = Amity.SessionStates.TERMINATED;
+
+    const unsub = onTokenTerminated(callback);
+    client.emitter.emit('tokenTerminated', expected);
+
+    expect(callback).toHaveBeenCalledWith(expected);
+
+    unsub();
+  });
+
+  test('it should not call callback if unsubscribed', () => {
+    const callback = jest.fn();
+    const state = Amity.SessionStates.TERMINATED;
+
+    const unsub = onTokenTerminated(callback);
+    unsub();
+
+    client.emitter.emit('tokenTerminated', state);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,40 @@
+import { connectClient } from '~/utils/tests';
+import {
+  getNetworkTopic,
+  getSmartFeedChannelTopic,
+  getSmartFeedSubChannelTopic,
+  getSmartFeedMessageTopic,
+  getUserTopic,
+  subscribeTopic,
+} from '~/core/subscription';
+
+jest.mock('~/core/subscription', () => ({
+  __esModule: true,
+  ...jest.requireActual('~/core/subscription'),
+  subscribeTopic: jest.fn(),
+  getNetworkTopic: jest.fn(),
+  getUserTopic: 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');
+    (getUserTopic as jest.Mock).mockReturnValue('user-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(5);
+
+    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');
+    expect(subscribeTopic).toHaveBeenNthCalledWith(5, 'user-topic');
+  });
+});

package/src/client/utils/setClientToken.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '../api/activeClient';
+import { setSessionState } from '../api/setSessionState';
+import { getToken } from '../api/getToken';
+
+/**
+ * A util to set or refresh client token
+ *
+ * @param params.userId the user ID for the current session
+ * @param params.displayName the user's displayName for the current session
+ * @param params.deviceId Manual override of the user's device id (for device management)
+ * @param params.authToken The authentication token - necessary when network option is set to secure
+ * @returns token & user info
+ *
+ * @category private
+ * @async
+ */
+export const setClientToken = async (params: Parameters<typeof getToken>) => {
+  const client = getActiveClient();
+  // begin establishing session
+  setSessionState(Amity.SessionStates.ESTABLISHING);
+
+  // @ts-ignore: in that particular case, typing can be
+  // ignored since we enforce default values just before.
+  const { accessToken, users, expiresAt, issuedAt, refreshToken } = await getToken(params);
+
+  // manually setup the token for http transport
+  client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
+
+  client.http.defaults.metadata = { tokenExpiry: expiresAt };
+
+  // manually setup the token for ws transport
+  client.ws.io.opts.query = { token: accessToken };
+
+  client.token = { accessToken, issuedAt, expiresAt };
+
+  setSessionState(Amity.SessionStates.ESTABLISHED);
+
+  return { accessToken, users, refreshToken };
+};

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/tests/onCommentDeleted.test.ts

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

package/src/community/api/test/addCommunityMember.test.ts

@@ -0,0 +1,71 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { onCommunityUserAdded } from '../../events';
+import { addCommunityMembers } from '../addCommunityMembers';
+
+const communityToAddUserTo = community11;
+const userToAdd = communityUser11;
+
+const resolvedPostValue = {
+  data: {
+    communities: [communityToAddUserTo],
+    communityUsers: [userToAdd],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('addCommunityMembers', () => {
+  test('should return true value', async () => {
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    const recieved = addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]);
+
+    await expect(recieved).resolves.toBe(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(
+      addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]),
+    ).rejects.toThrow('error');
+  });
+
+  test('should create cache after added user', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    await addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]);
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: communityToAddUserTo.communityId,
+        userId: userToAdd.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(userToAdd));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityUserAdded`', async () => {
+    let dispose;
+    client.http.post = jest.fn().mockResolvedValueOnce(resolvedPostValue);
+
+    const callback = new Promise(resolve => {
+      dispose = onCommunityUserAdded(resolve);
+    }).finally(dispose);
+
+    await addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]);
+
+    await expect(callback).resolves.toEqual(expect.objectContaining(communityToAddUserTo));
+  });
+});