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

package/dist/stream/api/tests/createStream.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createStream.test.d.ts.map

package/dist/stream/api/tests/createStream.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStream.test.d.ts","sourceRoot":"","sources":["../../../../src/stream/api/tests/createStream.test.ts"],"names":[],"mappings":""}

package/dist/stream/api/tests/deleteStream.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deleteStream.test.d.ts.map

package/dist/stream/api/tests/deleteStream.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteStream.test.d.ts","sourceRoot":"","sources":["../../../../src/stream/api/tests/deleteStream.test.ts"],"names":[],"mappings":""}

package/dist/stream/api/tests/getStream.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getStream.test.d.ts.map

package/dist/stream/api/tests/getStream.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStream.test.d.ts","sourceRoot":"","sources":["../../../../src/stream/api/tests/getStream.test.ts"],"names":[],"mappings":""}

package/dist/subChannel/api/tests/createSubChannel.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createSubChannel.test.d.ts.map

package/dist/subChannel/api/tests/createSubChannel.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSubChannel.test.d.ts","sourceRoot":"","sources":["../../../../src/subChannel/api/tests/createSubChannel.test.ts"],"names":[],"mappings":""}

package/dist/utils/constants.d.ts

@@ -4,4 +4,6 @@ export declare const ENABLE_CACHE_MESSAGE = "For using Live Collection feature y
 export declare const LIVE_OBJECT_ENABLE_CACHE_MESSAGE = "For using Live Object feature you need to enable Cache!";
 export declare const UNSYNCED_OBJECT_CACHED_AT_MESSAGE = "Observing unsynced object is not supported by Live Object.";
 export declare const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;
+export declare const MINUTE: number;
+export declare const ACCESS_TOKEN_WATCHER_INTERVAL: number;
 //# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mCAAmC,IAAI,CAAC;AACrD,eAAO,MAAM,iCAAiC,EAAE,KAAK,CAAC,WAAiC,CAAC;AACxF,eAAO,MAAM,oBAAoB,gEAAgE,CAAC;AAClG,eAAO,MAAM,gCAAgC,4DACc,CAAC;AAC5D,eAAO,MAAM,iCAAiC,+DACgB,CAAC;AAC/D,eAAO,MAAM,+BAA+B,KAAK,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mCAAmC,IAAI,CAAC;AACrD,eAAO,MAAM,iCAAiC,EAAE,KAAK,CAAC,WAAiC,CAAC;AACxF,eAAO,MAAM,oBAAoB,gEAAgE,CAAC;AAClG,eAAO,MAAM,gCAAgC,4DACc,CAAC;AAC5D,eAAO,MAAM,iCAAiC,+DACgB,CAAC;AAC/D,eAAO,MAAM,+BAA+B,KAAK,CAAC;AAClD,eAAO,MAAM,MAAM,QAAY,CAAC;AAChC,eAAO,MAAM,6BAA6B,QAAc,CAAC"}

package/dist/utils/tests/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/utils/tests/client.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,MAAM,cAA4B,CAAC;AAEhD,eAAO,MAAM,aAAa,qBAgBzB,CAAC;AAEF,eAAO,MAAM,gBAAgB,qBAE5B,CAAC;;AAEF,wBAAkB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/utils/tests/client.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,MAAM,cAA4B,CAAC;AAKhD,eAAO,MAAM,aAAa,qBAuBzB,CAAC;AAEF,eAAO,MAAM,gBAAgB,qBAE5B,CAAC;;AAEF,wBAAkB"}

package/dist/utils/tests/dummy/index.d.ts

@@ -13,6 +13,8 @@ export * from './reaction';
 export * from './channel';
 export * from './subChannel';
 export * from './message';
+export * from './token';
 export * from './member';
 export * from './community';
