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

package/src/client/api/login.ts

@@ -0,0 +1,210 @@
+/* eslint-disable no-param-reassign */
+import { modifyMqttConnection } from '~/client/utils/modifyMqttConnection';
+/* eslint-disable require-atomic-updates */
+import { getDeviceId } from '~/core/device';
+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 reactionSyncEngineOnLoginHandler from '~/liveReactionRepository/utils/ReactionSyncEngineOnLoginHandler';
+import { logout } from './logout';
+
+import { getActiveClient } from './activeClient';
+import { terminateClient } from './terminateClient';
+import { setActiveUser } from './activeUser';
+
+import { onClientBanned } from '../events';
+import { onTokenExpired } from '../events/onTokenExpired';
+import { onTokenTerminated } from '../events/onTokenTerminated';
+
+import { setClientToken } from '../utils/setClientToken';
+import { removeChannelMarkerCache } from '../utils/removeChannelMarkerCache';
+import { initializeMessagePreviewSetting } from '../utils/messagePreviewEngine';
+import { ASCError } from '~/core/errors';
+import SessionWatcher from '../utils/SessionWatcher';
+import { setCurrentUserType } from './getCurrentUserType';
+import { setCurrentUser } from '../utils/setCurrentUser';
+
+/*
+ * 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();
+}
+
+/* begin_public_function
+  id: client.login
+*/
+/**
+ * ```js
+ * import { login } from '@amityco/ts-sdk/client/api'
+ * const success = await login({
+ *   userId: 'XYZ123456789',
+ * })
+ * ```
+ *
+ * Connects an {@link Amity.Client} instance to ASC servers
+ *
+ * @param params the connect parameters
+ * @param params.userId the user ID for the current session
+ * @param params.displayName the user's displayName for the current session
+ * @param params.deviceId Manual override of the user's device id (for device management)
+ * @param params.authToken The authentication token - necessary when network option is set to secure
+ * @returns a success boolean if connected
+ *
+ * @category Client API
+ * @async
+ */
+export const login = async (
+  params: Amity.ConnectClientParams,
+  sessionHandler: Amity.SessionHandler,
+  config?: Amity.ConnectClientConfig,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  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 logout();
+
+    // Remove subscription to ban and delete
+    subscriptions.forEach(fn => fn());
+    subscriptions = [];
+  }
+
+  // default values
+  const defaultDeviceId = await getDeviceId();
+
+  try {
+    const { users, userType } = await setClientToken({
+      params: {
+        ...params,
+        displayName: params?.displayName,
+        deviceId: params?.deviceId || defaultDeviceId,
+      },
+      options: {
+        setAccessTokenCookie: true,
+      },
+    });
+
+    const user = users.find(u => u.userId === params.userId);
+
+    if (user == null) {
+      throw new ASCError(
+        `${params.userId} has not been founded`,
+        Amity.ClientError.UNKNOWN_ERROR,
+        Amity.ErrorLevel.ERROR,
+      );
+    }
+
+    if (user.isDeleted) {
+      terminateClient(Amity.TokenTerminationReason.USER_DELETED);
+      return false;
+    }
+
+    if (user.isGlobalBan) {
+      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);
+
+    setCurrentUser({ user, userType });
+  } 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(),
+      reactionSyncEngineOnLoginHandler(),
+    );
+
+    if (client.useLegacyUnreadCount) {
+      subscriptions.push(readReceiptSyncEngineOnLoginHandler());
+    } else subscriptions.push(legacyReadReceiptSyncEngineOnLoginHandler());
+  }
+
+  return true;
+};
+/* end_public_function */

package/src/client/api/loginAsBot.ts

