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

package/src/client/api/setSessionState.ts

@@ -0,0 +1,75 @@
+import { fireEvent } from '~/core/events';
+import { ASCError } from '~/core/errors';
+
+import { getActiveClient } from './activeClient';
+
+/*
+ * Session States cannot be set arbitarily.
+ * These are the possible new states based on the current state
+ * Check tech spec for details:
+ * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Session-State
+ */
+const sessisonStateTransitions: Record<Amity.SessionStates, Amity.SessionStates[]> = {
+  // notLoggedIn -> establishing
+  [Amity.SessionStates.NOT_LOGGED_IN]: [Amity.SessionStates.ESTABLISHING],
+  // terminated -> establishing
+  [Amity.SessionStates.TERMINATED]: [Amity.SessionStates.ESTABLISHING],
+  // establishing -> notLoggedIn, established
+  [Amity.SessionStates.ESTABLISHING]: [
+    Amity.SessionStates.NOT_LOGGED_IN,
+    Amity.SessionStates.ESTABLISHED,
+  ],
+  /*
+   * established -> notLoggedIn, terminated, tokenExpired, establishing (for
+   * cases when logging in same user)
+   */
+  [Amity.SessionStates.ESTABLISHED]: [
+    Amity.SessionStates.NOT_LOGGED_IN,
+    Amity.SessionStates.TERMINATED,
+    Amity.SessionStates.TOKEN_EXPIRED,
+    Amity.SessionStates.ESTABLISHING,
+  ],
+  // tokenExpired -> establishing
+  [Amity.SessionStates.TOKEN_EXPIRED]: [Amity.SessionStates.ESTABLISHING],
+};
+
+export const isValidStateChange = (
+  prevState: Amity.SessionStates,
+  nextState: Amity.SessionStates,
+): boolean => {
+  return sessisonStateTransitions[prevState].includes(nextState);
+};
+
+/**
+ * Checks if a {@link Amity.Client} instance is connected to ASC servers
+ *
+ *
+ * @param state the new session state
+ * @returns a success boolean if connected
+ *
+ * @category private
+ */
+export const setSessionState = (state: Amity.SessionStates): boolean => {
+  const client = getActiveClient();
+
+  client.log('client/api/setSessionState', state);
+
+  const { sessionState: prevState } = client;
+
+  if (prevState === state) return false;
+
+  // check if transition is valid
+  if (!isValidStateChange(prevState, state)) {
+    throw new ASCError(
+      `Session state cannot change from ${prevState} to ${state}`,
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.ERROR,
+    );
+  }
+
+  client.sessionState = state;
+
+  fireEvent('sessionStateChange', state);
+
+  return true;
+};

package/src/client/api/terminateClient.ts

@@ -0,0 +1,20 @@
+import { disconnectClient } from './disconnectClient';
+import { setSessionState } from './setSessionState';
+import { getActiveClient } from './activeClient';
+
+/**
+ * Terminates {@link Amity.Client} instance
+ *
+ *
+ *
+ * @category private
+ */
+export const terminateClient = () => {
+  const client = getActiveClient();
+
+  setSessionState(Amity.SessionStates.TERMINATED);
+
+  client.sessionHandler = undefined;
+
+  disconnectClient();
+};

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

