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

package/src/client/api/renewal.ts

@@ -1,120 +0,0 @@
-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

@@ -1,270 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

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

package/src/client/api/terminateClient.ts

@@ -1,28 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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');
-  });
-});