@@ -0,0 +1,125 @@
+/* eslint-disable no-param-reassign */
+import { modifyMqttConnection } from '~/client/utils/modifyMqttConnection';
+/* eslint-disable require-atomic-updates */
+import { getDeviceId } from '~/core/device';
+import { logout } from './logout';
+
+import { getActiveClient } from './activeClient';
+import { terminateClient } from './terminateClient';
+import { setActiveUser } from './activeUser';
+
+import { onTokenExpired } from '../events/onTokenExpired';
+import { onTokenTerminated } from '../events/onTokenTerminated';
+import { initializeMessagePreviewSetting } from '../utils/messagePreviewEngine';
+
+import SessionWatcher from '../utils/SessionWatcher';
+import { setBotClientToken } from '../utils/setBotClientToken';
+import { setCurrentUser } from '../utils/setCurrentUser';
+
+/*
+ * 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[] = [];
+
+/* begin_public_function
+  id: client.loginAsBot
+*/
+/**
+ * ```js
+ * import { loginAsBot } from '@amityco/ts-sdk/client/api'
+ * const success = await loginAsBot({
+    sessionHandler: {
+      sessionWillRenewAccessToken(renewal: Amity.AccessTokenRenewal) {
+       ...
+    }
+ * })
+ * ```
+ *
+ * Connects an {@link Amity.Client} instance to ASC servers
+ *
+ * @param params. the connect parameters
+ * @param params.sessionHandler
+ * @returns a success boolean if connected
+ *
+ * @category Client API
+ * @async
+ */
+
+export const loginAsBot = async (params: {
+  sessionHandler: Amity.SessionHandler;
+}): Promise<boolean> => {
+  const client = getActiveClient();
+  let unsubWatcher: Amity.Unsubscriber;
+
+  client.log('client/api/connectClient', {
+    apiKey: client.apiKey,
+    sessionState: client.sessionState,
+  });
+
+  // generate deviceId
+  const deviceId = await getDeviceId();
+  let user: Amity.RawUser;
+
+  try {
+    const { users, userType } = await setBotClientToken({
+      params: {
+        deviceId,
+      },
+      options: {
+        setAccessTokenCookie: true,
+      },
+    });
+
+    [user] = users;
+
+    client.userId = user.userId;
+
+    client.sessionHandler = params.sessionHandler;
+
+    /*
+     * Cannot push to subscriptions as watcher needs to continue working even if
+     * token expires
+     */
+    unsubWatcher = client.accessTokenExpiryWatcher(params.sessionHandler);
+
+    setCurrentUser({ user, userType });
+  } 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;
+  }
+
+  await initializeMessagePreviewSetting();
+
+  if (subscriptions.length === 0) {
+    // handling internal SDK events
+    subscriptions.push(
+      onTokenTerminated(_ => {
+        terminateClient();
+
+        subscriptions.forEach(fn => fn());
+
+        unsubWatcher();
+      }),
+
+      onTokenExpired(state => {
+        SessionWatcher.getInstance().setSessionState(state);
+
+        logout();
+
+        subscriptions.forEach(fn => fn());
+      }),
+    );
+  }
+
+  return true;
+};
+
+/* end_public_function */

package/src/client/api/loginAsVisitor.ts

@@ -0,0 +1,129 @@
+/* eslint-disable no-param-reassign */
+import { modifyMqttConnection } from '~/client/utils/modifyMqttConnection';
+/* eslint-disable require-atomic-updates */
+import { getDeviceId } from '~/core/device';
+import { logout } from './logout';
+
+import { getActiveClient } from './activeClient';
+import { terminateClient } from './terminateClient';
+
+import { onTokenExpired } from '../events/onTokenExpired';
+import { onTokenTerminated } from '../events/onTokenTerminated';
+import { initializeMessagePreviewSetting } from '../utils/messagePreviewEngine';
+
+import SessionWatcher from '../utils/SessionWatcher';
+import { setVisitorClientToken } from '../utils/setVisitorClientToken';
+import { setCurrentUser } from '../utils/setCurrentUser';
+
+/*
+ * 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[] = [];
+
+/* begin_public_function
+  id: client.loginAsVisitor
+*/
+/**
+ * ```js
+ * import { loginAsVisitor } from '@amityco/ts-sdk/client/api'
+ * const success = await loginAsVisitor({
+    sessionHandler: {
+      sessionWillRenewAccessToken(renewal: Amity.AccessTokenRenewal) {
+       ...
+    }
+ * })
+ * ```
+ *
+ * Connects an {@link Amity.Client} instance to ASC servers
+ *
+ * @param params. the connect parameters
+ * @param params.authSignature The authenitcation signature - necessary when network option is set to secure
+ * @param params.authSignatureExpiresAt Expire time of the authenitcation signature
+ * @param params.sessionHandler
+ * @returns a success boolean if connected
+ *
+ * @category Client API
+ * @async
+ */
+
+export const loginAsVisitor = async (
+  params: Amity.ConnectClientAsVisitorParams & {
+    sessionHandler: Amity.SessionHandler;
+  },
+): Promise<boolean> => {
+  const client = getActiveClient();
+  let unsubWatcher: Amity.Unsubscriber;
+  client.log('client/api/connectClient', {
+    apiKey: client.apiKey,
+    sessionState: client.sessionState,
+    ...params,
+  });
+
+  // generate deviceId
+  const deviceId = await getDeviceId();
+  let user: Amity.RawUser;
+
+  try {
+    const { users, userType } = await setVisitorClientToken({
+      params: {
+        ...params,
+        deviceId,
+      },
+      options: {
+        setAccessTokenCookie: true,
+      },
+    });
+
+    [user] = users;
+
+    client.userId = user.userId;
+
+    client.sessionHandler = params.sessionHandler;
+
+    /*
+     * Cannot push to subscriptions as watcher needs to continue working even if
+     * token expires
+     */
+    unsubWatcher = client.accessTokenExpiryWatcher(params.sessionHandler);
+
+    setCurrentUser({ user, userType });
+  } 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;
+  }
+
+  await initializeMessagePreviewSetting();
+
+  if (subscriptions.length === 0) {
+    // handling internal SDK events
+    subscriptions.push(
+      onTokenTerminated(_ => {
+        terminateClient();
+
+        subscriptions.forEach(fn => fn());
+
+        unsubWatcher();
+      }),
+
+      onTokenExpired(state => {
+        SessionWatcher.getInstance().setSessionState(state);
+
+        logout();
+
+        subscriptions.forEach(fn => fn());
+      }),
+    );
+  }
+
+  return true;
+};
+
+/* end_public_function */