+export * from './stream';
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/tests/dummy/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,QAA2B,CAAC;AAC7C,eAAO,MAAM,mBAAmB;;;CAAiC,CAAC;AAElE,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AAEvB,cAAc,QAAQ,CAAC;AAEvB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAE3B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAE7B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,QAA2B,CAAC;AAC7C,eAAO,MAAM,mBAAmB;;;CAAiC,CAAC;AAElE,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AAEvB,cAAc,QAAQ,CAAC;AAEvB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAE3B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAE7B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAE5B,cAAc,UAAU,CAAC"}

package/dist/utils/tests/dummy/stream.d.ts

@@ -0,0 +1,83 @@
+export declare const streamResponse: {
+    data: {
+        videoStreamings: {
+            streamId: string;
+            userId: string;
+            thumbnailFileId: string;
+            title: string;
+            status: string;
+            isLive: boolean;
+            isDeleted: boolean;
+            description: string;
+            platform: {
+                name: string;
+                version: string;
+            };
+            startedAt: string;
+            endedAt: string;
+            createdAt: string;
+            updatedAt: string;
+            metadata: {};
+            resolution: string;
+            streamerUrl: {
+                url: string;
+                components: {
+                    origin: string;
+                    appName: string;
+                    streamName: string;
+                    query: string;
+                };
+            };
+            recordings: {
+                flv: {
+                    url: string;
+                    duration: number;
+                    startTime: number;
+                    stopTime: number;
+                };
+                mp4: {
+                    url: string;
+                    duration: number;
+                    startTime: number;
+                    stopTime: number;
+                };
+                m3u8: {
+                    url: string;
+                    duration: number;
+                    startTime: number;
+                    stopTime: number;
+                };
+            }[];
+            watcherUrl: {
+                flv: {
+                    url: string;
+                    components: {
+                        origin: string;
+                        appName: string;
+                        streamName: string;
+                        query: string;
+                    };
+                };
+                hls: {
+                    url: string;
+                    components: {
+                        origin: string;
+                        appName: string;
+                        streamName: string;
+                        query: string;
+                    };
+                };
+                rtmp: {
+                    url: string;
+                    components: {
+                        origin: string;
+                        appName: string;
+                        streamName: string;
+                        query: string;
+                    };
+                };
+            };
+        }[];
+    };
+};
+//# sourceMappingURL=stream.d.ts.map

package/dist/utils/tests/dummy/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/stream.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqF1B,CAAC"}

package/dist/utils/tests/dummy/subChannel.d.ts

@@ -1,3 +1,23 @@
 export declare function generateRawSubChannel(params?: Partial<Amity.RawSubChannel>): Amity.RawSubChannel;
 export declare function generateSubChannel(params?: Record<string, any>): Amity.SubChannel;
+export declare const createSubChannelError400400: {
+    status: string;
+    message: string;
+    code: number;
+    data: {
+        detail: {
+            channelId: string;
+        };
+    };
+};
+export declare const createSubChannelError400301: {
+    status: string;
+    message: string;
+    code: number;
+    data: {
+        detail: {
+            channelId: string;
+        };
+    };
+};
 //# sourceMappingURL=subChannel.d.ts.map

