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

package/src/client/api/connectClient.ts

@@ -4,19 +4,34 @@ import { disconnectClient } from '~/client/api/disconnectClient';
 import { getDeviceId } from '~/core/device';
 import { proxyWebsocketEvents } from '~/core/events';
 import {
+  getUserTopic,
   getNetworkTopic,
   getSmartFeedChannelTopic,
   getSmartFeedMessageTopic,
   getSmartFeedSubChannelTopic,
   subscribeTopic,
 } from '~/core/subscription';
+
 import { onUserDeleted } from '~/user/events/onUserDeleted';
 
 import { getActiveClient } from './activeClient';
-import { setActiveUser } from './activeUser';
+import { terminateClient } from './terminateClient';
+import { setActiveUser, getActiveUser } from './activeUser';
+
+import { setSessionState } from './setSessionState';
 
-import { getToken } from './getToken';
 import { onClientBanned } from '../events';
+import { onTokenExpired } from '../events/onTokenExpired';
+import { onTokenTerminated } from '../events/onTokenTerminated';
+
+import { setClientToken } from '../utils/setClientToken';
+
+/*
+ * declared earlier to accomodate case when logging in with a different user
+ * than the one already connected, in which case the existing subscriptions need
+ * to be cleared
+ */
+const subscriptions: Amity.Unsubscriber[] = [];
 
 /**
  * ```js
@@ -40,52 +55,118 @@ import { onClientBanned } from '../events';
  */
 export const connectClient = async (
   params: Amity.ConnectClientParams,
+  sessionHandler: Amity.SessionHandler,
   config?: Amity.ConnectClientConfig,
 ): Promise<boolean> => {
   const client = getActiveClient();
-  client.log('client/api/connectClient', { apiKey: client.apiKey, ...params });
+  let unsubWatcher: Amity.Unsubscriber;
+
+  client.log('client/api/connectClient', {
+    apiKey: client.apiKey,
+    sessionState: client.sessionState,
+    ...params,
+  });
+
+  // if connecting to a different userId than the one that is connected currently
+  if (client.userId && client.userId !== params.userId) {
+    await disconnectClient();
+
+    // Remove subscription to ban and delete
+    subscriptions.forEach(fn => fn());
+  }
 
   // default values
   params.deviceId ??= getDeviceId();
 
-  // @ts-ignore: in that particular case, typing can be
-  // ignored since we enforce default values just before.
-  const { accessToken, users } = await getToken(params);
+  try {
+    // @ts-ignore: in that particular case, typing can be
+    // ignored since we enforce default values just before.
+    const { users } = await setClientToken(params);
 
-  // manually setup the token for http, ws transport
-  client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
-  client.ws.io.opts.query = { token: accessToken };
+    // FIXME: events are duplicated if connectClient is called few times without disconnectClient
+    // wire websocket events to our event emitter
+    proxyWebsocketEvents(client.ws, client.emitter);
 
-  // FIXME: events are duplicated if connectClient is called few times without disconnectClient
-  // wire websocket events to our event emitter
-  proxyWebsocketEvents(client.ws, client.emitter);
+    // TODO: in phase 2, this should not be necessary. we should have WS
+    // to be connected "on demand" rather than "by default"
+    await new Promise(resolve => {
+      client.ws.once('connect', resolve);
+      client.ws.open();
+    });
 
-  // TODO: in phase 2, this should not be necessary. we should have WS
-  // to be connected "on demand" rather than "by default"
-  await new Promise(resolve => {
-    client.ws.once('connect', resolve);
-    client.ws.open();
-  });
+    client.userId = params.userId;
+
+    client.sessionHandler = sessionHandler;
 
-  client.userId = params.userId;
-  client.accessToken = accessToken;
+    /*
+     * Cannot push to subscriptions as watcher needs to continue working even if
+     * token expires
+     */
+    unsubWatcher = client.accessTokenExpiryWatcher(
+      client.token?.issuedAt!,
+      client.token?.expiresAt!,
+      sessionHandler!,
+    );
 
-  setActiveUser(users[0]);
+    setActiveUser(users[0]);
+  } catch (error) {
+    /*
+     * if getting token failed session state reverts to initial state when app
+     * is first launched
+     */
+    setSessionState(Amity.SessionStates.NOT_LOGGED_IN);
+
+    // pass error down tree so the calling function handle it
+    throw error;
+  }
 
   if (config?.disableRTE !== true) {
     subscribeTopic(getNetworkTopic());
     subscribeTopic(getSmartFeedChannelTopic());
     subscribeTopic(getSmartFeedSubChannelTopic());
     subscribeTopic(getSmartFeedMessageTopic());
+    // subscribing to user topic is necessary to handle ban event
+    subscribeTopic(getUserTopic(getActiveUser()));
   }
 
-  const subscriptions = [
-    onClientBanned(() => {
+  subscriptions.push(
+    // GLOBAL_BAN
+    onClientBanned((_: Amity.UserPayload) => {
+      terminateClient();
+
+      subscriptions.forEach(fn => fn());
+
+      unsubWatcher();
+    }),
+
+    onTokenTerminated(_ => {
+      terminateClient();
+
+      subscriptions.forEach(fn => fn());
+
+      unsubWatcher();
+    }),
+
+    onUserDeleted((user: Amity.User) => {
+      if (user.userId === client.userId) {
+        terminateClient();
+
+        subscriptions.forEach(fn => fn());
+
+        unsubWatcher();
+      }
+    }),
+
+    onTokenExpired(state => {
+      setSessionState(state);
+
       disconnectClient();
+
       subscriptions.forEach(fn => fn());
     }),
+
     onUserDeleted(() => null),
-  ];
+  );
 
   return client.ws.connected;
 };

package/src/client/api/createClient.ts

@@ -14,6 +14,8 @@ import { createEventEmitter } from '~/core/events';
 import { getActiveClient, setActiveClient } from './activeClient';
 import { getFeedSettings } from './getFeedSettings';
 
+import { accessTokenExpiryWatcher } from './accessTokenExpiryWatcher';
+
 const DEFAULT_DEBUG_SESSION = 'amity';
 
 /**
@@ -27,7 +29,7 @@ const DEFAULT_DEBUG_SESSION = 'amity';
  * @param apiKey for the {@link Amity.Client} instance
  * @param apiRegion endpoint to connect to
  * @param apiEndpoint custom endpoint in case you don't want to use a preset endpoint
- * @param debugSession session's identifier for the client's logger instance
+ * @param param.debugSession session's identifier for the client's logger instance
  * @returns A {@link Amity.Client} instance
  *
  * @category Client API
@@ -59,6 +61,9 @@ export const createClient = (
 
   const emitter = createEventEmitter();
 
+  const sessionState = Amity.SessionStates.NOT_LOGGED_IN;
+  const sessionHandler = undefined;
+
   const client = {
     version: `${VERSION}`,
 
@@ -68,8 +73,11 @@ export const createClient = (
     ws,
     mqtt,
     emitter,
+    accessTokenExpiryWatcher,
     use: () => setActiveClient(client),
 
+    sessionState,
+    sessionHandler,
     getFeedSettings,
   };
 

package/src/client/api/disconnectClient.ts

@@ -1,4 +1,5 @@
 import { getActiveClient } from './activeClient';
+import { setSessionState } from './setSessionState';
 
 /**
  * ```js
@@ -8,7 +9,6 @@ import { getActiveClient } from './activeClient';
  *
  * Disconnects an {@link Amity.Client} instance from ASC servers
  *
- * @param client The {@link Amity.Client} instance to disconnect
  * @returns a success boolean if disconnected
  *
  * @category Client API
@@ -16,6 +16,7 @@ import { getActiveClient } from './activeClient';
  */
 export const disconnectClient = async (): Promise<boolean> => {
   const client = getActiveClient();
+
   client.log('client/api/disconnectClient');
 
   await new Promise(resolve => {
@@ -29,7 +30,30 @@ export const disconnectClient = async (): Promise<boolean> => {
   client.ws.removeAllListeners();
   client.mqtt.removeAllListeners();
   client.userId = undefined;
-  client.accessToken = undefined;
+  client.token = undefined;
+
+  client.http.defaults.headers.common.Authorization = '';
+  client.ws.io.opts.query = { token: '' };
+
+  /*
+   * for cases when session state is terminated (example on ban) or token expired,
+   * the terminating block will set session state to terminated or for the or
+   * in the case of expired token the same happens
+   *
+   * establishing state also ignored in cases where accessTokenExpiryWatcher
+   * calls renewal. There is a possibility that renewal will be called before
+   * disconnectClient finishes execution
+   */
+  if (client.sessionState === Amity.SessionStates.ESTABLISHED)
+    setSessionState(Amity.SessionStates.NOT_LOGGED_IN);
+
+  /*
+   * Cache should be usable if tokenExpired
+   * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#SDK-usability-based-on-Session-State
+   */
+  if (client.sessionState !== Amity.SessionStates.TOKEN_EXPIRED && client.cache) {
+    client.cache = { data: {} };
+  }
 
   return !client.ws.connected;
 };

package/src/client/api/getToken.ts

@@ -5,10 +5,10 @@ import { getDeviceInfo } from '~/core/device';
 /**
  * Retrieves a pair of {@link Amity.Tokens} necessary for connection
  *
- * @param userId The userId to use to issue a token
- * @param displayName The user's displayName
- * @param deviceId The user's device Id (can be manually set for native users)
- * @param authToken The authentication token - necessary when network option is set to secure
+ * @param params.userId The userId to use to issue a token
+ * @param params.displayName The user's displayName
+ * @param params.deviceId The user's device Id (can be manually set for native users)
+ * @param params.authToken The authentication token - necessary when network option is set to secure
  * @return The accessToken for the given userId
  *
  * @category Client API
@@ -23,10 +23,10 @@ export const getToken = async (params: {
   const client = getActiveClient();
   client.log('client/api/getToken', params);
 
-  const deviceInfo = await getDeviceInfo();
+  const deviceInfo = getDeviceInfo();
 
   const { data } = await client.http.post<Amity.Tokens & { users: Amity.User[] }>(
-    '/v1/device',
+    '/api/v3/sessions',
     {
       ...params,
       deviceInfo,

package/src/client/api/index.ts

@@ -8,3 +8,5 @@ export * from './disconnectClient';
 export * from './isConnected';
 
 export * from './getFeedSettings';
+
+export * from './renewal';

package/src/client/api/renewal.ts

@@ -0,0 +1,74 @@
+import { getDeviceId } from '~/core/device';
+import { ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
+
+import { getActiveUser } from './activeUser';
+import { setClientToken as refreshToken } from '../utils/setClientToken';
+import { getActiveClient } from './activeClient';
+import { connectClient } from './connectClient';
+
+/*
+ * Renewal defintion accepted by SessionHandler interface
+ *
+ * Tech Spec:
+ * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Session-Handler
+ *
+ * @category private
+ */
+export const renewal = (): Amity.AccessTokenRenewal => {
+  let tokenRenewed = false;
+  let renewTimeoutId: ReturnType<typeof setTimeout>;
+
+  const client = getActiveClient();
+
+  client.log('initiating access token renewal');
+  /*
+   * Renews a token if it is hasn't been renewed before. Also marks token as
+   * renewed once done
+   * Per instance of Renewal, only one renewal is allowed
+   */
+  const renewToken = async (authToken?: Amity.ConnectClientParams['authToken']): Promise<void> => {
+    const { userId, displayName } = getActiveUser();
+    const deviceId = getDeviceId();
+
+    const params = { userId, displayName, authToken, deviceId };
+
+    if (client.sessionState === Amity.SessionStates.TOKEN_EXPIRED) {
+      // sessionHandler will never be empty when renewal is instantiatied
+      await connectClient(params, client.sessionHandler!);
+    } else {
+      // about to expire
+
+      // @ts-ignore: in that particular case, typing can be
+      // ignored since we enforce default values just before.
+      await refreshToken(params);
+    }
+
+    tokenRenewed = true;
+
+    if (renewTimeoutId) clearTimeout(renewTimeoutId);
+  };
+
+  return {
+    renew: () => {
+      if (tokenRenewed) {
+        console.log("'renew' method can be called only once per renewal instance");
+        return;
+      }
+      renewToken();
+    },
+
+    renewWithAuthToken: (authToken: string) => {
+      if (tokenRenewed) {
+        console.log("'renewWithAuthToken' method can be called only once per renewal instance");
+        return;
+      }
+      renewToken(authToken);
+    },
+
+    unableToRetrieveAuthToken: () => {
+      renewTimeoutId = setTimeout(() => {
+        client.sessionHandler?.sessionWillRenewAccessToken(renewal());
+      }, ACCESS_TOKEN_WATCHER_INTERVAL);
+    },
+  };
+};

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,132 @@
+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({
+        expiresAt: aboutToExpireTime.toISOString(),
+        issuedAt: 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/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);
+  });
+});