@amityco/ts-sdk 7.9.3-8cb8198.0 → 7.9.3-9d4caef6.0

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/renewal.ts

@@ -1,10 +1,12 @@
 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 { 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
@@ -30,7 +32,7 @@ export const renewal = (): Amity.AccessTokenRenewal => {
    * Per instance of Renewal, only one renewal is allowed
    */
   const renewToken = async (authToken?: Amity.ConnectClientParams['authToken']): Promise<void> => {
-    const { userId, displayName } = getActiveUser();
+    const { userId, displayName } = getCurrentUser();
     const deviceId = await getDeviceId();
 
     const params = { userId, displayName, authToken, deviceId };
@@ -53,6 +55,30 @@ export const renewal = (): Amity.AccessTokenRenewal => {
     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) {
@@ -75,6 +101,20 @@ export const renewal = (): Amity.AccessTokenRenewal => {
         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/utils/setBotClientToken.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '../api/activeClient';
+import { setSessionState } from '../api/setSessionState';
+import { getBotToken } from '../api/getBotToken';
+
+/**
+ * A util to set or refresh client token
+ * @param options get bot token options
+ * @param options.setAccessTokenCookie The authentication token - necessary when network option is set to secure
+ * @returns token & user info
+ *
+ * @category private
+ * @async
+ */
+export const setBotClientToken = async (params: Parameters<typeof getBotToken>[0]) => {
+  const client = getActiveClient();
+  // begin establishing session
+  setSessionState(Amity.SessionStates.ESTABLISHING);
+
+  const { accessToken, users, expiresAt, issuedAt, userType } = await getBotToken(params);
+
+  // manually setup the token for http transport
+  client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
+
+  client.http.defaults.metadata = {
+    tokenExpiry: expiresAt,
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
+  client.token = { accessToken, issuedAt, expiresAt };
+
+  setSessionState(Amity.SessionStates.ESTABLISHED);
+
+  return { accessToken, users, userType };
+};

package/src/client/utils/setClientToken.ts

@@ -19,7 +19,7 @@ export const setClientToken = async (params: Parameters<typeof getToken>[0]) =>
   // begin establishing session
   setSessionState(Amity.SessionStates.ESTABLISHING);
 
-  const { accessToken, users, expiresAt, issuedAt } = await getToken(params);
+  const { accessToken, users, expiresAt, issuedAt, userType } = await getToken(params);
 
   // manually setup the token for http transport
   client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
@@ -42,5 +42,5 @@ export const setClientToken = async (params: Parameters<typeof getToken>[0]) =>
 
   setSessionState(Amity.SessionStates.ESTABLISHED);
 
-  return { accessToken, users };
+  return { accessToken, users, userType };
 };

package/src/client/utils/setCurrentUser.ts

@@ -0,0 +1,15 @@
+import { setActiveUser } from '../api/activeUser';
+import { setCurrentUserType } from '../api/getCurrentUserType';
+import { pushToCache } from '~/cache/api/pushToCache';
+
+export const setCurrentUser = ({
+  user,
+  userType,
+}: {
+  user: Amity.RawUser;
+  userType: Amity.UserType;
+}) => {
+  setActiveUser(user);
+  setCurrentUserType(userType);
+  pushToCache(['user', 'get', user.userId], user);
+};

package/src/client/utils/setVisitorClientToken.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '../api/activeClient';
+import { setSessionState } from '../api/setSessionState';
+import { getVisitorToken } from '../api/getVisitorToken';
+
+/**
+ * A util to set or refresh client token
+ *
+ * @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
+ * @param options get bot token options
+ * @param options.setAccessTokenCookie The authentication token - necessary when network option is set to secure
+ * @returns token & user info
+ *
+ * @category private
+ * @async
+ */
+export const setVisitorClientToken = async (params: Parameters<typeof getVisitorToken>[0]) => {
+  const client = getActiveClient();
+  // begin establishing session
+  setSessionState(Amity.SessionStates.ESTABLISHING);
+
+  const { accessToken, users, expiresAt, issuedAt, userType } = await getVisitorToken(params);
+
+  // manually setup the token for http transport
+  client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
+
+  client.http.defaults.metadata = {
+    tokenExpiry: expiresAt,
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
+  client.token = { accessToken, issuedAt, expiresAt };
+
+  setSessionState(Amity.SessionStates.ESTABLISHED);
+
+  return { accessToken, users, userType };
+};

package/src/core/transports/http.ts

@@ -104,6 +104,7 @@ export const createHttpTransport = (endpoint: string) => {
 
   instance.interceptors.request.use(config => {
     // do not check expiration for token creation url
+
     if (config.url === '/api/v5/sessions') {
       return config;
     }
@@ -123,10 +124,10 @@ export const createHttpTransport = (endpoint: string) => {
       }
 
       if (tokenExpiry) {
-        if (Date.now() >= Date.parse(tokenExpiry)) {
-          controller.abort(RequestCancelation.UserDeleted);
-          handleRequestCancelation(RequestCancelation.TokenExpired);
-        }
+        // if (Date.now() >= Date.parse(tokenExpiry)) {
+        //   controller.abort(RequestCancelation.UserDeleted);
+        //   handleRequestCancelation(RequestCancelation.TokenExpired);
+        // }
       }
     }
 

package/src/utils/linkedObject/channelLinkedObject.ts

@@ -3,6 +3,7 @@ import { shallowClone } from '../shallowClone';
 import { queryCache } from '~/cache/api';
 import { channelMemberLinkedObject } from './channelMemberLinkedObject';
 import { getMyMembership } from '~/channelRepository/observers/getMyMembership';
+import { getMembership } from '~/channelRepository/observers/getMembership';
 
 export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Channel => {
   let previewMembers: Amity.Membership<'channel'>[] = [];
@@ -28,5 +29,15 @@ export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Chann
     previewMembers,
     myMembership: (callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | undefined>) =>
       getMyMembership(channel.channelId, callback),
+    getMembership: (
+      userId: Amity.User['userId'],
+      callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | undefined>,
+    ) => {
+      getMembership({
+        channelId: channel.channelId,
+        userId,
+        callback,
+      });
+    },
   });
 };