package/dist/utils/tests/dummy/subChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subChannel.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/subChannel.ts"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,KAAK,CAAC,aAAa,CAkBhG;AAED,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC,UAAU,CAKjF"}
+{"version":3,"file":"subChannel.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/subChannel.ts"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,KAAK,CAAC,aAAa,CAkBhG;AAED,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC,UAAU,CAKjF;AAED,eAAO,MAAM,2BAA2B;;;;;;;;;CASvC,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;CASvC,CAAC"}

package/dist/utils/tests/dummy/token.d.ts

@@ -0,0 +1,11 @@
+export declare const sessionResponse: {
+    data: {
+        accessToken: string;
+        refreshToken: string;
+        issuedAt: Date;
+        expiresAt: Date;
+        users: Amity.User[];
+        files: never[];
+    };
+};
+//# sourceMappingURL=token.d.ts.map

package/dist/utils/tests/dummy/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/token.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;;;;;;;CAS3B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "0.0.1-beta.36",
+  "version": "0.0.1-beta.37",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/@types/core/errors.ts

@@ -31,6 +31,7 @@ declare global {
       QUERY_IN_PROGRESS = 800170,
       CONNECTION_ERROR = 800210,
       DISCONNECTED = 800211,
+      TOKEN_EXPIRED = 800403,
       DISALOOW_UNSYNCED_OBJECT = 800800,
     }
 

package/src/@types/core/events.ts

@@ -39,6 +39,7 @@ declare global {
       close: Error;
       end: undefined;
       reconnect: undefined;
+      'user.didGlobalBan': Amity.UserPayload;
     };
 
     type MqttChannelUserEvents = {
@@ -149,6 +150,11 @@ declare global {
       'local.message-feed.deleted': Amity.SubChannelPayload;
       'poll.updated': Amity.PollPayload;
       'poll.deleted': Amity.PollPayload;
+
+      sessionStateChange: Amity.SessionStates;
+      // used by accessTokenExpiryWatcher
+      tokenExpired: Amity.SessionStates.TOKEN_EXPIRED;
+      tokenTerminated: Amity.SessionStates.TERMINATED;
     };
 
     type Events = WsEvents & MqttEvents & MqttRTE & LocalEvents;

package/src/@types/domains/client.ts

@@ -5,6 +5,27 @@ declare global {
   namespace Amity {
     type Logger = (topic: string, ...args: any[]) => void;
 
+    const enum SessionStates {
+      NOT_LOGGED_IN = 'notLoggedIn',
+
+      ESTABLISHING = 'establishing',
+      ESTABLISHED = 'established',
+
+      TOKEN_EXPIRED = 'tokenExpired',
+
+      /*
+       * Terminated is slightly different from NOT_LOGGED_IN:
+       *
+       * After established, upon receiving the termination code, the SDK will move to terminated.
+       * Unlike tokenExpired that users can regain SDK usability by giving an auth token.
+       * This state represents unrecoverable failures. The app must manually re-login with a valid user.
+       *
+       * For more details, please check tech spec:
+       * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#terminated
+       */
+      TERMINATED = 'terminated',
+    }
+
     type Client = {
       version: string;
 
@@ -14,14 +35,24 @@ declare global {
       ws: SocketIOClient.Socket;
       emitter: Emitter<Amity.Events>;
 
+      sessionState: Amity.SessionStates;
+      sessionHandler?: Amity.SessionHandler;
+
       cache?: Amity.Cache;
 
       apiKey?: string;
       userId?: string;
-      accessToken?: string;
+
+      token?: Omit<Amity.Tokens, 'refreshToken'>;
 
       use: () => void;
 
+      accessTokenExpiryWatcher: (
+        expiresAt: Amity.Tokens['expiresAt'],
+        issuedAt: Amity.Tokens['issuedAt'],
+        sessionHandler: Amity.SessionHandler,
+      ) => Amity.Unsubscriber;
+
       getFeedSettings: () => Promise<Amity.FeedSettings>;
     };
 
@@ -37,8 +68,21 @@ declare global {
     type Tokens = {
       accessToken: string;
       refreshToken: string;
+      // issuedAt, expiresAt is in iso Date format
+      issuedAt: string;
+      expiresAt: string;
     };
 
+    type AccessTokenRenewal = {
+      renew: () => void;
+      renewWithAuthToken: (authToken: string) => void;
+      unableToRetrieveAuthToken: () => void;
+    };
+
+    interface SessionHandler {
+      sessionWillRenewAccessToken(renewal: AccessTokenRenewal): void;
+    }
+
     type ChatSettings = {
       enabled: boolean;
       mention: {

package/src/@types/global.ts

@@ -28,3 +28,17 @@ declare global {
 
   type ValueOf<T extends Record<any, any>> = T[keyof T];
 }
+
+/*
+ * Extented to pass token expiry into request config, for internal use only.
+ * Since it's in the request config, it does not get sent for the server, and
+ * allows us to intercept the tokenExpiry value to check if the token has not
+ * expired & cancel the request if yes.
+ *
+ */
+declare module 'axios' {
+  export interface AxiosRequestConfig {
+    // expires at iso string for access token
+    metadata?: { tokenExpiry: string };
+  }
+}

package/src/client/api/accessTokenExpiryWatcher.ts

@@ -0,0 +1,83 @@
+import { fireEvent } from '~/core/events';
+import { scheduleTask } from '~/core/microtasks';
+import { MINUTE, ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
+
+import { renewal } from './renewal';
+
+const ABOUT_TO_EXPIRE_THRESHOLD = 80 / 100;
+const COMPENSATED_DELAY = 5 * MINUTE;
+
+/*
+ * a helper function to check if the token has expires
+ *
+ * @param token to be checked
+ * @returns boolean indicating if token expires
+ *
+ * @category private
+ */
+export const isExpired = (expiresAt: Amity.Tokens['expiresAt']): boolean =>
+  Date.now() > Date.parse(expiresAt) - COMPENSATED_DELAY;
+
+/*
+ * a helper function to check if the token is about to expire
+ *
+ * @param token to be checked
+ * @returns boolean indicating if token is aboutToExpire
+ *
+ * @category private
+ */
+export const isAboutToExpire = (
+  expiresAt: Amity.Tokens['expiresAt'],
+  issuedAt: Amity.Tokens['issuedAt'],
+): boolean => {
+  const expires = Date.parse(expiresAt);
+  const issued = Date.parse(issuedAt);
+  const now = Date.now();
+
+  const duration = expires - issued - COMPENSATED_DELAY;
+  const aboutToExpireAt = issued + duration * ABOUT_TO_EXPIRE_THRESHOLD;
+
+  return now > aboutToExpireAt && now < expires;
+};
+
+/*
+ * Monitors time to expire of token and updates session state to aboutToExpire
+ *
+ * @returns intervalId to be cleared after trigger
+ *
+ * @category private
+ */
+export const accessTokenExpiryWatcher = (
+  expiresAt: Amity.Tokens['expiresAt'],
+  issuedAt: Amity.Tokens['issuedAt'],
+  sessionHandler: Amity.SessionHandler,
+): Amity.Unsubscriber => {
+  const interval: ReturnType<typeof setInterval> = setInterval(() => {
+    if (isExpired(expiresAt)) {
+      /*
+       * the event handler will take care of updating session state
+       * Note, this will also clear the interval id, so this event will only be
+       * fired once
+       */
+      fireEvent('tokenExpired', Amity.SessionStates.TOKEN_EXPIRED);
+
+      /*
+       * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Automatically-initiate-renewal-flow
+       *
+       * Why sechduled task?
+       * Since fireEvent is scheduled, it will be called
+       * after sessionHandler leading to an invalid state change from
+       * establishing to tokenExpired
+       */
+      scheduleTask(() => sessionHandler.sessionWillRenewAccessToken(renewal()));
+
+      return;
+    }
+
+    if (isAboutToExpire(issuedAt, expiresAt)) {
+      sessionHandler.sessionWillRenewAccessToken(renewal());
+    }
+  }, ACCESS_TOKEN_WATCHER_INTERVAL);
+
+  return (): void => clearInterval(interval);
+};

package/src/client/api/activeUser.ts

@@ -1,6 +1,6 @@
 import { ASCError } from '~/core/errors';
 
-let activeUser: Pick<Amity.User, '_id' | 'userId' | 'path'> | null = null;
+let activeUser: Pick<Amity.User, '_id' | 'userId' | 'path' | 'displayName'> | null = null;
 
 /**
  * for internal use

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,
   };