@@ -0,0 +1,129 @@
+import { client, connectClient, disconnectClient } from '~/utils/tests';
+import { ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
+
+import { accessTokenExpiryWatcher, isAboutToExpire, isExpired } from '../accessTokenExpiryWatcher';
+
+import { onTokenExpired } from '~/client/events/onTokenExpired';
+
+describe('accessTokenExpiryWatcher', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  const expiresAt = new Date().toISOString();
+  const issuedAt = new Date().toISOString();
+
+  test('it should fire event when session expires', async () => {
+    const sessionHandler: Amity.SessionHandler = {
+      sessionWillRenewAccessToken(_) {
+        // do nothing
+      },
+    };
+
+    jest.useFakeTimers();
+    const callback = jest.fn();
+    const expected = Amity.SessionStates.TOKEN_EXPIRED;
+
+    const unsub = onTokenExpired(callback);
+    const stopWatcher = accessTokenExpiryWatcher(expiresAt, issuedAt, sessionHandler!);
+
+    jest.advanceTimersByTime(ACCESS_TOKEN_WATCHER_INTERVAL + 1);
+
+    expect(callback).toBeCalledWith(expected);
+
+    unsub();
+    stopWatcher();
+  });
+
+  test('it should renew token if session is about to expire', async () => {
+    jest.useFakeTimers();
+    const callback = jest.fn();
+
+    const sessionHandler = { sessionWillRenewAccessToken: callback };
+    client.sessionHandler = sessionHandler;
+
+    const stopWatcher = accessTokenExpiryWatcher(expiresAt, issuedAt, sessionHandler);
+
+    const oldIssuedAtTime = new Date();
+    const aboutToExpireTime = new Date();
+
+    aboutToExpireTime.setMinutes(aboutToExpireTime.getMinutes() + 30);
+    oldIssuedAtTime.setDate(oldIssuedAtTime.getDate() - 1);
+
+    aboutToExpireTime.setHours(aboutToExpireTime.getHours() + 1);
+
+    if (client.token) {
+      client.token.expiresAt = aboutToExpireTime.toISOString();
+      client.token.issuedAt = oldIssuedAtTime.toISOString();
+    }
+
+    jest.advanceTimersByTime(ACCESS_TOKEN_WATCHER_INTERVAL + 1);
+    stopWatcher();
+
+    expect(callback).toHaveBeenCalled();
+  });
+
+  test('it should renew token if session has expired', async () => {
+    jest.useFakeTimers();
+    const callback = jest.fn();
+
+    const sessionHandler = { sessionWillRenewAccessToken: callback };
+    client.sessionHandler = sessionHandler;
+
+    const stopWatcher = accessTokenExpiryWatcher(expiresAt, issuedAt, sessionHandler);
+    if (client.token) client.token.expiresAt = new Date().toISOString();
+
+    jest.advanceTimersByTime(ACCESS_TOKEN_WATCHER_INTERVAL + 1);
+
+    expect(callback).toHaveBeenCalled();
+
+    stopWatcher();
+  });
+});
+
+describe('accessTokenExpiryWatcher > aboutToExpire', () => {
+  const expiresAt = new Date().toISOString();
+  const issuedAt = new Date().toISOString();
+  const oldIssuedAtTime = new Date();
+  const aboutToExpireTime = new Date();
+
+  test('it should return true if about to expire', () => {
+    oldIssuedAtTime.setDate(oldIssuedAtTime.getDate() - 1);
+
+    aboutToExpireTime.setHours(aboutToExpireTime.getHours() + 1);
+
+    expect(isAboutToExpire(aboutToExpireTime.toISOString(), oldIssuedAtTime.toISOString())).toBe(
+      true,
+    );
+  });
+
+  test('it should return false if token expired', () => {
+    expect(isAboutToExpire(expiresAt, issuedAt)).toBe(false);
+  });
+
+  test('it should return false if not about to expire', () => {
+    oldIssuedAtTime.setDate(oldIssuedAtTime.getDate() - 10);
+
+    expect(isAboutToExpire(expiresAt, issuedAt)).toBe(false);
+  });
+});
+
+describe('accessTokenExpiryWatcher > isExpired', () => {
+  let expiresAt = new Date().toISOString();
+
+  test('it should return true if token expired', () => {
+    expect(isExpired(expiresAt)).toBe(true);
+  });
+
+  test('it should return false if token not about expired', () => {
+    const laterDate = new Date();
+    laterDate.setMonth(laterDate.getMonth() + 1);
+    expiresAt = laterDate.toISOString();
+
+    expect(isExpired(expiresAt)).toBe(false);
+  });
+});

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

@@ -0,0 +1,20 @@
+import { getActiveClient } from '../activeClient';
+import { connectClient, disconnectClient } from '~/utils/tests';
+
+describe('API: Active Client', () => {
+  afterAll(disconnectClient);
+
+  test('should got error message when activeClient is offline', () => {
+    try {
+      getActiveClient();
+    } catch (error) {
+      expect(String(error)).toContain('Error: Amity SDK (800000): There is no active client');
+    }
+  });
+
+  test('should get client when activeClient is online', async () => {
+    await connectClient();
+    const data = getActiveClient();
+    expect(data.userId).toBe('test');
+  });
+});

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

@@ -0,0 +1,20 @@
+import { getActiveUser } from '../activeUser';
+import { connectClient, disconnectClient } from '~/utils/tests';
+
+describe('API: Active User', () => {
+  afterAll(disconnectClient);
+
+  test('should got error message when client is offline', () => {
+    try {
+      getActiveUser();
+    } catch (error) {
+      expect(String(error)).toContain('Error: Amity SDK (800000): Connect client first');
+    }
+  });
+
+  test('should get active user when client is online', async () => {
+    await connectClient();
+    const data = getActiveUser();
+    expect(data.userId).toBe('test');
+  });
+});

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 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';