package/src/client/api/logout.ts

@@ -0,0 +1,71 @@
+import { getActiveClient } from './activeClient';
+import { setSessionState } from './setSessionState';
+
+/* begin_public_function
+  id: client.logout
+*/
+/**
+ * ```js
+ * import { Client } from '@amityco/ts-sdk';
+ * const success = await Client.logout()
+ * ```
+ *
+ * Disconnects an {@link Amity.Client} instance from ASC servers
+ *
+ * @returns a success boolean if disconnected
+ *
+ * @category Client API
+ * @async
+ */
+export const logout = async (): Promise<boolean> => {
+  const client = getActiveClient();
+
+  client.log('client/api/disconnectClient');
+
+  if (client.mqtt && client.mqtt.connected) {
+    client.mqtt.disconnect();
+  }
+
+  /*
+   * 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
+   *
+   * IMPORTANT: call this before `emitter.all.clear()`, otherwise the session
+   * event will never be triggered
+   */
+  if (client.sessionState === Amity.SessionStates.ESTABLISHED)
+    setSessionState(Amity.SessionStates.NOT_LOGGED_IN);
+
+  client.emitter.all.clear();
+
+  client.mqtt?.removeAllListeners();
+  client.userId = undefined;
+  client.token = undefined;
+
+  client.http.defaults.headers.common.Authorization = '';
+  client.http.defaults.metadata = {
+    tokenExpiry: '',
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
+  if (typeof document !== 'undefined') {
+    document.cookie = '_ascSession=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';
+  }
+
+  /*
+   * 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 true;
+};
+/* end_public_function */

package/src/client/api/markerSync.ts

@@ -0,0 +1,61 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { getActiveClient } from './activeClient';
+import { convertChannelMarkerResponse, convertSubChannelMarkerResponse } from '~/utils/marker';
+
+/**
+ * ```js
+ * import { markerSync } from '@amityco/ts-sdk'
+ * const success = await markerSync()
+ * ```
+ *
+ * Make all markers synced
+ * * If response is empty means that the sync has ended.
+ * * If response is not empty, the sync has not ended. You must call markerSync
+ * again to continue syncing.
+ *
+ * @return {hasMore} A success boolean if the marker sync was ended.
+ *
+ * @category Marker API
+ * @async
+ * @private
+ */
+export const markerSync = async (
+  deviceLastSyncAt: string,
+): Promise<{
+  data: Amity.MarkerSyncPayload;
+  hasMore: boolean;
+}> => {
+  const client = getActiveClient();
+  client.log('channel/markerSync');
+
+  const { data: payload } = await client.http.post<Amity.MarkerSyncPayload>(
+    `/api/v1/markers/sync`,
+    { deviceLastSyncAt },
+  );
+
+  const {
+    userEntityMarkers: userEntityMarkersPayload,
+    userFeedMarkers: userFeedMarkersPayload,
+    feedMarkers,
+    userMarkers,
+  } = payload;
+
+  const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+  const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache)
+    ingestInCache({ userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers }, { cachedAt });
+
+  fireEvent('local.feedMarker.fetched', { feedMarkers });
+  fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+  fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+  fireEvent('local.userMarker.fetched', { userMarkers });
+
+  return {
+    data: payload,
+    hasMore: payload.feedMarkers.length > 0,
+  };
+};