@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

package/src/client/api/renewal.ts

@@ -0,0 +1,120 @@
+import { getDeviceId } from '~/core/device';
+import { ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
+
+import { setClientToken as refreshToken } from '../utils/setClientToken';
+import { setVisitorClientToken as refreshVisitorToken } from '../utils/setVisitorClientToken';
+import { getActiveClient } from './activeClient';
+import { login } from './login';
+import { loginAsVisitor } from './loginAsVisitor';
+import { getCurrentUser } from './getCurrentUser';
+
+/* begin_public_function
+  id: client.renew_access_token
+*/
+/*
+ * 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 } = getCurrentUser();
+    const deviceId = await getDeviceId();
+
+    const params = { userId, displayName, authToken, deviceId };
+
+    if (client.sessionState === Amity.SessionStates.TOKEN_EXPIRED && client.sessionHandler) {
+      await login(params, client.sessionHandler);
+    } else {
+      // about to expire
+
+      await refreshToken({
+        params,
+        options: {
+          setAccessTokenCookie: true,
+        },
+      });
+    }
+
+    tokenRenewed = true;
+
+    if (renewTimeoutId) clearTimeout(renewTimeoutId);
+  };
+
+  const renewVisitorToken = async ({
+    authSignature,
+    authSignatureExpiresAt,
+  }: Amity.ConnectClientAsVisitorParams): Promise<void> => {
+    const deviceId = await getDeviceId();
+
+    if (client.sessionState === Amity.SessionStates.TOKEN_EXPIRED && client.sessionHandler) {
+      await loginAsVisitor({ sessionHandler: client.sessionHandler });
+    } else {
+      // about to expire
+
+      await refreshVisitorToken({
+        params: { authSignature, authSignatureExpiresAt, deviceId },
+        options: {
+          setAccessTokenCookie: true,
+        },
+      });
+    }
+
+    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);
+    },
+
+    renewWithAuthSignature: (params: Amity.ConnectClientAsVisitorParams) => {
+      if (tokenRenewed) {
+        console.log("'renew' method can be called only once per renewal instance");
+        return;
+      }
+      renewVisitorToken(params);
+    },
+
+    unableToRetrieveAuthSignature: () => {
+      renewTimeoutId = setTimeout(() => {
+        client.sessionHandler?.sessionWillRenewAccessToken(renewal());
+      }, ACCESS_TOKEN_WATCHER_INTERVAL);
+    },
+  };
+};
+/* end_public_function */

package/src/client/api/resumeSession.ts

@@ -0,0 +1,270 @@
+import jwtDecode from 'jwt-decode';
+/* eslint-disable no-param-reassign */
+import { modifyMqttConnection } from '~/client/utils/modifyMqttConnection';
+/* eslint-disable require-atomic-updates */
+import { proxyWebsocketEvents } from '~/core/events';
+import { onChannelDeleted } from '~/channelRepository/events/onChannelDeleted';
+import { onChannelMemberBanned } from '~/channelRepository/events/onChannelMemberBanned';
+
+import { markReadEngineOnLoginHandler } from '~/subChannelRepository/utils/markReadEngine';
+import { onUserDeleted } from '~/userRepository/events/onUserDeleted';
+
+import analyticsEngineOnLoginHandler from '~/analytic/utils/analyticsEngineOnLoginHandler';
+import readReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler';
+import legacyReadReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngineOnLoginHandler';
+import objectResolverEngineOnLoginHandler from '~/client/utils/ObjectResolver/objectResolverEngineOnLoginHandler';
+import { logout } from './logout';
+
+import { getActiveClient } from './activeClient';
+import { terminateClient } from './terminateClient';
+import { setActiveUser } from './activeUser';
+import { setSessionState } from './setSessionState';
+
+import { onClientBanned } from '../events';
+import { onTokenExpired } from '../events/onTokenExpired';
+import { onTokenTerminated } from '../events/onTokenTerminated';
+
+import { removeChannelMarkerCache } from '../utils/removeChannelMarkerCache';
+import { initializeMessagePreviewSetting } from '../utils/messagePreviewEngine';
+import { ASCError } from '~/core/errors';
+import SessionWatcher from '../utils/SessionWatcher';
+
+/*
+ * 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
+ */
+let subscriptions: Amity.Unsubscriber[] = [];
+
+async function runMqtt() {
+  await modifyMqttConnection();
+}
+
+interface Params {
+  userId: string;
+  token: {
+    issuedAt: string;
+    expiresAt: string;
+    accessToken: string;
+  };
+}
+
+const isSameUserId = (token: Params['token']['accessToken']) => {
+  const client = getActiveClient();
+
+  const decoded = jwtDecode<{
+    user: {
+      userId: string;
+      publicUserId: string;
+      deviceInfo: Amity.Device['deviceInfo'];
+      networkId: string;
+      displayName: string;
+      refreshToken: string;
+    };
+  }>(token);
+
+  return decoded?.user?.publicUserId === client.userId;
+};
+
+const validateAccessToken = async ({ token, userId }: Params) => {
+  const client = getActiveClient();
+  // begin establishing session
+  setSessionState(Amity.SessionStates.ESTABLISHING);
+
+  const {
+    data: { users },
+  } = await client.http.get(`/api/v3/users/${userId}`, {
+    headers: {
+      Authorization: `Bearer ${token.accessToken}`,
+    },
+  });
+
+  const user = users.find((u: Amity.User) => u.userId === userId);
+
+  client.http.defaults.headers.common.Authorization = `Bearer ${token.accessToken}`;
+
+  client.http.defaults.metadata = {
+    tokenExpiry: token.expiresAt,
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
+  client.upload.defaults.headers.common.Authorization = `Bearer ${token.accessToken}`;
+
+  client.upload.defaults.metadata = {
+    tokenExpiry: token.expiresAt,
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
+  client.token = token;
+
+  setSessionState(Amity.SessionStates.ESTABLISHED);
+
+  return user;
+};
+
+/* begin_public_function
+  id: client.resumeSession
+*/
+/**
+ * ```js
+ * import { resumeSession } from '@amityco/ts-sdk/client/api'
+ * const success = await resumeSession({
+ *   userId: 'XYZ123456789',
+ *   token: { accessToken: 'abc123', issuedAt: '2023-01-01T00:00:00Z', expiresAt: '2023-01-02T00:00:00Z' }
+ * })
+ * ```
+ *
+ * Connects an {@link Amity.Client} instance to ASC servers using an existing access token
+ *
+ * @param params the connect parameters
+ * @param params.userId the user ID for the current session
+ * @param params.token the existing access token with its metadata
+ * @param sessionHandler the session handler for token renewal
+ * @param config optional configuration
+ * @returns a success boolean if connected
+ *
+ * @category Client API
+ * @async
+ */
+export const resumeSession = async (
+  params: Params,
+  sessionHandler: Amity.SessionHandler,
+  config?: Amity.ConnectClientConfig,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  let unsubWatcher: Amity.Unsubscriber;
+
+  client.log('client/api/resumeSession', {
+    apiKey: client.apiKey,
+    sessionState: client.sessionState,
+    ...params,
+  });
+
+  // Handle existing connected user
+  if (client.userId) {
+    if (client.userId === params.userId && isSameUserId(params.token.accessToken)) {
+      // Clear connections and listeners but preserve cache
+      if (client.mqtt && client.mqtt.connected) {
+        client.mqtt.disconnect();
+      }
+
+      // Clear existing subscriptions
+      subscriptions.forEach(fn => fn());
+      subscriptions = [];
+    } else {
+      // Different user - do full logout
+      await logout();
+
+      // Remove subscription to ban and delete
+      subscriptions.forEach(fn => fn());
+      subscriptions = [];
+    }
+  }
+
+  try {
+    const user = await validateAccessToken(params);
+
+    if (user == null) {
+      throw new ASCError(
+        `${params.userId} has not been found`,
+        Amity.ClientError.UNKNOWN_ERROR,
+        Amity.ErrorLevel.ERROR,
+      );
+    }
+
+    if (user.isDeleted) {
+      terminateClient(Amity.TokenTerminationReason.USER_DELETED);
+      return false;
+    }
+
+    if (user.isGlobalBanned) {
+      terminateClient(Amity.TokenTerminationReason.GLOBAL_BAN);
+      return false;
+    }
+
+    client.userId = user.userId;
+
+    client.sessionHandler = sessionHandler;
+
+    /*
+     * Cannot push to subscriptions as watcher needs to continue working even if
+     * token expires
+     */
+    unsubWatcher = client.accessTokenExpiryWatcher(sessionHandler);
+
+    setActiveUser(user);
+  } catch (error) {
+    /*
+     * if getting token failed session state reverts to initial state when app
+     * is first launched
+     */
+    SessionWatcher.getInstance().setSessionState(Amity.SessionStates.NOT_LOGGED_IN);
+
+    // pass error down tree so the calling function handle it
+    throw error;
+  }
+
+  if (config?.disableRTE !== true) {
+    runMqtt();
+  }
+
+  await initializeMessagePreviewSetting();
+
+  if (subscriptions.length === 0) {
+    subscriptions.push(
+      // GLOBAL_BAN
+      onClientBanned((_: Amity.UserPayload) => {
+        terminateClient(Amity.TokenTerminationReason.GLOBAL_BAN);
+
+        subscriptions.forEach(fn => fn());
+
+        unsubWatcher();
+      }),
+
+      onTokenTerminated(_ => {
+        terminateClient();
+
+        subscriptions.forEach(fn => fn());
+
+        unsubWatcher();
+      }),
+
+      onUserDeleted((user: Amity.InternalUser) => {
+        if (user.userId === client.userId) {
+          terminateClient(Amity.TokenTerminationReason.USER_DELETED);
+
+          subscriptions.forEach(fn => fn());
+
+          unsubWatcher();
+        }
+      }),
+
+      onTokenExpired(state => {
+        SessionWatcher.getInstance().setSessionState(state);
+
+        logout();
+
+        subscriptions.forEach(fn => fn());
+      }),
+
+      // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
+      // the channel because currently backend can't handle this, so every time a user is banned from
+      // a channel or the channel is deleted the channel's unread count will not be reset to zero
+      onChannelDeleted(removeChannelMarkerCache),
+      onChannelMemberBanned(removeChannelMarkerCache),
+
+      markReadEngineOnLoginHandler(),
+      analyticsEngineOnLoginHandler(),
+      objectResolverEngineOnLoginHandler(),
+    );
+
+    if (client.useLegacyUnreadCount) {
+      subscriptions.push(readReceiptSyncEngineOnLoginHandler());
+    } else subscriptions.push(legacyReadReceiptSyncEngineOnLoginHandler());
+  }
+
+  return true;
+};
+/* end_public_function */

package/src/client/api/secureLogout.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { logout } from './logout';
+
+/* begin_public_function
+  id: client.secureLogout
+*/
+/**
+ * ```js
+ * import { Client } from '@amityco/ts-sdk'
+ * const success = await Client.secureLogout()
+ * ```
+ *
+ * Revoke access token for current user and disconnects an {@link Amity.Client} instance from ASC servers
+ *
+ * @returns a success boolean if disconnected
+ *
+ * @category Client API
+ * @async
+ */
+export const secureLogout = async (): Promise<boolean> => {
+  const client = getActiveClient();
+  const {
+    data: { success },
+  } = await client.http.delete<{ success: boolean }>('/api/v4/sessions');
+
+  if (!success) {
+    throw new Error('Failed to logout');
+  }
+
+  const result = await logout();
+  return result;
+};
+/* end_public_function */

package/src/client/api/setSessionState.ts

@@ -0,0 +1,75 @@
+import { ASCError } from '~/core/errors';
+
+import SessionWatcher from '~/client/utils/SessionWatcher';
+import { getActiveClient } from './activeClient';
+
+/*
+ * Session States cannot be set arbitrarily.
+ * 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 sessionStateTransitions: 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 the 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 sessionStateTransitions[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;
+
+  SessionWatcher.getInstance().setSessionState(state);
+
+  return true;
+};

package/src/client/api/setUploadedFileAccessType.ts

@@ -0,0 +1,5 @@
+import GlobalFileAccessType from '~/client/utils/GlobalFileAccessType';
+
+export function setUploadedFileAccessType(accessType: Amity.FileAccessType) {
+  GlobalFileAccessType.getInstance().setFileAccessType(accessType);
+}

package/src/client/api/terminateClient.ts

@@ -0,0 +1,28 @@
+import { logout } from './logout';
+import { setSessionState } from './setSessionState';
+import { getActiveClient } from './activeClient';
+
+/**
+ * Terminates {@link Amity.Client} instance
+ *
+ *
+ *
+ * @category private
+ */
+export const terminateClient = (terminationReason?: Amity.TokenTerminationReason) => {
+  const client = getActiveClient();
+
+  setSessionState(Amity.SessionStates.TERMINATED);
+
+  if (client.http.defaults.metadata) {
+    if (terminationReason === Amity.TokenTerminationReason.GLOBAL_BAN)
+      client.http.defaults.metadata.isGlobalBanned = true;
+
+    if (terminationReason === Amity.TokenTerminationReason.USER_DELETED)
+      client.http.defaults.metadata.isUserDeleted = true;
+  }
+
+  client.sessionHandler = undefined;
+
+  logout();
+};

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