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

package/dist/index.cjs.js

@@ -7,7 +7,6 @@ var AsyncStorage = require('@react-native-async-storage/async-storage');
 var mitt = require('mitt');
 var debug = require('debug');
 var axios = require('axios');
-var qs = require('qs');
 var HttpAgent = require('agentkeepalive');
 var io = require('socket.io-client');
 var nativeIdGenerator = require('react-native-uuid');
@@ -18,7 +17,6 @@ var AsyncStorage__default = /*#__PURE__*/_interopDefaultLegacy(AsyncStorage);
 var mitt__default = /*#__PURE__*/_interopDefaultLegacy(mitt);
 var debug__default = /*#__PURE__*/_interopDefaultLegacy(debug);
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
-var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
 var HttpAgent__default = /*#__PURE__*/_interopDefaultLegacy(HttpAgent);
 var io__default = /*#__PURE__*/_interopDefaultLegacy(io);
 var nativeIdGenerator__default = /*#__PURE__*/_interopDefaultLegacy(nativeIdGenerator);
@@ -1094,6 +1092,14 @@ const sortByDisplayName = ({ displayName: a }, { displayName: b }) => {
         return 0;
     return a < b ? -1 : 1;
 };
+/**
+ * Alphabetic sorting of objects having a name
+ */
+const sortByName = ({ name: a }, { name: b }) => {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+};
 /**
  * Sorting a collection by their apparition order (oldest first)
  */
@@ -1140,6 +1146,9 @@ const WS_EVENTS = [
     'connect_error',
     'reconnect_error',
     'reconnect_failed',
+    'sessionStateChange',
+    // for internal use by accessTokenExpiryWatcher
+    'tokenExpired',
 ];
 const MQTT_EVENTS = [
     'connect',
@@ -1149,6 +1158,7 @@ const MQTT_EVENTS = [
     'close',
     'end',
     'reconnect',
+    'user.didGlobalBan',
 ];
 /** @hidden */
 const createEventEmitter = () => {
@@ -1167,7 +1177,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 +1184,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 +1332,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;
@@ -1394,13 +1403,6 @@ const unwrapPayload = (response) => {
     return undefined;
 };
 
-/**
- * Axios param serializer (for querystring)
- * @hidden
- */
-const stringify = (params) => {
-    return qs__default["default"].stringify(params, { arrayFormat: 'brackets' });
-};
 /**
  * Creates a pre-configured axios instance
  *
@@ -1421,15 +1423,47 @@ const createHttpTransport = (endpoint) => {
         baseURL: endpoint,
         httpAgent: new HttpAgent__default["default"](options),
         httpsAgent: new HttpAgent.HttpsAgent(options),
-        paramsSerializer: stringify,
+        /*
+         * If paramSerializer is required, use the serialize option to stringify
+         * params. The encode option will pass complex params as string only whereas
+         * the serialize option will pass params in the format Record<string, any>
+         *
+         * For more details:
+         * https://github.com/axios/axios#request-config
+         */
     });
-    instance.interceptors.response.use(response => response, error => {
+    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, _b;
         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)
-            unwrapPayload(response.data);
+        // 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 it's an error with status in the response payload,
+        // then it's an expected error.
+        if ((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.status) {
+            unwrapPayload(response === null || response === void 0 ? void 0 : response.data);
+        }
+        // unexpected error.
+        else {
+            throw new Error((_b = response === null || response === void 0 ? void 0 : response.data) !== null && _b !== void 0 ? _b : error);
+        }
     });
     return instance;
 };
