@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

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

@@ -5,6 +5,9 @@ import { fireEvent } from '~/core/events';
 
 import { getPost } from '~/post/api/getPost';
 
+/* begin_public_function
+  id: comment.create
+*/
 /**
  * ```js
  * import { createComment } from '@amityco/ts-sdk'
@@ -19,10 +22,16 @@ 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'
+    | 'attachments'
   >,
 ): Promise<Amity.Cached<Amity.Comment>> => {
   const client = getActiveClient();
@@ -35,7 +44,17 @@ export const createComment = async <T extends Amity.CommentContentType>(
 
   const post = await getPost(bundle.referenceId);
 
-  fireEvent('post.updated', { posts: [post.data] });
+  fireEvent('post.updated', {
+    posts: [post.data],
+    categories: [],
+    comments: [],
+    communities: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    postChildren: [],
+    users: [],
+  });
   fireEvent('comment.created', data);
 
   const { comments } = data;
@@ -44,3 +63,4 @@ export const createComment = async <T extends Amity.CommentContentType>(
     cachedAt,
   };
 };
+/* end_public_function */

package/src/comment/api/deleteComment.ts

@@ -1,11 +1,17 @@
 import { getActiveClient } from '~/client/api';
 
-import { dropFromCache, upsertInCache } from '~/cache/api';
+import { upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 
-import { getComment } from './getComment';
 import { getPost } from '~/post/api/getPost';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { scheduleTask } from '~/core/microtasks';
+
+import { getComment } from './getComment';
 
+/* begin_public_function
+  id: comment.soft_delete, comment.hard_delete
+*/
 /**
  * ```js
  * import { deleteComment } from '@amityco/ts-sdk'
@@ -45,16 +51,31 @@ export const deleteComment = async (
 
   const post = await getPost(comment.data.referenceId);
 
-  fireEvent('post.updated', { posts: [post.data] });
-  fireEvent('comment.deleted', { comments: [deleted] });
+  fireEvent('post.updated', {
+    posts: [post.data],
+    categories: [],
+    comments: [],
+    communities: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    postChildren: [],
+    users: [],
+  });
+
+  fireEvent('comment.deleted', {
+    comments: [deleted],
+    commentChildren: [],
+    files: [],
+    users: [],
+  });
 
   if (permanent) {
-    setTimeout(() => {
-      dropFromCache(['comment', 'get', commentId], true);
-    }, 0);
+    scheduleTask(() => pushToTombstone('comment', commentId));
   } else {
     upsertInCache(['comment', 'get', commentId], { isDeleted: true });
   }
 
   return deleted;
 };
+/* end_public_function */

package/src/comment/api/getComment.ts

@@ -1,8 +1,14 @@
 import { getActiveClient } from '~/client/api';
 
-import { pullFromCache, dropFromCache } from '~/cache/api';
+import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
+/* begin_public_function
+  id: comment.get
+*/
 /**
  * ```js
  * import { getComment } from '@amityco/ts-sdk'
@@ -23,6 +29,8 @@ export const getComment = async (
   const client = getActiveClient();
   client.log('comment/getComment', commentId);
 
+  isInTombstone('comment', commentId);
+
   let data: Amity.CommentPayload;
 
   try {
@@ -33,8 +41,8 @@ export const getComment = async (
 
     data = response.data;
   } catch (error) {
-    if ((error as Amity.ErrorResponse)?.code === Amity.ServerError.ITEM_NOT_FOUND) {
-      dropFromCache(['comment', 'get', commentId], true);
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('comment', commentId);
     }
 
     throw error;
@@ -49,6 +57,7 @@ export const getComment = async (
     cachedAt,
   };
 };
+/* end_public_function */
 
 /**
  * ```js

package/src/comment/api/getComments.ts

@@ -3,6 +3,9 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: comment.get_by_ids
+*/
 /**
  * ```js
  * import { getComments } from '@amityco/ts-sdk'
@@ -38,6 +41,7 @@ export const getComments = async (
     cachedAt,
   };
 };
+/* end_public_function */
 
 /**
  * ```js

package/src/comment/api/queryComments.ts

@@ -5,6 +5,9 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
+/* begin_public_function
+  id: comment.query
+*/
 /**
  * ```js
  * import { queryComments } from '@amityco/ts-sdk'
@@ -19,19 +22,18 @@ import { getResolver } from '~/core/model';
  * @category Comment API
  * @async
  */
-export const queryComments = async (query: {
-  referenceType: Amity.Comment['referenceType'];
-  referenceId: Amity.Comment['referenceId'];
-  parentId?: Amity.Comment['commentId'] | null;
-  hasFlag?: boolean;
-  isDeleted?: Amity.Comment['isDeleted'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Comment>>> => {
+export const queryComments = async (
+  query: Amity.QueryComments,
+): Promise<Amity.Cached<Amity.Paged<Amity.Comment>>> => {
   const client = getActiveClient();
   client.log('comment/queryComments', query);
 
-  const { page = { limit: 10 }, ...params } = query;
+  const { page = { limit: 10 }, includeDeleted, ...params } = query;
 
+  const options = {
+    type: params.sortBy ? 'pagination' : undefined,
+    token: toToken(page, params.sortBy ? 'skiplimit' : 'afterbefore'),
+  };
   // const filterByParentId = query.parentId !== undefined
 
   // API-FIX: parameters should be querystring. (1)
@@ -42,10 +44,9 @@ export const queryComments = async (query: {
     {
       params: {
         ...params,
+        isDeleted: includeDeleted === false ? false : undefined,
         //      filterByParentId, API-FIX: backend does not support this boolean LOL. what the hell seriously.
-        options: {
-          token: toToken(page, 'afterbefore'),
-        },
+        options,
       },
     },
   );
@@ -73,6 +74,7 @@ export const queryComments = async (query: {
 
   return { data: comments, cachedAt, prevPage, nextPage };
 };
+/* end_public_function */
 
 /**
  * ```js