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

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

@@ -37,4 +37,12 @@ describe('createClient', () => {
 
     expect(recieved).toStrictEqual(expected);
   });
+
+  test('it should set not logged in as the start up session state', () => {
+    const got = createClient('key', 'sg');
+    const { sessionState } = got;
+
+    expect(got).toBeDefined();
+    expect(sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
+  });
 });

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

@@ -0,0 +1,78 @@
+import { pushToCache, pullFromCache, enableCache } from '~/cache/api';
+import { client, connectClient, message11 as message } from '~/utils/tests';
+
+import { disconnectClient } from '..';
+
+const disconnect = () => setTimeout(() => client.ws.emit('disconnect'), 500);
+
+describe('disconnectClient', () => {
+  beforeEach(async () => {
+    await connectClient();
+  });
+
+  test('it should disconnect client', async () => {
+    disconnect().unref();
+
+    const recieved = await disconnectClient();
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should set sesion state to notLoggedIn after disconnect', async () => {
+    disconnect().unref();
+    await disconnectClient();
+
+    expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
+  });
+
+  test('it should not update sesion state if session state terminated', async () => {
+    client.sessionState = Amity.SessionStates.TERMINATED;
+    disconnect().unref();
+
+    await disconnectClient();
+
+    expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
+  });
+
+  test('it should clear userId and accessToken on disconnect', async () => {
+    disconnect().unref();
+
+    await disconnectClient();
+
+    expect(client.userId).toBeUndefined();
+    expect(client.token).toBeUndefined();
+  });
+
+  test('it should clear auth header on disconnect', async () => {
+    disconnect().unref();
+
+    await disconnectClient();
+
+    expect(client.http.defaults.headers.common.Authorization).toBeFalsy();
+  });
+
+  test('it should clear cache on disconnect', async () => {
+    disconnect().unref();
+    enableCache();
+
+    const cacheKey = ['message', 'get', message.messageId];
+    pushToCache(cacheKey, message);
+
+    await disconnectClient();
+
+    expect(pullFromCache(cacheKey)).toBeUndefined();
+  });
+
+  test('it should not clear cache if tokenExpired', async () => {
+    client.sessionState = Amity.SessionStates.TOKEN_EXPIRED;
+    disconnect().unref();
+    enableCache();
+
+    const cacheKey = ['message', 'get', message.messageId];
+    pushToCache(cacheKey, message);
+
+    await disconnectClient();
+
+    expect(pullFromCache(cacheKey)?.data).toStrictEqual(message);
+  });
+});

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

@@ -0,0 +1,36 @@
+import { client, user11, sessionResponse } from '~/utils/tests';
+
+import { getToken } from '../getToken';
+
+describe('getToken', () => {
+  const { userId } = user11;
+  const displayName = 'test-displayName';
+  const deviceId = 'test-deviceId';
+  const params = { userId, displayName, deviceId };
+
+  test('it should call v3/sessions api', async () => {
+    const expected = '/api/v3/sessions';
+    const mockApi = jest.fn().mockResolvedValue(sessionResponse);
+    client.http.post = mockApi;
+
+    await getToken(params);
+    const [recieved] = mockApi.mock.lastCall;
+
+    expect(recieved).toBe(expected);
+  });
+
+  test('it should return token', async () => {
+    const expected = sessionResponse.data;
+    client.http.post = jest.fn().mockResolvedValue(sessionResponse);
+
+    const recieved = await getToken(params);
+
+    expect(recieved).toStrictEqual(expected);
+  });
+
+  test('it should throw error', async () => {
+    client.http.post = jest.fn().mockRejectedValue(new Error('error'));
+
+    await expect(getToken(params)).rejects.toThrow();
+  });
+});

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