@@ -20163,7 +20197,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 +20328,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 +20485,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 +20503,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 +20578,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 +20663,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 +20748,259 @@ 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]);
-    if ((config === null || config === void 0 ? void 0 : config.disableRTE) !== true) {
-        subscribeTopic(getNetworkTopic());
-        subscribeTopic(getSmartFeedChannelTopic());
-        subscribeTopic(getSmartFeedSubChannelTopic());
+    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 = (params) => {
+    const { expiresAt, issuedAt } = params;
+    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({ expiresAt, issuedAt })) {
+            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,12 +21410,57 @@ 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;
+const liveObject = (id, callback, key, fetcher, eventHandlers) => {
+    const { cache } = getActiveClient();
+    if (!cache) {
+        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+    }
+    let model;
+    let isUnsyncedModel = false; // for messages
+    const disposers = [];
+    const dispatcher = (data) => {
+        model = data.data;
+        callback(data);
+    };
+    const realtimeRouter = (eventModel) => {
+        if (id !== eventModel[key]) {
+            return;
+        }
+        if (model && !hasUpdates(model, eventModel)) {
+            return;
+        }
+        dispatcher({ loading: false, data: eventModel, origin: 'event' });
+    };
+    const onFetch = () => {
+        // @ts-ignore
+        const query = createQuery(fetcher, id, true);
+        runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+                dispatcher({
+                    // @ts-ignore
+                    data,
+                    origin,
+                    loading: false,
+                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
+                });
+                isUnsyncedModel = true;
+                disposers.forEach(fn => fn());
+            }
+            else if (!isUnsyncedModel) {
+                // @ts-ignore
+                dispatcher({ loading, data, origin, error });
+            }
+            if (error) {
+                disposers.forEach(fn => fn());
+            }
+        });
+    };
+    disposers.push(...eventHandlers.map(fn => fn(realtimeRouter)));
+    onFetch();
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
 
 /**
  * ```js
@@ -21071,42 +21499,14 @@ const onUserFetched = (callback) => createUserEventSubscriber('user.fetched', ca
  * @category Message Live Object
  */
 const liveUser = (userId, callback) => {
-    const { log, cache } = getActiveClient();
-    const timestamp = Date.now();
-    log(`liveUser(tmpid: ${timestamp}) > listen`);
-    if (!cache) {
-        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-    }
-    let user;
-    const disposers = [];
-    const dispatcher = (data) => {
-        user = data.data;
-        callback(data);
-    };
-    const realtimeRouter = (eventUser) => {
-        if (userId !== eventUser.userId) {
-            return;
-        }
-        if (user && !hasUpdates(user, eventUser)) {
-            return;
-        }
-        dispatcher({ loading: false, data: eventUser, origin: 'event' });
-    };
-    const onFetch = () => {
-        const query = createQuery(getUser, userId, true);
-        runQuery(query, ({ loading, data, error, origin }) => {
-            dispatcher({ loading, data, origin, error });
-            if (error) {
-                disposers.forEach(fn => fn());
-            }
-        });
-    };
-    disposers.push(onUserFetched(realtimeRouter), onUserUpdated(realtimeRouter), onUserDeleted(realtimeRouter), onUserFlagged(realtimeRouter), onUserUnflagged(realtimeRouter), onUserFlagCleared(realtimeRouter));
-    onFetch();
-    return () => {
-        log(`liveUser(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
+    return liveObject(userId, callback, 'userId', getUser, [
+        onUserFetched,
+        onUserUpdated,
+        onUserDeleted,
+        onUserFlagged,
+        onUserUnflagged,
+        onUserFlagCleared,
+    ]);
 };
 
 /**
@@ -21230,7 +21630,7 @@ const createFile = async (formData, onProgress) => {
         : { 'content-type': 'multipart/form-data' };
     const { data } = await client.http.post('/api/v4/files', formData, {
         headers,
-        onUploadProgress({ loaded, total }) {
+        onUploadProgress({ loaded, total = 100 }) {
             onProgress && onProgress(Math.round((loaded * 100) / total));
         },
     });
@@ -21309,7 +21709,7 @@ const createVideo = async (formData, feedType, onProgress) => {
         : { 'content-type': 'multipart/form-data' };
     const { data } = await client.http.post('/api/v4/videos', formData, {
         headers,
-        onUploadProgress({ loaded, total }) {
+        onUploadProgress({ loaded, total = 100 }) {
             onProgress && onProgress(Math.round((loaded * 100) / total));
         },
     });
@@ -21350,7 +21750,7 @@ const createImage = async (formData, onProgress) => {
         : { 'content-type': 'multipart/form-data' };
     const { data } = await client.http.post('/api/v4/images', formData, {
         headers,
-        onUploadProgress({ loaded, total }) {
+        onUploadProgress({ loaded, total = 100 }) {
             onProgress && onProgress(Math.round((loaded * 100) / total));
         },
     });
@@ -23329,6 +23729,7 @@ getComments.locally = (commentIds) => {
 const getComment = async (commentId) => {
     const client = getActiveClient();
     client.log('comment/getComment', commentId);
+    isInTombstone('comment', commentId);
     let data;
     try {
         // API-FIX: endpoint should not be /list, parameters should be querystring.
@@ -23336,8 +23737,8 @@ const getComment = async (commentId) => {
         data = response.data;
     }
     catch (error) {
-        if ((error === null || error === void 0 ? void 0 : error.code) === 400400 /* Amity.ServerError.ITEM_NOT_FOUND */) {
-            dropFromCache(['comment', 'get', commentId], true);
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('comment', commentId);
         }
         throw error;
     }
@@ -23471,9 +23872,7 @@ const deleteComment = async (commentId, permanent = false) => {
     fireEvent('post.updated', { posts: [post.data] });
     fireEvent('comment.deleted', { comments: [deleted] });
     if (permanent) {
-        setTimeout(() => {
-            dropFromCache(['comment', 'get', commentId], true);
-        }, 0);
+        scheduleTask(() => pushToTombstone('comment', commentId));
     }
     else {
         upsertInCache(['comment', 'get', commentId], { isDeleted: true });
@@ -25896,55 +26295,13 @@ const onMessageReactionRemoved = (callback) => {
  * @category Message Live Object
  */
 const liveChannel = (channelId, callback) => {
-    const { log, cache } = getActiveClient();
-    const timestamp = Date.now();
-    log(`liveChannel(tmpid: ${timestamp}) > listen`);
-    if (!cache) {
-        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-    }
-    let channel;
-    let isUnsyncedObject = false;
-    const disposers = [];
-    const dispatcher = (data) => {
-        channel = data.data;
-        callback(data);
-    };
-    const realtimeRouter = (eventChannel) => {
-        if (channelId !== eventChannel.channelId) {
-            return;
-        }
-        if (channel && !hasUpdates(channel, eventChannel)) {
-            return;
-        }
-        dispatcher({ loading: false, data: eventChannel, origin: 'event' });
-    };
-    const onFetch = () => {
-        const query = createQuery(getChannel, channelId);
-        runQuery(query, ({ loading, data, error, origin, cachedAt }) => {
-            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
-                dispatcher({
-                    data,
-                    origin,
-                    loading: false,
-                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
-                });
-                isUnsyncedObject = true;
-                disposers.forEach(fn => fn());
-            }
-            else if (!isUnsyncedObject) {
-                dispatcher({ loading, data, origin, error });
-            }
-            if (error) {
-                disposers.forEach(fn => fn());
-            }
-        });
-    };
-    disposers.push(onChannelUpdated(realtimeRouter), onChannelDeleted(realtimeRouter), onChannelJoined(realtimeRouter), onChannelMuted(realtimeRouter), onMessageCreated(() => null));
-    onFetch();
-    return () => {
-        log(`liveChannel(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
+    return liveObject(channelId, callback, 'channelId', getChannel, [
+        onChannelUpdated,
+        onChannelDeleted,
+        onChannelJoined,
+        onChannelMuted,
+        () => onMessageCreated(() => null), // watch unread count
+    ]);
 };
 
 /**
@@ -26605,42 +26962,11 @@ const onSubChannelFetched = (callback) => {
  * @category SubChannel Live Object
  */
 const liveSubChannel = (subChannelId, callback) => {
-    const { log, cache } = getActiveClient();
-    const timestamp = Date.now();
-    log(`liveSubChannel(tmpid: ${timestamp}) > listen`);
-    if (!cache) {
-        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-    }
-    let subChannel;
-    const disposers = [];
-    const dispatcher = (data) => {
-        subChannel = data.data;
-        callback(data);
-    };
-    const realtimeRouter = (eventSubChannel) => {
-        if (subChannelId !== eventSubChannel.subChannelId) {
-            return;
-        }
-        if (subChannel && !hasUpdates(subChannel, eventSubChannel)) {
-            return;
-        }
-        dispatcher({ loading: false, data: eventSubChannel, origin: 'event' });
-    };
-    const onFetch = () => {
-        const query = createQuery(getSubChannel, subChannelId);
-        runQuery(query, ({ error, data, loading, origin }) => {
-            dispatcher({ error, data, loading, origin });
-            if (error) {
-                disposers.forEach(fn => fn());
-            }
-        });
-    };
-    disposers.push(onSubChannelFetched(realtimeRouter), onSubChannelUpdated(realtimeRouter), onSubChannelDeleted(realtimeRouter));
-    onFetch();
-    return () => {
-        log(`liveSubChannel(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
+    return liveObject(subChannelId, callback, 'subChannelId', getSubChannel, [
+        onSubChannelFetched,
+        onSubChannelUpdated,
+        onSubChannelDeleted,
+    ]);
 };
 
 /**
@@ -26771,55 +27097,16 @@ const onMessageFetched = (callback) => {
  * @category Message Live Object
  */
 const liveMessage = (messageId, callback) => {
-    const { log, cache } = getActiveClient();
-    const timestamp = Date.now();
-    log(`liveMessage(tmpid: ${timestamp}) > listen`);
-    if (!cache) {
-        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-    }
-    let message;
-    let isUnsyncedObject = false;
-    const disposers = [];
-    const dispatcher = (data) => {
-        message = data.data;
-        callback(data);
-    };
-    const realtimeRouter = (eventMessage) => {
-        if (messageId !== eventMessage.messageId) {
-            return;
-        }
-        if (message && !hasUpdates(message, eventMessage)) {
-            return;
-        }
-        dispatcher({ loading: false, data: eventMessage, origin: 'event' });
-    };
-    const onFetch = () => {
-        const query = createQuery(getMessage, messageId, true);
-        runQuery(query, ({ loading, data, error, origin, cachedAt }) => {
-            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
-                dispatcher({
-                    data,
-                    origin,
-                    loading: false,
-                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
-                });
-                isUnsyncedObject = true;
-                disposers.forEach(fn => fn());
-            }
-            else if (!isUnsyncedObject) {
-                dispatcher({ loading, data, origin, error });
-            }
-            if (error) {
-                disposers.forEach(fn => fn());
-            }
-        });
-    };
-    disposers.push(onMessageFetched(realtimeRouter), onMessageUpdated(realtimeRouter), onMessageDeleted(realtimeRouter), onMessageFlagged(realtimeRouter), onMessageUnflagged(realtimeRouter), onMessageFlagCleared(realtimeRouter), onMessageReactionAdded(realtimeRouter), onMessageReactionRemoved(realtimeRouter));
-    onFetch();
-    return () => {
-        log(`liveMessage(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
+    return liveObject(messageId, callback, 'messageId', getMessage, [
+        onMessageFetched,
+        onMessageUpdated,
+        onMessageDeleted,
+        onMessageFlagged,
+        onMessageUnflagged,
+        onMessageFlagCleared,
+        onMessageReactionAdded,
+        onMessageReactionRemoved,
+    ]);
 };
 
 /**
@@ -27020,6 +27307,30 @@ const createCommunityEventSubscriber = (event, callback) => {
     };
     return createEventSubscriber(client, event, event, filter);
 };
+/*
+ * verifies membership status
+ */
+function isMember(membership) {
+    return membership !== 'none';
+}
+/*
+ * checks if currently logged in user is part of the community
+ */
+function isCurrentUserPartOfCommunity(c, m) {
+    const { userId } = getActiveUser();
+    return c.communityId === m.communityId && m.userId === userId;
+}
+/*
+ * For mqtt events server will not send user specific data as it's broadcasted
+ * to multiple users. Althought this can be calculated, it's not scalable. Hence
+ * the client SDK needs to calculate this info
+ */
+function updateMembershipStatus(communities, communityUsers) {
+    return communities.map(c => {
+        const isJoined = communityUsers.some(m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership));
+        return Object.assign(Object.assign({}, c), { isJoined });
+    });
+}
 function hasPermission(member, payload, permission) {
     if (member.permissions.some(x => x === permission)) {
         return true;
@@ -27050,7 +27361,15 @@ const createCommunityMemberEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
         const communityPayload = unpackCommunityPayload(payload);
+        const { communities } = communityPayload;
         const preparedPayload = prepareMembershipPayload(communityPayload, 'communityUsers');
+        const { communityUsers } = preparedPayload;
+        /*
+         * community.isJoined is not part of the communityMembership payload, and needs
+         * to be calculated based on the communityMembership value
+         */
+        const communitiesWithMembership = updateMembershipStatus(communities, communityUsers);
+        preparedPayload.communities = communitiesWithMembership;
         if (!client.cache) {
             // TODO: here we are missing specific properties here!
             callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
@@ -27192,6 +27511,23 @@ const onCommunityUserAdded = (callback) => createCommunityMemberEventSubscriber(
  */
 const onCommunityUserRemoved = (callback) => createCommunityMemberEventSubscriber('community.userRemoved', callback);
 
+/**
+ * ```js
+ * import { onCommunityUserChanged } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserChanged((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user has been added or removed from a {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+const onCommunityUserChanged = (callback) => createCommunityMemberEventSubscriber('community.userChanged', callback);
+
 /**
  * ```js
  * import { onCommunityUserBanned } from '@amityco/ts-sdk'
@@ -27270,6 +27606,122 @@ const observeCommunity = (communityId, callback) => {
     };
 };
 
+/**
+ * ```js
+ * import { liveCommunities } from '@amityco/ts-sdk'
+ *
+ * let communities = []
+ * const unsub = liveCommunities({
+ *   displayName: Amity.Community['displayName'],
+ * }, response => merge(communities, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Community}s
+ *
+ * @param params for querying communities
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the communities
+ *
+ * @category Community Live Collection
+ */
+const liveCommunities = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveCommunities(tmpid: ${timestamp}) > listen`);
+    const { limit: queryLimit } = params, queryParams = __rest(params, ["limit"]);
+    const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
+    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
+    const disposers = [];
+    const cacheKey = ['community', 'collection', {}];
+    const responder = (data) => {
+        var _a, _b;
+        let communities = (_a = data.data
+            .map(communityId => pullFromCache(['community', 'get', communityId]))
+            .filter(Boolean)
+            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+        communities = filterByPropEquality(communities, 'isDeleted', params.isDeleted);
+        communities = filterByPropEquality(communities, 'displayName', params.displayName);
+        if (params.categoryId) {
+            communities = communities.filter(c => { var _a; return (_a = c.categoryIds) === null || _a === void 0 ? void 0 : _a.includes(params.categoryId); });
+        }
+        if (params.tags) {
+            communities = communities.filter(c => { var _a; return (_a = c.tags) === null || _a === void 0 ? void 0 : _a.some(t => { var _a; return (_a = params.tags) === null || _a === void 0 ? void 0 : _a.includes(t); }); });
+        }
+        if (params.membership === 'member') {
+            communities = filterByPropEquality(communities, 'isJoined', true);
+        }
+        if (params.membership === 'notMember') {
+            communities = filterByPropEquality(communities, 'isJoined', false);
+        }
+        const sortBy = params.sortBy || 'lastCreated';
+        if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
+            communities = communities.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+        }
+        /*
+         * The server returns communities with empty | null displayName's first before
+         * returning sorted list of communities with displayNames
+         *
+         * This section needs to be updated as displayNames can be null as well
+         */
+        if (sortBy === 'displayName') {
+            communities = communities
+                // this needs to be aligned with the backend data type
+                .map(c => (c.displayName ? c : Object.assign(Object.assign({}, c), { displayName: '' })))
+                // @ts-ignore
+                .sort(sortByDisplayName);
+        }
+        callback({
+            onNextPage: onFetch,
+            data: communities,
+            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (_) => (community) => {
+        var _a;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        /*
+         * Simply update collection and let responder decide what to do with data
+         */
+        collection.data = [...new Set([community.communityId, ...collection.data])];
+        pushToCache(cacheKey, collection);
+        responder(collection);
+    };
+    const onFetch = () => {
+        var _a, _b, _c;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const communities = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        if (communities.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
+            return;
+        const query = createQuery(queryCommunities, Object.assign(Object.assign({}, queryParams), { page: (_c = collection === null || collection === void 0 ? void 0 : collection.params.page) !== null && _c !== void 0 ? _c : { limit } }));
+        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
+            const data = {
+                loading,
+                error,
+                params: { page },
+                data: communities,
+            };
+            if (result) {
+                data.data = [...new Set([...communities, ...result.map(getResolver('community'))])];
+            }
+            pushToCache(cacheKey, data);
+            responder(data);
+        }, queryOptions(policy));
+    };
+    disposers.push(onCommunityCreated(realtimeRouter()), onCommunityDeleted(realtimeRouter()), onCommunityUpdated(realtimeRouter()), onCommunityJoined(realtimeRouter()), onCommunityLeft(realtimeRouter()), onCommunityUserChanged(realtimeRouter()));
+    onFetch();
+    return () => {
+        log(`liveCommunities(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 /**
  * ```js
  * import { queryCategories } from '@amityco/ts-sdk'
@@ -27398,6 +27850,96 @@ getCategory.locally = (categoryId) => {
     };
 };
 
+/**
+ * ```js
+ * import { liveCategories } from '@amityco/ts-sdk'
+ *
+ * let categories = []
+ * const unsub = liveCategories({}, response => merge(categories, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Category}s
+ *
+ * @param params for querying categories
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the categories
+ *
+ * @category Category Live Collection
+ */
+const liveCategories = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveCategories(tmpid: ${timestamp}) > listen`);
+    const { limit: queryLimit } = params, queryParams = __rest(params, ["limit"]);
+    const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
+    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
+    const disposers = [];
+    const cacheKey = ['category', 'collection', {}];
+    const responder = (data) => {
+        var _a, _b;
+        let categories = (_a = data.data
+            .map(categoryId => pullFromCache(['category', 'get', categoryId]))
+            .filter(Boolean)
+            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+        categories = filterByPropEquality(categories, 'isDeleted', params.isDeleted);
+        switch (params.sortBy) {
+            case 'firstCreated':
+                categories = categories.sort(sortByFirstCreated);
+                break;
+            case 'lastCreated':
+                categories = categories.sort(sortByLastCreated);
+                break;
+            default:
+                categories = categories.sort(sortByName);
+        }
+        callback({
+            onNextPage: onFetch,
+            data: categories,
+            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    /*
+     * const realtimeRouter = () => {
+     * @TODO: At the time of creating this method category does not have any
+     * observers
+     *};
+     */
+    const onFetch = () => {
+        var _a, _b, _c;
+        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const categories = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        if (categories.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
+            return;
+        const query = createQuery(queryCategories, Object.assign(Object.assign({}, queryParams), { page: (_c = collection === null || collection === void 0 ? void 0 : collection.params.page) !== null && _c !== void 0 ? _c : { limit } }));
+        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
+            const data = {
+                loading,
+                error,
+                params: { page },
+                data: categories,
+            };
+            if (result) {
+                data.data = [...new Set([...categories, ...result.map(getResolver('category'))])];
+            }
+            pushToCache(cacheKey, data);
+            responder(data);
+        }, queryOptions(policy));
+    };
+    disposers.push(() => {
+        // @TODO -> update once observers added
+    });
+    onFetch();
+    return () => {
+        log(`liveCategories(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 /**
  * ```js
  * import { queryGlobalFeed } from '@amityco/ts-sdk'
@@ -28322,6 +28864,38 @@ const observePost = (postId, callback, policy = 'cache_then_server') => {
     };
 };
 
+/**
+ * ```js
+ * import { livePost } from '@amityco/ts-sdk';
+ *
+ * let post;
+ *
+ * const unsubscribe = livePost(postId, response => {
+ *   post = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Post}
+ *
+ * @param postId the ID of the message to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the sub channel
+ *
+ * @category Post Live Object
+ */
+const livePost = (postId, callback) => {
+    return liveObject(postId, callback, 'postId', getPost, [
+        onPostApproved,
+        onPostDeclined,
+        onPostDeleted,
+        onPostFlagged,
+        onPostReactionAdded,
+        onPostReactionRemoved,
+        onPostUnflagged,
+        onPostUpdated,
+    ]);
+};
+
 /**
  * ```js
  * import { livePosts } from '@amityco/ts-sdk'
@@ -28517,6 +29091,36 @@ const observeComment = (commentId, callback, policy = 'cache_then_server') => {
     };
 };
 
+/**
+ * ```js
+ * import { liveComment } from '@amityco/ts-sdk';
+ *
+ * let comment;
+ *
+ * const unsubscribe = liveComment(commentId, response => {
+ *   comment = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Comment}
+ *
+ * @param commentId the ID of the comment to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
+ *
+ * @category Comment Live Object
+ */
+const liveComment = (commentId, callback) => {
+    return liveObject(commentId, callback, 'commentId', getComment, [
+        onCommentDeleted,
+        onCommentFlagged,
+        onCommentReactionAdded,
+        onCommentReactionRemoved,
+        onCommentUnflagged,
+        onCommentUpdated,
+    ]);
+};
+
 /**
  * ```js
  * import { liveComments } from '@amityco/ts-sdk'
@@ -29195,9 +29799,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 };
 };
 
@@ -29314,14 +29918,18 @@ exports.joinChannel = joinChannel;
 exports.joinCommunity = joinCommunity;
 exports.leaveChannel = leaveChannel;
 exports.leaveCommunity = leaveCommunity;
+exports.liveCategories = liveCategories;
 exports.liveChannel = liveChannel;
 exports.liveChannelMembers = liveChannelMembers;
 exports.liveChannels = liveChannels;
+exports.liveComment = liveComment;
 exports.liveComments = liveComments;
+exports.liveCommunities = liveCommunities;
 exports.liveFollowers = liveFollowers;
 exports.liveFollowings = liveFollowings;
 exports.liveMessage = liveMessage;
 exports.liveMessages = liveMessages;
+exports.livePost = livePost;
 exports.livePosts = livePosts;
 exports.liveReactions = liveReactions;
 exports.liveSubChannel = liveSubChannel;
@@ -29369,6 +29977,7 @@ exports.onCommunityLeft = onCommunityLeft;
 exports.onCommunityUpdated = onCommunityUpdated;
 exports.onCommunityUserAdded = onCommunityUserAdded;
 exports.onCommunityUserBanned = onCommunityUserBanned;
+exports.onCommunityUserChanged = onCommunityUserChanged;
 exports.onCommunityUserRemoved = onCommunityUserRemoved;
 exports.onCommunityUserUnbanned = onCommunityUserUnbanned;
 exports.onConnectionError = onConnectionError;
@@ -29401,6 +30010,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 +30049,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;
@@ -29446,6 +30057,7 @@ exports.sortByDisplayName = sortByDisplayName;
 exports.sortByFirstCreated = sortByFirstCreated;
 exports.sortByLastActivity = sortByLastActivity;
 exports.sortByLastCreated = sortByLastCreated;
+exports.sortByName = sortByName;
 exports.sortBySegmentNumber = sortBySegmentNumber;
 exports.startReading = startReading;
 exports.stopReading = stopReading;