@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

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

@@ -0,0 +1,84 @@
+import { ASCApiError } from '~/core/errors';
+import { sessionResponse, user11, disconnectClient } from '~/utils/tests';
+import { connectClient, createClient } from '..';
+import { setActiveClient } from '../activeClient';
+
+let client: Amity.Client;
+
+const sessionHandler: Amity.SessionHandler = {
+  sessionWillRenewAccessToken(_) {
+    // do nothing
+  },
+};
+
+const onConnect = () =>
+  setTimeout(() => {
+    const CONNECT_PACKET = { type: 0, nsp: client.ws.nsp };
+
+    client.ws.emit('connect');
+
+    // simulate a connection ack packet from server
+    client.ws.io.emit('packet', CONNECT_PACKET);
+  }, 50);
+
+describe('connectClient', () => {
+  beforeEach(() => {
+    client = createClient('key', 'sg');
+    client.mqtt.connect = jest.fn();
+    client.mqtt.subscribe = jest.fn();
+    client.http.post = jest.fn().mockResolvedValueOnce(sessionResponse);
+
+    setActiveClient(client);
+  });
+
+  afterEach(async () => {
+    if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
+  });
+
+  test('it should connect client', async () => {
+    onConnect().unref();
+
+    const recieved = await connectClient({ userId: user11.userId }, sessionHandler);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should establish connection', async () => {
+    onConnect().unref();
+
+    await connectClient({ userId: user11.userId }, sessionHandler);
+    const { sessionState } = client;
+
+    expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
+  });
+
+  test('it should have session state establishing while connecting client', () => {
+    connectClient({ userId: user11.userId }, sessionHandler);
+
+    expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHING);
+  });
+
+  test('it should have session state notLoggedIn on failure', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValue(
+        new ASCApiError('unauthorzed', Amity.ServerError.UNAUTHORIZED, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(connectClient({ userId: user11.userId }, sessionHandler)).rejects.toThrow(
+      'unauthorzed',
+    );
+    expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
+  });
+
+  test('it should terminate session on ban', async () => {
+    onConnect().unref();
+
+    await connectClient({ userId: user11.userId }, sessionHandler);
+
+    // ban user
+    client.emitter.emit('user.didGlobalBan', {} as Amity.UserPayload);
+
+    expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
+  });
+});

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

@@ -0,0 +1,48 @@
+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);
+  });
+
+  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 v4/sessions api', async () => {
+    const expected = '/api/v4/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

@@ -1 +1,6 @@
-export * from './onClientDisconnected'
+export * from './onConnectionError';
+
+export * from './onClientDisconnected';
+export * from './onClientBanned';
+
+export * from './onSessionStateChange';

package/src/client/events/onClientBanned.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onClientBanned } from '@amityco/ts-sdk'
+ * const dispose = onClientBanned(() => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} have been banned from the platform
+ *
+ * @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 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/onClientDisconnected.ts

@@ -1,11 +1,9 @@
-import { getActiveClient } from '~/client/api'
-
-import { createEventSubscriber } from '~/core/events'
+import { onConnectionError } from './onConnectionError';
 
 /**
  * ```js
  * import { onClientDisconnected } from '@amityco/ts-sdk'
- * const dispose = onClientDisconnected(reason => {
+ * const dispose = onClientDisconnected(() => {
  *   // ...
  * })
  * ```
@@ -17,13 +15,8 @@ import { createEventSubscriber } from '~/core/events'
  *
  * @category Client Events
  */
-export const onClientDisconnected = (
-  callback: Amity.Listener<void>,
-): Amity.Unsubscriber => {
-  return createEventSubscriber(
-    getActiveClient(),
-    'client/onClientDisconnected',
-    'disconnected',
-    () => callback(),
-  )
-}
+export const onClientDisconnected = (callback: Amity.Listener<void>): Amity.Unsubscriber => {
+  return onConnectionError(({ code }) => {
+    code === Amity.ClientError.DISCONNECTED && callback();
+  });
+};

package/src/client/events/onConnectionError.ts

@@ -0,0 +1,46 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+import { ASCError, ASCConnectionError } from '~/core/errors';
+
+const EVENTS = [
+  'disconnected',
+  'error',
+  'connect_error',
+  'reconnect_error',
+  'reconnect_failed',
+] as const;
+
+/**
+ * ```js
+ * import { onConnectionError } from '@amityco/ts-sdk'
+ * const dispose = onClientBanned(() => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} have been banned from the platform
+ *
+ * @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 onConnectionError = (callback: Amity.Listener<ASCError>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const subscribers = EVENTS.map(event =>
+    createEventSubscriber(client, `client/onConnectionError(${event})`, event, response => {
+      const error = response?.code
+        ? new ASCError(response.message, response.code, Amity.ErrorLevel.FATAL)
+        : new ASCConnectionError(event);
+
+      callback(error);
+    }),
+  );
+
+  return () => {
+    subscribers.forEach(fn => fn());
+  };
+};

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();
+  });
+});