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

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/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/core/events.ts

@@ -12,6 +12,9 @@ const WS_EVENTS = [
   'connect_error',
   'reconnect_error',
   'reconnect_failed',
+  'sessionStateChange',
+  // for internal use by accessTokenExpiryWatcher
+  'tokenExpired',
 ] as const;
 
 const MQTT_EVENTS = [
@@ -22,6 +25,8 @@ const MQTT_EVENTS = [
   'close',
   'end',
   'reconnect',
+
+  'user.didGlobalBan',
 ] as const;
 
 /** @hidden */
@@ -42,7 +47,6 @@ export const createEventEmitter = () => {
 export const proxyWebsocketEvents = (ws: Amity.Client['ws'], emitter: Amity.Client['emitter']) => {
   WS_EVENTS.forEach(event => {
     ws.on(event, (param: Amity.Events[typeof event]) => {
-      console.log('ws', event, param);
       emitter.emit(event, param);
     });
   });
@@ -54,7 +58,6 @@ export const proxyMqttEvents = (
 ) => {
   MQTT_EVENTS.forEach(event => {
     mqttClient.on(event, (...params: any[]) => {
-      console.log('mqtt', event, params);
       emitter.emit(event, params.length === 1 ? params[0] : params);
     });
   });
@@ -62,7 +65,6 @@ export const proxyMqttEvents = (
   // @ts-ignore
   mqttClient.on('message', (topic: string, payload: Buffer) => {
     const message = JSON.parse(payload.toString());
-    console.log('mqtt message', message);
     emitter.emit(message.eventType, message.data);
   });
 };

package/src/core/subscription.ts

@@ -127,7 +127,9 @@ export function subscribeTopic(
   topic: string,
   callback?: Amity.Listener<ASCError | void>,
 ): Amity.Unsubscriber {
-  const { mqtt, emitter, accessToken } = getActiveClient();
+  const { mqtt, emitter, token } = getActiveClient();
+  const accessToken = token?.accessToken ?? '';
+
   const user = getActiveUser();
 
   if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {

package/src/core/transports/http.ts

@@ -2,6 +2,9 @@ import axios from 'axios';
 import qs from 'qs';
 import HttpAgent, { HttpsAgent } from 'agentkeepalive';
 
+import { ASCError } from '~/core/errors';
+
+import { fireEvent } from '../events';
 import { unwrapPayload } from './utils';
 
 /**
@@ -36,6 +39,22 @@ export const createHttpTransport = (endpoint: string) => {
     paramsSerializer: stringify,
   });
 
+  instance.interceptors.request.use(config => {
+    // check global.ts for the extension of AxiosRequestConfig
+    const tokenExpiry = config.metadata?.tokenExpiry;
+
+    if (tokenExpiry) {
+      if (Date.now() >= Date.parse(tokenExpiry)) {
+        return {
+          ...config,
+          cancelToken: new axios.CancelToken(cancel => cancel('Token Expired')),
+        };
+      }
+    }
+
+    return config;
+  });
+
   instance.interceptors.response.use(
     response => response,
     error => {
@@ -43,7 +62,23 @@ export const createHttpTransport = (endpoint: string) => {
       // eslint-disable-next-line no-console
       console.error(response?.data ?? error);
 
-      if (response) unwrapPayload(response.data);
+      // handle unauthorized request
+      if (response.data.code === Amity.ServerError.UNAUTHORIZED) {
+        fireEvent('tokenTerminated', Amity.SessionStates.TERMINATED);
+      }
+
+      // handle request cancellation
+      if (axios.isCancel(error)) {
+        fireEvent('tokenExpired', Amity.SessionStates.TOKEN_EXPIRED);
+
+        throw new ASCError(
+          'Token expired',
+          Amity.ClientError.TOKEN_EXPIRED,
+          Amity.ErrorLevel.FATAL,
+        );
+      }
+
+      if (response?.data) unwrapPayload(response.data);
     },
   );
 

package/src/core/transports/mqtt.ts

@@ -21,7 +21,7 @@ export function getMqttOptions(params: {
 }): IClientOptions {
   return {
     clean: false, // keep subscriptions
-    clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`,
+    clientId: `mqttjs_ + ${Math.random().toString(16).substring(2, 10)}`,
     protocolId: 'MQTT',
     protocolVersion: 4,
     reconnectPeriod: 0, // disable auto reconnect

package/src/external/api/createUserToken.ts

@@ -26,11 +26,11 @@ export const createUserToken = async (
   },
 ) => {
   const deviceId = getDeviceId();
-  const deviceInfo = await getDeviceInfo();
+  const deviceInfo = getDeviceInfo();
   const http = createHttpTransport(computeUrl('http', apiRegion));
 
   const { data } = await http.post<Amity.Tokens>(
-    '/api/v3/sessions',
+    '/api/v4/sessions',
     {
       ...params,
       deviceId,

package/src/stream/api/tests/createStream.test.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  streamResponse,
+} from '~/utils/tests';
+import { createStream } from '../createStream';
+
+const bundle: Parameters<typeof createStream>[0] = {
+  title: 'my stream',
+  'thumbnailFileId': streamResponse.data.videoStreamings[0].thumbnailFileId,
+};
+
+describe('createStream', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  it('creates a stream and returns the new stream', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(streamResponse);
+
+    const created = await createStream(bundle);
+
+    expect(getActiveClient().http.post).toHaveBeenCalledWith(
+      `/api/v3/video-streaming`,
+      bundle
+    );
+    expect(created.data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+});

package/src/stream/api/tests/deleteStream.test.ts

@@ -0,0 +1,48 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, streamResponse } from '~/utils/tests';
+
+import { deleteStream } from '~/stream/api';
+
+const STREAM_ID = streamResponse.data.videoStreamings[0].streamId;
+
+const resolvedDeleteValue = {
+  data: {
+    success: true,
+  },
+};
+
+jest.mock('~/stream/api/getStream', () => ({
+  getStream: jest.fn(() => Promise.resolve(streamResponse.data.videoStreamings[0])),
+}));
+
+describe('deleteStream', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('should return deleted stream', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+
+    await expect(deleteStream(STREAM_ID)).resolves.toEqual(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(deleteStream(STREAM_ID)).rejects.toThrow('error');
+  });
+
+  test('should update cache after deleted stream', async () => {
+    enableCache();
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+    pushToCache(['community', 'get', STREAM_ID], streamResponse.data.videoStreamings[0]);
+
+    await deleteStream(STREAM_ID);
+    const recieved = pullFromCache(['stream', 'get', STREAM_ID])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining({
+      isDeleted: true
+    }));
+
+    disableCache();
+  });
+});

package/src/stream/api/tests/getStream.test.ts

@@ -0,0 +1,23 @@
+import { enableCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, streamResponse } from '~/utils/tests';
+import { getStream } from '~/stream/api';
+
+const STREAM_ID = streamResponse.data.videoStreamings[0].streamId;
+
+describe('getStream', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('Should return the stream from backend', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValueOnce(streamResponse);
+    const { data } = await getStream(STREAM_ID);
+    expect(data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+
+  test('Should return stream from locally', () => {
+    const stream: ReturnType<typeof getStream.locally> = getStream.locally(STREAM_ID);
+
+    expect(stream?.data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+});