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

package/dist/index.cjs.js

@@ -1140,6 +1140,9 @@ const WS_EVENTS = [
     'connect_error',
     'reconnect_error',
     'reconnect_failed',
+    'sessionStateChange',
+    // for internal use by accessTokenExpiryWatcher
+    'tokenExpired',
 ];
 const MQTT_EVENTS = [
     'connect',
@@ -1149,6 +1152,7 @@ const MQTT_EVENTS = [
     'close',
     'end',
     'reconnect',
+    'user.didGlobalBan',
 ];
 /** @hidden */
 const createEventEmitter = () => {
@@ -1167,7 +1171,6 @@ const createEventEmitter = () => {
 const proxyWebsocketEvents = (ws, emitter) => {
     WS_EVENTS.forEach(event => {
         ws.on(event, (param) => {
-            console.log('ws', event, param);
             emitter.emit(event, param);
         });
     });
@@ -1175,14 +1178,12 @@ const proxyWebsocketEvents = (ws, emitter) => {
 const proxyMqttEvents = (mqttClient, emitter) => {
     MQTT_EVENTS.forEach(event => {
         mqttClient.on(event, (...params) => {
-            console.log('mqtt', event, params);
             emitter.emit(event, params.length === 1 ? params[0] : params);
         });
     });
     // @ts-ignore
     mqttClient.on('message', (topic, payload) => {
         const message = JSON.parse(payload.toString());
-        console.log('mqtt message', message);
         emitter.emit(message.eventType, message.data);
     });
 };
@@ -1325,7 +1326,9 @@ const getSmartFeedMessageTopic = () => {
 let mqttAccessToken;
 let mqttUserId;
 function subscribeTopic(topic, callback) {
-    const { mqtt, emitter, accessToken } = getActiveClient();
+    var _a;
+    const { mqtt, emitter, token } = getActiveClient();
+    const accessToken = (_a = token === null || token === void 0 ? void 0 : token.accessToken) !== null && _a !== void 0 ? _a : '';
     const user = getActiveUser();
     if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
         mqttAccessToken = accessToken;
@@ -1423,12 +1426,32 @@ const createHttpTransport = (endpoint) => {
         httpsAgent: new HttpAgent.HttpsAgent(options),
         paramsSerializer: stringify,
     });
+    instance.interceptors.request.use(config => {
+        var _a;
+        // check global.ts for the extension of AxiosRequestConfig
+        const tokenExpiry = (_a = config.metadata) === null || _a === void 0 ? void 0 : _a.tokenExpiry;
+        if (tokenExpiry) {
+            if (Date.now() >= Date.parse(tokenExpiry)) {
+                return Object.assign(Object.assign({}, config), { cancelToken: new axios__default["default"].CancelToken(cancel => cancel('Token Expired')) });
+            }
+        }
+        return config;
+    });
     instance.interceptors.response.use(response => response, error => {
         var _a;
         const { response } = error;
         // eslint-disable-next-line no-console
         console.error((_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : error);
-        if (response)
+        // handle unauthorized request
+        if (response.data.code === 400100 /* Amity.ServerError.UNAUTHORIZED */) {
+            fireEvent('tokenTerminated', "terminated" /* Amity.SessionStates.TERMINATED */);
+        }
+        // handle request cancellation
+        if (axios__default["default"].isCancel(error)) {
+            fireEvent('tokenExpired', "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */);
+            throw new ASCError('Token expired', 800403 /* Amity.ClientError.TOKEN_EXPIRED */, "fatal" /* Amity.ErrorLevel.FATAL */);
+        }
+        if (response === null || response === void 0 ? void 0 : response.data)
             unwrapPayload(response.data);
     });
     return instance;
@@ -20163,7 +20186,7 @@ var MqttError;
     MqttError[MqttError["NOT_AUTHORIZED"] = 5] = "NOT_AUTHORIZED";
 })(MqttError || (MqttError = {}));
 function getMqttOptions(params) {
-    return Object.assign({ clean: false, clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`, protocolId: 'MQTT', protocolVersion: 4, reconnectPeriod: 0, will: {
+    return Object.assign({ clean: false, clientId: `mqttjs_ + ${Math.random().toString(16).substring(2, 10)}`, protocolId: 'MQTT', protocolVersion: 4, reconnectPeriod: 0, will: {
             topic: 'WillMsg',
             payload: 'Connection Closed abnormally..!',
             qos: 0,
@@ -20294,54 +20317,153 @@ const getFeedSettings = async () => {
     }));
 };
 
-const DEFAULT_DEBUG_SESSION = 'amity';
+const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+const COLLECTION_DEFAULT_CACHING_POLICY = 'cache_then_server';
+const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';
+const LIVE_OBJECT_ENABLE_CACHE_MESSAGE = 'For using Live Object feature you need to enable Cache!';
+const UNSYNCED_OBJECT_CACHED_AT_MESSAGE = 'Observing unsynced object is not supported by Live Object.';
+const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;
+const MINUTE = 60 * 1000;
+const ACCESS_TOKEN_WATCHER_INTERVAL = 10 * MINUTE;
+
+// TODO: find a way to uniquely identify the device
+/** @hidden */
+const VERSION = '11.0.0';
+/** @hidden */
+const getDeviceId = () => {
+    // here maybe put some auto detection of the device id based on if it's react or not?
+    // anyhow we let consumer branch out if they want, but it doesn't mean we shouldn't try to be nice
+    // and do things automatically
+    // https://www.npmjs.com/package/react-native-device-info#getuniqueid
+    // how to make sure that the react native package will not be included when build is for web
+    return `ascWebSdk#${Math.random().toString(16)}`;
+};
+/** @hidden */
+const getDeviceModel = () => {
+    var _a, _b;
+    if ((_a = safeProcess.versions) === null || _a === void 0 ? void 0 : _a.node)
+        return safeProcess.versions.node;
+    if (navigator)
+        return `${navigator.product.toLowerCase()}#${(_b = navigator.userAgent) !== null && _b !== void 0 ? _b : 'unknown_agent'}`;
+    return 'unknown_model';
+};
+/** @hidden */
+const getDeviceInfo = () => {
+    const model = getDeviceModel();
+    return {
+        version: VERSION,
+        // TODO: replace with: kind: process.versions ? 'node' : 'web', when backend has fixed this
+        kind: 'web',
+        model,
+    };
+};
+
+/*
+ * Session States cannot be set arbitarily.
+ * 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 sessisonStateTransitions = {
+    // notLoggedIn -> establishing
+    ["notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */]: ["establishing" /* Amity.SessionStates.ESTABLISHING */],
+    // terminated -> establishing
+    ["terminated" /* Amity.SessionStates.TERMINATED */]: ["establishing" /* Amity.SessionStates.ESTABLISHING */],
+    // establishing -> notLoggedIn, established
+    ["establishing" /* Amity.SessionStates.ESTABLISHING */]: [
+        "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */,
+        "established" /* Amity.SessionStates.ESTABLISHED */,
+    ],
+    /*
+     * established -> notLoggedIn, terminated, tokenExpired, establishing (for
+     * cases when logging in same user)
+     */
+    ["established" /* Amity.SessionStates.ESTABLISHED */]: [
+        "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */,
+        "terminated" /* Amity.SessionStates.TERMINATED */,
+        "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */,
+        "establishing" /* Amity.SessionStates.ESTABLISHING */,
+    ],
+    // tokenExpired -> establishing
+    ["tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */]: ["establishing" /* Amity.SessionStates.ESTABLISHING */],
+};
+const isValidStateChange = (prevState, nextState) => {
+    return sessisonStateTransitions[prevState].includes(nextState);
+};
 /**
- * ```js
- * import { createClient } from '@amityco/ts-sdk'
- * const client = createClient(apiKey, 'https://asc.server/', 'myClient')
- * ```
+ * Checks if a {@link Amity.Client} instance is connected to ASC servers
  *
- * Creates a new {@link Amity.Client} instance
  *
- * @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
- * @returns A {@link Amity.Client} instance
+ * @param state the new session state
+ * @returns a success boolean if connected
+ *
+ * @category private
+ */
+const setSessionState = (state) => {
+    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}`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+    client.sessionState = state;
+    fireEvent('sessionStateChange', state);
+    return true;
+};
+
+/**
+ * Retrieves a pair of {@link Amity.Tokens} necessary for connection
+ *
+ * @param params.userId The userId to use to issue a token
+ * @param params.displayName The user's displayName
+ * @param params.deviceId The user's device Id (can be manually set for native users)
+ * @param params.authToken The authentication token - necessary when network option is set to secure
+ * @return The accessToken for the given userId
  *
  * @category Client API
- * */
-const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAULT_DEBUG_SESSION, apiEndpoint, } = {}) => {
-    var _a, _b;
-    const log = createLogger(debugSession);
-    log('client/api/createClient', {
-        apiKey: apiKey.replace(/.{5}$/g, 'xxxxx'),
-        apiRegion,
+ * @hidden
+ */
+const getToken = async (params) => {
+    const client = getActiveClient();
+    client.log('client/api/getToken', params);
+    const deviceInfo = getDeviceInfo();
+    const { data } = await client.http.post('/api/v3/sessions', Object.assign(Object.assign({}, params), { deviceInfo }), {
+        // @ts-ignore
+        headers: { 'X-API-Key': client.apiKey },
     });
-    const httpEndpoint = (_a = apiEndpoint === null || apiEndpoint === void 0 ? void 0 : apiEndpoint.http) !== null && _a !== void 0 ? _a : computeUrl('http', apiRegion);
-    const mqttEndpoint = (_b = apiEndpoint === null || apiEndpoint === void 0 ? void 0 : apiEndpoint.mqtt) !== null && _b !== void 0 ? _b : computeUrl('mqtt', apiRegion);
-    const http = createHttpTransport(httpEndpoint);
-    const ws = createWebsocketTransport(httpEndpoint);
-    const mqtt = createMqttTransport(mqttEndpoint);
-    const emitter = createEventEmitter();
-    const client = {
-        version: `${VERSION$1}`,
-        apiKey,
-        log,
-        http,
-        ws,
-        mqtt,
-        emitter,
-        use: () => setActiveClient(client),
-        getFeedSettings,
-    };
-    try {
-        return getActiveClient();
-    }
-    catch (_c) {
-        setActiveClient(client);
-    }
-    return client;
+    return data;
+};
+
+/**
+ * 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
+ * @returns token & user info
+ *
+ * @category private
+ * @async
+ */
+const setClientToken = async (params) => {
+    const client = getActiveClient();
+    // begin establishing session
+    setSessionState("establishing" /* Amity.SessionStates.ESTABLISHING */);
+    // @ts-ignore: in that particular case, typing can be
+    // ignored since we enforce default values just before.
+    const { accessToken, users, expiresAt, issuedAt, refreshToken } = await getToken(params);
+    // manually setup the token for http transport
+    client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
+    client.http.defaults.metadata = { tokenExpiry: expiresAt };
+    // manually setup the token for ws transport
+    client.ws.io.opts.query = { token: accessToken };
+    client.token = { accessToken, issuedAt, expiresAt };
+    setSessionState("established" /* Amity.SessionStates.ESTABLISHED */);
+    return { accessToken, users, refreshToken };
 };
 
 /**
@@ -20352,7 +20474,6 @@ const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAU
  *
  * Disconnects an {@link Amity.Client} instance from ASC servers
  *
- * @param client The {@link Amity.Client} instance to disconnect
  * @returns a success boolean if disconnected
  *
  * @category Client API
@@ -20371,42 +20492,30 @@ const disconnectClient = async () => {
     client.ws.removeAllListeners();
     client.mqtt.removeAllListeners();
     client.userId = undefined;
-    client.accessToken = undefined;
+    client.token = undefined;
+    client.http.defaults.headers.common.Authorization = '';
+    client.ws.io.opts.query = { token: '' };
+    /*
+     * 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
+     */
+    if (client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */)
+        setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
+    /*
+     * 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 !== "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */ && client.cache) {
+        client.cache = { data: {} };
+    }
     return !client.ws.connected;
 };
 
-// TODO: find a way to uniquely identify the device
-/** @hidden */
-const VERSION = '11.0.0';
-/** @hidden */
-const getDeviceId = () => {
-    // here maybe put some auto detection of the device id based on if it's react or not?
-    // anyhow we let consumer branch out if they want, but it doesn't mean we shouldn't try to be nice
-    // and do things automatically
-    // https://www.npmjs.com/package/react-native-device-info#getuniqueid
-    // how to make sure that the react native package will not be included when build is for web
-    return `ascWebSdk#${Math.random().toString(16)}`;
-};
-/** @hidden */
-const getDeviceModel = () => {
-    var _a, _b;
-    if ((_a = safeProcess.versions) === null || _a === void 0 ? void 0 : _a.node)
-        return safeProcess.versions.node;
-    if (navigator)
-        return `${navigator.product.toLowerCase()}#${(_b = navigator.userAgent) !== null && _b !== void 0 ? _b : 'unknown_agent'}`;
-    return 'unknown_model';
-};
-/** @hidden */
-const getDeviceInfo = () => {
-    const model = getDeviceModel();
-    return {
-        version: VERSION,
-        // TODO: replace with: kind: process.versions ? 'node' : 'web', when backend has fixed this
-        kind: 'web',
-        model,
-    };
-};
-
 /**
  * Ingest a payload (v3) into the cache
  *
@@ -20458,26 +20567,17 @@ const createUserEventSubscriber = (event, callback) => {
 const onUserDeleted = (callback) => createUserEventSubscriber('user.deleted', callback);
 
 /**
- * Retrieves a pair of {@link Amity.Tokens} necessary for connection
+ * Terminates {@link Amity.Client} instance
  *
- * @param userId The userId to use to issue a token
- * @param displayName The user's displayName
- * @param deviceId The user's device Id (can be manually set for native users)
- * @param authToken The authentication token - necessary when network option is set to secure
- * @return The accessToken for the given userId
  *
- * @category Client API
- * @hidden
+ *
+ * @category private
  */
-const getToken = async (params) => {
+const terminateClient = () => {
     const client = getActiveClient();
-    client.log('client/api/getToken', params);
-    const deviceInfo = await getDeviceInfo();
-    const { data } = await client.http.post('/v1/device', Object.assign(Object.assign({}, params), { deviceInfo }), {
-        // @ts-ignore
-        headers: { 'X-API-Key': client.apiKey },
-    });
-    return data;
+    setSessionState("terminated" /* Amity.SessionStates.TERMINATED */);
+    client.sessionHandler = undefined;
+    disconnectClient();
 };
 
 const EVENTS = [
@@ -20552,12 +20652,71 @@ const onClientDisconnected = (callback) => {
  * @category Client Events
  */
 const onClientBanned = (callback) => {
-    return onConnectionError(({ code }) => {
-        code === 400312 /* Amity.ServerError.GLOBAL_BAN */ && callback();
-    });
+    const client = getActiveClient();
+    return createEventSubscriber(client, `client/onConnectionError(user.didGlobalBan)`, 'user.didGlobalBan', callback);
+};
+
+/**
+ * ```js
+ * import { onSessionStateChange } from '@amityco/ts-sdk'
+ * const dispose = onSessionStateChange((state: Amity.SessionStates) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} has a session state change
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+const onSessionStateChange = (callback) => {
+    const client = getActiveClient();
+    return createEventSubscriber(client, `client/onSessionStateChange`, 'sessionStateChange', callback);
+};
+
+/**
+ * ```js
+ * import { onTokenExpired } from '@amityco/ts-sdk'
+ * const dispose = onTokenExpired((state: Amity.SessionStates.TOKEN_EXPIRED) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} session state has expired
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category private
+ */
+const onTokenExpired = (callback) => {
+    const client = getActiveClient();
+    return createEventSubscriber(client, `client/onTokenExpired`, 'tokenExpired', callback);
+};
+
+/**
+ *
+ * Fired when any {@link Amity.Client} session state has terminated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category private
+ */
+const onTokenTerminated = (callback) => {
+    const client = getActiveClient();
+    return createEventSubscriber(client, `client/onTokenTerminated`, 'tokenTerminated', callback);
 };
 
 /* eslint-disable no-param-reassign */
+/*
+ * 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 = [];
 /**
  * ```js
  * import { connectClient } from '@amityco/ts-sdk/client/api'
@@ -20578,46 +20737,258 @@ const onClientBanned = (callback) => {
  * @category Client API
  * @async
  */
-const connectClient = async (params, config) => {
-    var _a;
+const connectClient = async (params, sessionHandler, config) => {
+    var _a, _b, _c;
     const client = getActiveClient();
-    client.log('client/api/connectClient', Object.assign({ apiKey: client.apiKey }, params));
+    let unsubWatcher;
+    client.log('client/api/connectClient', Object.assign({ 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
     (_a = params.deviceId) !== null && _a !== void 0 ? _a : (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);
-    // 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);
-    // 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.accessToken = accessToken;
-    setActiveUser(users[0]);
+    try {
+        // @ts-ignore: in that particular case, typing can be
+        // ignored since we enforce default values just before.
+        const { users } = await setClientToken(params);
+        // 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();
+        });
+        client.userId = params.userId;
+        client.sessionHandler = sessionHandler;
+        /*
+         * Cannot push to subscriptions as watcher needs to continue working even if
+         * token expires
+         */
+        unsubWatcher = client.accessTokenExpiryWatcher((_b = client.token) === null || _b === void 0 ? void 0 : _b.issuedAt, (_c = client.token) === null || _c === void 0 ? void 0 : _c.expiresAt, sessionHandler);
+        setActiveUser(users[0]);
+    }
+    catch (error) {
+        /*
+         * if getting token failed session state reverts to initial state when app
+         * is first launched
+         */
+        setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
+        // pass error down tree so the calling function handle it
+        throw error;
+    }
     if ((config === null || config === void 0 ? void 0 : 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(() => {
-            disconnectClient();
+    subscriptions.push(
+    // GLOBAL_BAN
+    onClientBanned((_) => {
+        terminateClient();
+        subscriptions.forEach(fn => fn());
+        unsubWatcher();
+    }), onTokenTerminated(_ => {
+        terminateClient();
+        subscriptions.forEach(fn => fn());
+        unsubWatcher();
+    }), onUserDeleted((user) => {
+        if (user.userId === client.userId) {
+            terminateClient();
             subscriptions.forEach(fn => fn());
-        }),
-        onUserDeleted(() => null),
-    ];
+            unsubWatcher();
+        }
+    }), onTokenExpired(state => {
+        setSessionState(state);
+        disconnectClient();
+        subscriptions.forEach(fn => fn());
+    }), onUserDeleted(() => null));
     return client.ws.connected;
 };
 
+/*
+ * 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
+ */
+const renewal = () => {
+    let tokenRenewed = false;
+    let renewTimeoutId;
+    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) => {
+        const { userId, displayName } = getActiveUser();
+        const deviceId = getDeviceId();
+        const params = { userId, displayName, authToken, deviceId };
+        if (client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
+            // sessionHandler will never be empty when renewal is instantiatied
+            await connectClient(params, client.sessionHandler);
+        }
+        else {
+            // about to expire
+            // @ts-ignore: in that particular case, typing can be
+            // ignored since we enforce default values just before.
+            await setClientToken(params);
+        }
+        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) => {
+            if (tokenRenewed) {
+                console.log("'renewWithAuthToken' method can be called only once per renewal instance");
+                return;
+            }
+            renewToken(authToken);
+        },
+        unableToRetrieveAuthToken: () => {
+            renewTimeoutId = setTimeout(() => {
+                var _a;
+                (_a = client.sessionHandler) === null || _a === void 0 ? void 0 : _a.sessionWillRenewAccessToken(renewal());
+            }, ACCESS_TOKEN_WATCHER_INTERVAL);
+        },
+    };
+};
+
+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
+ */
+const isExpired = (expiresAt) => 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
+ */
+const isAboutToExpire = (expiresAt, issuedAt) => {
+    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
+ */
+const accessTokenExpiryWatcher = (expiresAt, issuedAt, sessionHandler) => {
+    const interval = 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', "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 () => clearInterval(interval);
+};
+
+const DEFAULT_DEBUG_SESSION = 'amity';
+/**
+ * ```js
+ * import { createClient } from '@amityco/ts-sdk'
+ * const client = createClient(apiKey, 'https://asc.server/', 'myClient')
+ * ```
+ *
+ * Creates a new {@link Amity.Client} instance
+ *
+ * @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 param.debugSession session's identifier for the client's logger instance
+ * @returns A {@link Amity.Client} instance
+ *
+ * @category Client API
+ * */
+const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAULT_DEBUG_SESSION, apiEndpoint, } = {}) => {
+    var _a, _b;
+    const log = createLogger(debugSession);
+    log('client/api/createClient', {
+        apiKey: apiKey.replace(/.{5}$/g, 'xxxxx'),
+        apiRegion,
+    });
+    const httpEndpoint = (_a = apiEndpoint === null || apiEndpoint === void 0 ? void 0 : apiEndpoint.http) !== null && _a !== void 0 ? _a : computeUrl('http', apiRegion);
+    const mqttEndpoint = (_b = apiEndpoint === null || apiEndpoint === void 0 ? void 0 : apiEndpoint.mqtt) !== null && _b !== void 0 ? _b : computeUrl('mqtt', apiRegion);
+    const http = createHttpTransport(httpEndpoint);
+    const ws = createWebsocketTransport(httpEndpoint);
+    const mqtt = createMqttTransport(mqttEndpoint);
+    const emitter = createEventEmitter();
+    const sessionState = "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */;
+    const sessionHandler = undefined;
+    const client = {
+        version: `${VERSION$1}`,
+        apiKey,
+        log,
+        http,
+        ws,
+        mqtt,
+        emitter,
+        accessTokenExpiryWatcher,
+        use: () => setActiveClient(client),
+        sessionState,
+        sessionHandler,
+        getFeedSettings,
+    };
+    try {
+        return getActiveClient();
+    }
+    catch (_c) {
+        setActiveClient(client);
+    }
+    return client;
+};
+
 /**
  * ```js
  * import { isConnected } from '@amityco/ts-sdk'
@@ -21027,13 +21398,6 @@ const onUserUnflagged = (callback) => createUserEventSubscriber('user.unflagged'
  */
 const onUserFlagCleared = (callback) => createUserEventSubscriber('user.flagCleared', callback);
 
-const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
-const COLLECTION_DEFAULT_CACHING_POLICY = 'cache_then_server';
-const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';
-const LIVE_OBJECT_ENABLE_CACHE_MESSAGE = 'For using Live Object feature you need to enable Cache!';
-const UNSYNCED_OBJECT_CACHED_AT_MESSAGE = 'Observing unsynced object is not supported by Live Object.';
-const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;
-
 /**
  * ```js
  * import { onUserFetched } from '@amityco/ts-sdk'
@@ -29195,9 +29559,9 @@ const onStreamRecorded = (callback) => {
  */
 const createUserToken = async (apiKey, apiRegion, params) => {
     const deviceId = getDeviceId();
-    const deviceInfo = await getDeviceInfo();
+    const deviceInfo = getDeviceInfo();
     const http = createHttpTransport(computeUrl('http', apiRegion));
-    const { data } = await http.post('/api/v3/sessions', Object.assign(Object.assign({}, params), { deviceId, deviceInfo: Object.assign(Object.assign({}, deviceInfo), { model: 'token management API on TS-SDK' }) }), { headers: { 'X-API-Key': apiKey } });
+    const { data } = await http.post('/api/v4/sessions', Object.assign(Object.assign({}, params), { deviceId, deviceInfo: Object.assign(Object.assign({}, deviceInfo), { model: 'token management API on TS-SDK' }) }), { headers: { 'X-API-Key': apiKey } });
     return { accessToken: data.accessToken };
 };
 
@@ -29401,6 +29765,7 @@ exports.onReactionAdded = onReactionAdded;
 exports.onReactionRemoved = onReactionRemoved;
 exports.onReactorAdded = onReactorAdded;
 exports.onReactorRemoved = onReactorRemoved;
+exports.onSessionStateChange = onSessionStateChange;
 exports.onStreamRecorded = onStreamRecorded;
 exports.onStreamStarted = onStreamStarted;
 exports.onStreamStopped = onStreamStopped;
@@ -29439,6 +29804,7 @@ exports.removeChannelMembersRole = removeChannelMembersRole;
 exports.removeCommunityMembers = removeCommunityMembers;
 exports.removeCommunityMembersRoles = removeCommunityMembersRoles;
 exports.removeReaction = removeReaction;
+exports.renewal = renewal;
 exports.restoreCache = restoreCache;
 exports.runQuery = runQuery;
 exports.sortByChannelSegment = sortByChannelSegment;