@@ -0,0 +1,67 @@
+import { ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
+import { client, connectClient, disconnectClient, user11, pause } from '~/utils/tests';
+
+import { renewal } from '../renewal';
+
+const accessToken = 'renewed-access-token';
+const sessionResponse = {
+  data: {
+    accessToken,
+    refreshToken: 'test-refresh-token',
+    issuedAt: new Date(),
+    expiresAt: new Date(),
+    users: [user11],
+    files: [],
+  },
+};
+
+describe('renewal', () => {
+  beforeAll(connectClient);
+
+  afterAll(disconnectClient);
+
+  test('it should renew access token', async () => {
+    const mock = jest.fn();
+    client.http.post = mock.mockResolvedValue(sessionResponse);
+
+    renewal().renew();
+    await pause();
+
+    expect(client.token?.accessToken).toBe(accessToken);
+  });
+
+  test('it should show warning message if renewal already called', async () => {
+    client.http.post = jest.fn().mockResolvedValue(sessionResponse);
+    jest.spyOn(global.console, 'log');
+
+    const expected = "'renew' method can be called only once per renewal instance";
+    const renewalInstance = renewal();
+
+    renewalInstance.renew();
+    await pause();
+
+    renewalInstance.renew();
+    await pause();
+
+    expect(console.log).toBeCalledWith(expected);
+  });
+
+  test('it should call renewal later if unable to renew', async () => {
+    jest.useFakeTimers();
+    const sessionHandler: Amity.SessionHandler = {
+      sessionWillRenewAccessToken(renewal) {
+        renewal.renew();
+      },
+    };
+
+    client.sessionHandler = sessionHandler;
+
+    const mock = jest.fn();
+    client.http.post = mock.mockResolvedValue(sessionResponse);
+
+    renewal().unableToRetrieveAuthToken();
+    jest.advanceTimersByTime(ACCESS_TOKEN_WATCHER_INTERVAL);
+
+    expect(mock).toBeCalled();
+  });
+});

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

@@ -0,0 +1,62 @@
+import { ASCError } from '~/core/errors';
+import { getActiveClient } from '../activeClient';
+
+import { connectClient, disconnectClient, pause } from '~/utils/tests';
+
+import { setSessionState } from '../setSessionState';
+import { onSessionStateChange } from '../../events';
+
+describe('setSessionState', () => {
+  beforeEach(async () => {
+    await connectClient();
+  });
+
+  afterEach(async () => {
+    await disconnectClient();
+  });
+
+  test('it should set new session state', () => {
+    const client = getActiveClient();
+    const expected = Amity.SessionStates.NOT_LOGGED_IN;
+
+    setSessionState(expected);
+
+    expect(client.sessionState).toBe(expected);
+  });
+
+  test('it should return true if state changed successully', () => {
+    const expected = true;
+
+    const recieved = setSessionState(Amity.SessionStates.NOT_LOGGED_IN);
+
+    expect(recieved).toBe(expected);
+  });
+
+  test('it should fire event on state change', async () => {
+    const callback = jest.fn();
+
+    const expected = Amity.SessionStates.NOT_LOGGED_IN;
+    const unsub = onSessionStateChange(callback);
+
+    const recieved = setSessionState(expected);
+
+    // wait for event handler
+    await pause();
+
+    expect(recieved).toBe(true);
+    expect(callback).toHaveBeenCalledWith(expected);
+
+    unsub();
+  });
+
+  test('it should not allow invalid state change', async () => {
+    /*
+     * as state changes from established -> established are not possible, even
+     * for cases when logging in with already logged in user it should go to
+     * establishing first
+     */
+    const nextState = Amity.SessionStates.ESTABLISHED;
+
+    expect(setSessionState(nextState)).toBe(false);
+  });
+});

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

@@ -0,0 +1,29 @@
+import { client, connectClient } from '~/utils/tests';
+
+import { terminateClient } from '../terminateClient';
+
+const disconnect = () => setTimeout(() => client.ws.emit('disconnect'), 500);
+
+describe('terminateClient', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  test('it should terminate client session', async () => {
+    disconnect().unref();
+
+    const expected = Amity.SessionStates.TERMINATED;
+
+    terminateClient();
+
+    expect(client.sessionState).toBe(expected);
+  });
+
+  test('it should clear sessionHandler', async () => {
+    disconnect().unref();
+
+    terminateClient();
+
+    expect(client.sessionHandler).toBeUndefined();
+  });
+});

package/src/client/events/index.ts

@@ -2,3 +2,5 @@ export * from './onConnectionError';
 
 export * from './onClientDisconnected';
 export * from './onClientBanned';
+
+export * from './onSessionStateChange';

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

@@ -4,6 +4,7 @@ import {
   getSmartFeedChannelTopic,
   getSmartFeedSubChannelTopic,
   getSmartFeedMessageTopic,
+  getUserTopic,
   subscribeTopic,
 } from '~/core/subscription';
 
@@ -12,6 +13,7 @@ jest.mock('~/core/subscription', () => ({
   ...jest.requireActual('~/core/subscription'),
   subscribeTopic: jest.fn(),
   getNetworkTopic: jest.fn(),
+  getUserTopic: jest.fn(),
   getSmartFeedChannelTopic: jest.fn(),
   getSmartFeedSubChannelTopic: jest.fn(),
   getSmartFeedMessageTopic: jest.fn(),
@@ -20,16 +22,19 @@ jest.mock('~/core/subscription', () => ({
 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(4);
+    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/deleteComment.ts

@@ -1,10 +1,12 @@
 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';
 
 /**
  * ```js
@@ -49,9 +51,7 @@ export const deleteComment = async (
   fireEvent('comment.deleted', { comments: [deleted] });
 
   if (permanent) {
-    setTimeout(() => {
-      dropFromCache(['comment', 'get', commentId], true);
-    }, 0);
+    scheduleTask(() => pushToTombstone('comment', commentId));
   } else {
     upsertInCache(['comment', 'get', commentId], { isDeleted: true });
   }

package/src/comment/api/getComment.ts

@@ -1,7 +1,10 @@
 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';
 
 /**
  * ```js
@@ -23,6 +26,8 @@ export const getComment = async (
   const client = getActiveClient();
   client.log('comment/getComment', commentId);
 
+  isInTombstone('comment', commentId);
+
   let data: Amity.CommentPayload;
 
   try {
@@ -33,8 +38,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;

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/observers/index.ts

@@ -1,3 +1,4 @@
 export * from './observeComments';
 export * from './observeComment';
+export * from './liveComment';
 export * from './liveComments';