@amityco/ts-sdk-react-native 7.13.0 → 7.14.0

package/dist/index.cjs.js

@@ -224,6 +224,12 @@ exports.FeedSourceEnum = void 0;
     FeedSourceEnum["Community"] = "community";
     FeedSourceEnum["User"] = "user";
 })(exports.FeedSourceEnum || (exports.FeedSourceEnum = {}));
+exports.FeedTypeEnum = void 0;
+(function (FeedTypeEnum) {
+    FeedTypeEnum["Reviewing"] = "reviewing";
+    FeedTypeEnum["Published"] = "published";
+    FeedTypeEnum["Declined"] = "declined";
+})(exports.FeedTypeEnum || (exports.FeedTypeEnum = {}));
 
 exports.AmityEventType = void 0;
 (function (AmityEventType) {
@@ -260,8 +266,8 @@ exports.AmityEventOrderOption = void 0;
 
 function getVersion() {
     try {
-        // the string ''v7.13.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v7.13.0-cjs';
+        // the string ''v7.14.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v7.14.0-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -1715,10 +1721,14 @@ const getLiveReactionTopic = (post) => {
 };
 const getRoomWatcherTopic = (room) => {
     const user = getCurrentUser();
+    if (!user)
+        return;
     return `${getNetworkId(user)}/room/${room._id}`;
 };
 const getRoomStreamerTopic = (room) => {
     const user = getCurrentUser();
+    if (!user)
+        return;
     return `${getNetworkId(user)}/room/${room.roomId}/streamer`;
 };
 function subscribeTopic(topic, callback) {
@@ -1813,13 +1823,13 @@ class NetworkActivitiesWatcher {
         this._listener.clear();
     }
 }
-let instance$7;
+let instance$8;
 var NetworkActivitiesWatcher$1 = {
     getInstance: () => {
-        if (!instance$7) {
-            instance$7 = new NetworkActivitiesWatcher();
+        if (!instance$8) {
+            instance$8 = new NetworkActivitiesWatcher();
         }
-        return instance$7;
+        return instance$8;
     },
 };
 
@@ -6914,13 +6924,13 @@ class SessionWatcher {
         this._listener.clear();
     }
 }
-let instance$6;
+let instance$7;
 var SessionWatcher$1 = {
     getInstance: () => {
-        if (!instance$6) {
-            instance$6 = new SessionWatcher();
+        if (!instance$7) {
+            instance$7 = new SessionWatcher();
         }
-        return instance$6;
+        return instance$7;
     },
 };
 
@@ -7497,6 +7507,108 @@ const setVisitorClientToken = async (params) => {
     return { accessToken, users, userType };
 };
 
+/* begin_public_function
+  id: client.logout
+*/
+/**
+ * ```js
+ * import { Client } from '@amityco/ts-sdk-react-native';
+ * const success = await Client.logout()
+ * ```
+ *
+ * Disconnects an {@link Amity.Client} instance from ASC servers
+ *
+ * @returns a success boolean if disconnected
+ *
+ * @category Client API
+ * @async
+ */
+const logout = async () => {
+    var _a;
+    const client = getActiveClient();
+    client.log('client/api/disconnectClient');
+    if (client.mqtt && client.mqtt.connected) {
+        client.mqtt.disconnect();
+    }
+    /*
+     * for cases when session state is terminated (example on ban) or token expired,
+     * the terminating block will set session state to terminated or for the or
+     * in the case of expired token the same happens
+     *
+     * establishing state also ignored in cases where accessTokenExpiryWatcher
+     * calls renewal. There is a possibility that renewal will be called before
+     * disconnectClient finishes execution
+     *
+     * IMPORTANT: call this before `emitter.all.clear()`, otherwise the session
+     * event will never be triggered
+     */
+    if (client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */)
+        setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
+    client.emitter.all.clear();
+    (_a = client.mqtt) === null || _a === void 0 ? void 0 : _a.removeAllListeners();
+    client.userId = undefined;
+    client.token = undefined;
+    client.loginType = undefined;
+    client.http.defaults.headers.common.Authorization = '';
+    client.http.defaults.metadata = {
+        tokenExpiry: '',
+        isGlobalBanned: false,
+        isUserDeleted: false,
+    };
+    if (typeof document !== 'undefined') {
+        document.cookie = '_ascSession=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';
+    }
+    /*
+     * Cache should be usable if tokenExpired
+     * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#SDK-usability-based-on-Session-State
+     */
+    if (client.sessionState !== "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */ && client.cache) {
+        client.cache = { data: {} };
+    }
+    return true;
+};
+/* end_public_function */
+
+/**
+ * Terminates {@link Amity.Client} instance
+ *
+ *
+ *
+ * @category private
+ */
+const terminateClient = (terminationReason) => {
+    const client = getActiveClient();
+    setSessionState("terminated" /* Amity.SessionStates.TERMINATED */, terminationReason);
+    if (client.http.defaults.metadata) {
+        if (terminationReason === "globalBan" /* Amity.TokenTerminationReason.GLOBAL_BAN */)
+            client.http.defaults.metadata.isGlobalBanned = true;
+        if (terminationReason === "userDeleted" /* Amity.TokenTerminationReason.USER_DELETED */)
+            client.http.defaults.metadata.isUserDeleted = true;
+    }
+    client.sessionHandler = undefined;
+    logout();
+};
+
+let currentUserType = null;
+/* begin_public_function
+  id: client.get_current_user_type
+*/
+const getCurrentUserType = () => {
+    if (!currentUserType) {
+        throw new ASCError('Connect client first', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "fatal" /* Amity.ErrorLevel.FATAL */);
+    }
+    return currentUserType;
+};
+/* end_public_function */
+const setCurrentUserType = (userType) => {
+    currentUserType = userType;
+};
+
+const setCurrentUser = ({ user, userType, }) => {
+    setActiveUser(user);
+    setCurrentUserType(userType);
+};
+
 const createUserEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (data) => {
@@ -7815,13 +7927,13 @@ class AnalyticsEngine {
         this._eventCapturer.resetAllBuckets();
     }
 }
-let instance$5;
+let instance$6;
 var AnalyticsEngine$1 = {
     getInstance: () => {
-        if (!instance$5) {
-            instance$5 = new AnalyticsEngine();
+        if (!instance$6) {
+            instance$6 = new AnalyticsEngine();
         }
-        return instance$5;
+        return instance$6;
     },
 };
 
@@ -8049,12 +8161,12 @@ class MessageReadReceiptSyncEngine {
         }
     }
 }
-let instance$4 = null;
+let instance$5 = null;
 var ReadReceiptSyncEngine = {
     getInstance: () => {
-        if (!instance$4)
-            instance$4 = new MessageReadReceiptSyncEngine();
-        return instance$4;
+        if (!instance$5)
+            instance$5 = new MessageReadReceiptSyncEngine();
+        return instance$5;
     },
 };
 
@@ -8308,12 +8420,12 @@ class LegacyMessageReadReceiptSyncEngine {
         }
     }
 }
-let instance$3 = null;
+let instance$4 = null;
 var LegacyReadReceiptSyncEngine = {
     getInstance: () => {
-        if (!instance$3)
-            instance$3 = new LegacyMessageReadReceiptSyncEngine();
-        return instance$3;
+        if (!instance$4)
+            instance$4 = new LegacyMessageReadReceiptSyncEngine();
+        return instance$4;
     },
 };
 
@@ -8589,12 +8701,12 @@ class ObjectResolverEngine {
         this.stopResolver();
     }
 }
-let instance$2 = null;
+let instance$3 = null;
 var ObjectResolverEngine$1 = {
     getInstance: () => {
-        if (!instance$2)
-            instance$2 = new ObjectResolverEngine();
-        return instance$2;
+        if (!instance$3)
+            instance$3 = new ObjectResolverEngine();
+        return instance$3;
     },
 };
 
@@ -8744,13 +8856,13 @@ class LiveReactionSyncEngine {
         this.stopReactionsSync();
     }
 }
-let instance$1;
+let instance$2;
 var ReactionSyncEngine = {
     getInstance: () => {
-        if (!instance$1) {
-            instance$1 = new LiveReactionSyncEngine();
+        if (!instance$2) {
+            instance$2 = new LiveReactionSyncEngine();
         }
-        return instance$1;
+        return instance$2;
     },
 };
 
@@ -8772,87 +8884,6 @@ var reactionSyncEngineOnLoginHandler = () => {
     };
 };
 
-/* begin_public_function
-  id: client.logout
-*/
-/**
- * ```js
- * import { Client } from '@amityco/ts-sdk-react-native';
- * const success = await Client.logout()
- * ```
- *
- * Disconnects an {@link Amity.Client} instance from ASC servers
- *
- * @returns a success boolean if disconnected
- *
- * @category Client API
- * @async
- */
-const logout = async () => {
-    var _a;
-    const client = getActiveClient();
-    client.log('client/api/disconnectClient');
-    if (client.mqtt && client.mqtt.connected) {
-        client.mqtt.disconnect();
-    }
-    /*
-     * for cases when session state is terminated (example on ban) or token expired,
-     * the terminating block will set session state to terminated or for the or
-     * in the case of expired token the same happens
-     *
-     * establishing state also ignored in cases where accessTokenExpiryWatcher
-     * calls renewal. There is a possibility that renewal will be called before
-     * disconnectClient finishes execution
-     *
-     * IMPORTANT: call this before `emitter.all.clear()`, otherwise the session
-     * event will never be triggered
-     */
-    if (client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */)
-        setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
-    client.emitter.all.clear();
-    (_a = client.mqtt) === null || _a === void 0 ? void 0 : _a.removeAllListeners();
-    client.userId = undefined;
-    client.token = undefined;
-    client.http.defaults.headers.common.Authorization = '';
-    client.http.defaults.metadata = {
-        tokenExpiry: '',
-        isGlobalBanned: false,
-        isUserDeleted: false,
-    };
-    if (typeof document !== 'undefined') {
-        document.cookie = '_ascSession=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';
-    }
-    /*
-     * Cache should be usable if tokenExpired
-     * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#SDK-usability-based-on-Session-State
-     */
-    if (client.sessionState !== "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */ && client.cache) {
-        client.cache = { data: {} };
-    }
-    return true;
-};
-/* end_public_function */
-
-/**
- * Terminates {@link Amity.Client} instance
- *
- *
- *
- * @category private
- */
-const terminateClient = (terminationReason) => {
-    const client = getActiveClient();
-    setSessionState("terminated" /* Amity.SessionStates.TERMINATED */, terminationReason);
-    if (client.http.defaults.metadata) {
-        if (terminationReason === "globalBan" /* Amity.TokenTerminationReason.GLOBAL_BAN */)
-            client.http.defaults.metadata.isGlobalBanned = true;
-        if (terminationReason === "userDeleted" /* Amity.TokenTerminationReason.USER_DELETED */)
-            client.http.defaults.metadata.isUserDeleted = true;
-    }
-    client.sessionHandler = undefined;
-    logout();
-};
-
 const EVENTS = [
     'disconnected',
     'error',
@@ -8982,24 +9013,50 @@ const removeChannelMarkerCache = (channel) => {
     dropFromCache(['channelMarker', 'get', id], true);
 };
 
-let currentUserType = null;
-/* begin_public_function
-  id: client.get_current_user_type
-*/
-const getCurrentUserType = () => {
-    if (!currentUserType) {
-        throw new ASCError('Connect client first', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "fatal" /* Amity.ErrorLevel.FATAL */);
+/**
+ * Sets up all login-related event subscriptions
+ * This includes handlers for user bans, deletions, token events, and various engine initializations
+ *
+ * @param unsubWatcher - The unsubscriber function for the access token expiry watcher
+ * @returns Array of unsubscriber functions for all registered subscriptions
+ *
+ * @category private
+ */
+const setupLoginSubscriptions = (unsubWatcher) => {
+    const client = getActiveClient();
+    const subscriptions = [];
+    subscriptions.push(
+    // GLOBAL_BAN
+    onClientBanned((_) => {
+        terminateClient("globalBan" /* Amity.TokenTerminationReason.GLOBAL_BAN */);
+        subscriptions.forEach(fn => fn());
+        unsubWatcher();
+    }), onTokenTerminated(_ => {
+        terminateClient();
+        subscriptions.forEach(fn => fn());
+        unsubWatcher();
+    }), onUserDeleted$2((user) => {
+        if (user.userId === client.userId) {
+            terminateClient("userDeleted" /* Amity.TokenTerminationReason.USER_DELETED */);
+            subscriptions.forEach(fn => fn());
+            unsubWatcher();
+        }
+    }), onTokenExpired(state => {
+        SessionWatcher$1.getInstance().setSessionState(state);
+        logout();
+        subscriptions.forEach(fn => fn());
+    }), 
+    // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
+    // the channel because currently backend can't handle this, so every time a user is banned from
+    // a channel or the channel is deleted the channel's unread count will not be reset to zero
+    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler());
+    if (client.useLegacyUnreadCount) {
+        subscriptions.push(readReceiptSyncEngineOnLoginHandler());
     }
-    return currentUserType;
-};
-/* end_public_function */
-const setCurrentUserType = (userType) => {
-    currentUserType = userType;
-};
-
-const setCurrentUser = ({ user, userType, }) => {
-    setActiveUser(user);
-    setCurrentUserType(userType);
+    else {
+        subscriptions.push(legacyReadReceiptSyncEngineOnLoginHandler());
+    }
+    return subscriptions;
 };
 
 /* eslint-disable no-param-reassign */
@@ -9008,8 +9065,8 @@ const setCurrentUser = ({ user, userType, }) => {
  * than the one already connected, in which case the existing subscriptions need
  * to be cleared
  */
-let subscriptions$3 = [];
-async function runMqtt$1() {
+let subscriptions$4 = [];
+async function runMqtt$2() {
     await modifyMqttConnection();
 }
 /* begin_public_function
@@ -9043,8 +9100,8 @@ const login = async (params, sessionHandler, config) => {
     if (client.userId && client.userId !== params.userId) {
         await logout();
         // Remove subscription to ban and delete
-        subscriptions$3.forEach(fn => fn());
-        subscriptions$3 = [];
+        subscriptions$4.forEach(fn => fn());
+        subscriptions$4 = [];
     }
     // default values
     const defaultDeviceId = await getDeviceId();
@@ -9069,11 +9126,12 @@ const login = async (params, sessionHandler, config) => {
         }
         client.userId = user.userId;
         client.sessionHandler = sessionHandler;
+        client.loginType = 'userId';
         /*
          * Cannot push to subscriptions as watcher needs to continue working even if
          * token expires
          */
-        unsubWatcher = client.accessTokenExpiryWatcher(sessionHandler);
+        unsubWatcher = client.accessTokenExpiryWatcher();
         setCurrentUser({ user, userType });
     }
     catch (error) {
@@ -9086,40 +9144,11 @@ const login = async (params, sessionHandler, config) => {
         throw error;
     }
     if ((config === null || config === void 0 ? void 0 : config.disableRTE) !== true) {
-        runMqtt$1();
+        runMqtt$2();
     }
     await initializeMessagePreviewSetting();
-    if (subscriptions$3.length === 0) {
-        subscriptions$3.push(
-        // GLOBAL_BAN
-        onClientBanned((_) => {
-            terminateClient("globalBan" /* Amity.TokenTerminationReason.GLOBAL_BAN */);
-            subscriptions$3.forEach(fn => fn());
-            unsubWatcher();
-        }), onTokenTerminated(_ => {
-            terminateClient();
-            subscriptions$3.forEach(fn => fn());
-            unsubWatcher();
-        }), onUserDeleted$2((user) => {
-            if (user.userId === client.userId) {
-                terminateClient("userDeleted" /* Amity.TokenTerminationReason.USER_DELETED */);
-                subscriptions$3.forEach(fn => fn());
-                unsubWatcher();
-            }
-        }), onTokenExpired(state => {
-            SessionWatcher$1.getInstance().setSessionState(state);
-            logout();
-            subscriptions$3.forEach(fn => fn());
-        }), 
-        // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
-        // the channel because currently backend can't handle this, so every time a user is banned from
-        // a channel or the channel is deleted the channel's unread count will not be reset to zero
-        onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler());
-        if (client.useLegacyUnreadCount) {
-            subscriptions$3.push(readReceiptSyncEngineOnLoginHandler());
-        }
-        else
-            subscriptions$3.push(legacyReadReceiptSyncEngineOnLoginHandler());
+    if (subscriptions$4.length === 0) {
+        subscriptions$4 = setupLoginSubscriptions(unsubWatcher);
     }
     return true;
 };
@@ -9131,7 +9160,7 @@ const login = async (params, sessionHandler, config) => {
  * than the one already connected, in which case the existing subscriptions need
  * to be cleared
  */
-const subscriptions$2 = [];
+const subscriptions$3 = [];
 /* begin_public_function
   id: client.loginAsVisitor
 */
@@ -9174,11 +9203,12 @@ const loginAsVisitor = async (params) => {
         [user] = users;
         client.userId = user.userId;
         client.sessionHandler = params.sessionHandler;
+        client.loginType = 'userId';
         /*
          * Cannot push to subscriptions as watcher needs to continue working even if
          * token expires
          */
-        unsubWatcher = client.accessTokenExpiryWatcher(params.sessionHandler);
+        unsubWatcher = client.accessTokenExpiryWatcher();
         setCurrentUser({ user, userType });
     }
     catch (error) {
@@ -9191,16 +9221,16 @@ const loginAsVisitor = async (params) => {
         throw error;
     }
     await initializeMessagePreviewSetting();
-    if (subscriptions$2.length === 0) {
+    if (subscriptions$3.length === 0) {
         // handling internal SDK events
-        subscriptions$2.push(onTokenTerminated(_ => {
+        subscriptions$3.push(onTokenTerminated(_ => {
             terminateClient();
-            subscriptions$2.forEach(fn => fn());
+            subscriptions$3.forEach(fn => fn());
             unsubWatcher();
         }), onTokenExpired(state => {
             SessionWatcher$1.getInstance().setSessionState(state);
             logout();
-            subscriptions$2.forEach(fn => fn());
+            subscriptions$3.forEach(fn => fn());
         }));
     }
     return true;
@@ -9229,7 +9259,7 @@ const renewal = () => {
      * Per instance of Renewal, only one renewal is allowed
      */
     const renewToken = async (authToken) => {
-        const { userId, displayName } = getCurrentUser();
+        const { userId, displayName } = getActiveUser();
         const deviceId = await getDeviceId();
         const params = { userId, displayName, authToken, deviceId };
         if (client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */ && client.sessionHandler) {
@@ -9304,6 +9334,242 @@ const renewal = () => {
 };
 /* end_public_function */
 
+const validateAccessToken = async ({ token, userId }) => {
+    const client = getActiveClient();
+    // Validate token using sessions API
+    await client.http.get('/api/v3/sessions', {
+        headers: {
+            Authorization: `Bearer ${token.accessToken}`,
+        },
+    });
+    // Get user details
+    const { data: { users }, } = await client.http.get(`/api/v3/users/${userId}`, {
+        headers: {
+            Authorization: `Bearer ${token.accessToken}`,
+        },
+    });
+    const user = users.find((u) => u.userId === userId);
+    client.http.defaults.headers.common.Authorization = `Bearer ${token.accessToken}`;
+    client.http.defaults.metadata = {
+        tokenExpiry: token.expiresAt,
+        isGlobalBanned: false,
+        isUserDeleted: false,
+    };
+    client.upload.defaults.headers.common.Authorization = `Bearer ${token.accessToken}`;
+    client.upload.defaults.metadata = {
+        tokenExpiry: token.expiresAt,
+        isGlobalBanned: false,
+        isUserDeleted: false,
+    };
+    client.token = token;
+    return user;
+};
+
+const isSameUserId = (token) => {
+    var _a;
+    const client = getActiveClient();
+    const decoded = jwtDecode__default["default"](token);
+    return ((_a = decoded === null || decoded === void 0 ? void 0 : decoded.user) === null || _a === void 0 ? void 0 : _a.publicUserId) === client.userId;
+};
+
+let subscriptions$2 = [];
+async function runMqtt$1() {
+    await modifyMqttConnection();
+}
+/* begin_public_function
+  id: client.loginWithAccessToken
+*/
+/**
+ * ```js
+ * import { loginWithAccessToken } from '@amityco/ts-sdk'
+ * const success = await loginWithAccessToken('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...')
+ * ```
+ *
+ * Authenticates a user using a pre-existing access token, allowing direct login without user credentials.
+ * Designed for customers who manage access tokens on their own backend.
+ *
+ * @param accessToken JWT access token signed by customer's backend containing user identity
+ * @returns true if authentication is successful
+ *
+ * @category Client API
+ * @async
+ */
+const loginWithAccessToken = async (accessToken) => {
+    var _a, _b;
+    const client = getActiveClient();
+    let unsubWatcher;
+    client.log('client/api/loginWithAccessToken', {
+        apiKey: client.apiKey,
+        sessionState: client.sessionState,
+    });
+    // Validate input
+    if (!accessToken || typeof accessToken !== 'string' || accessToken.trim() === '') {
+        throw new ASCError('Access token must be a non-empty string', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+    let decoded;
+    try {
+        decoded = jwtDecode__default["default"](accessToken);
+    }
+    catch (error) {
+        throw new ASCError('Invalid access token format', 400100 /* Amity.ServerError.UNAUTHORIZED */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+    // Extract userId from token
+    const userId = ((_a = decoded === null || decoded === void 0 ? void 0 : decoded.user) === null || _a === void 0 ? void 0 : _a.publicUserId) || ((_b = decoded === null || decoded === void 0 ? void 0 : decoded.user) === null || _b === void 0 ? void 0 : _b.userId);
+    if (!userId) {
+        throw new ASCError('Access token does not contain userId', 400100 /* Amity.ServerError.UNAUTHORIZED */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+    // Handle existing connected user
+    if (client.userId) {
+        const sameUser = isSameUserId(accessToken);
+        if (!sameUser) {
+            // Different user - do full logout
+            await logout();
+        }
+    }
+    try {
+        // Set state to establishing
+        setSessionState("establishing" /* Amity.SessionStates.ESTABLISHING */);
+        // Prepare token object for validation
+        const tokenObject = {
+            accessToken,
+            issuedAt: decoded.iat ? new Date(decoded.iat * 1000).toISOString() : new Date().toISOString(),
+            expiresAt: new Date(decoded.exp * 1000).toISOString(),
+        };
+        // Validate token and get user
+        const user = await validateAccessToken({
+            token: tokenObject,
+            userId,
+        });
+        if (user == null) {
+            setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
+            throw new ASCError(`User ${userId} has not been found`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+        }
+        if (user.isDeleted) {
+            setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
+            throw new ASCError(`User ${userId} has been deleted`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+        }
+        if (user.isGlobalBanned) {
+            setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
+            throw new ASCError(`User ${userId} is globally banned`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+        }
+        // Set userId and login method flag
+        client.userId = user.userId;
+        // Set login method flag to 'accessToken' in platform-specific login session
+        client.loginType = 'accessToken';
+        // This will be used by the access token handler to determine if token renewal should be invoked
+        // Set active user
+        setActiveUser(user);
+        unsubWatcher = client.accessTokenExpiryWatcher();
+        setSessionState("established" /* Amity.SessionStates.ESTABLISHED */);
+    }
+    catch (error) {
+        // If error occurs, revert session state to not logged in
+        setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
+        // Re-throw if it's already an ASCError
+        if (error instanceof ASCError) {
+            throw error;
+        }
+        // Wrap other errors
+        throw new ASCError((error instanceof Error ? error.message : undefined) || 'Login with access token failed', 400100 /* Amity.ServerError.UNAUTHORIZED */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+    runMqtt$1();
+    await initializeMessagePreviewSetting();
+    if (subscriptions$2.length === 0) {
+        subscriptions$2 = setupLoginSubscriptions(unsubWatcher);
+    }
+    return true;
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: client.renew_with_accessToken
+*/
+/*
+ * 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 renewWithAccessToken = async (accessToken) => {
+    var _a, _b;
+    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
+     */
+    // Validate input
+    if (!accessToken || typeof accessToken !== 'string' || accessToken.trim() === '') {
+        throw new ASCError('Access token must be a non-empty string', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+    let decoded;
+    try {
+        decoded = jwtDecode__default["default"](accessToken);
+    }
+    catch (error) {
+        throw new ASCError('Invalid access token format', 400100 /* Amity.ServerError.UNAUTHORIZED */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+    // Extract userId from token
+    const userId = ((_a = decoded === null || decoded === void 0 ? void 0 : decoded.user) === null || _a === void 0 ? void 0 : _a.publicUserId) || ((_b = decoded === null || decoded === void 0 ? void 0 : decoded.user) === null || _b === void 0 ? void 0 : _b.userId);
+    if (!userId) {
+        throw new ASCError('Access token does not contain userId', 400100 /* Amity.ServerError.UNAUTHORIZED */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+    // Handle existing connected user
+    if (client.userId) {
+        const sameUser = isSameUserId(accessToken);
+        if (!sameUser) {
+            // Different user - do full logout
+            await logout();
+        }
+    }
+    const tokenObject = {
+        accessToken,
+        issuedAt: decoded.iat ? new Date(decoded.iat * 1000).toISOString() : new Date().toISOString(),
+        expiresAt: new Date(decoded.exp * 1000).toISOString(),
+    };
+    if (client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */ && client.sessionHandler) {
+        await loginWithAccessToken(accessToken);
+    }
+    else {
+        // about to expire
+        await validateAccessToken({
+            token: tokenObject,
+            userId,
+        });
+    }
+};
+/* end_public_function */
+
+/**
+ * Helper function to renew access token using the accessTokenHandler
+ * Handles error catching and logging
+ *
+ * @param useScheduledTask - Whether to wrap renewal in scheduleTask (for token expired case)
+ * @category private
+ */
+const renewTokenWithHandler = async ({ useScheduledTask = false, }) => {
+    const client = getActiveClient();
+    if (!client.userId || !client.accessTokenHandler) {
+        return;
+    }
+    try {
+        const newToken = await client.accessTokenHandler.onTokenRenew(client.userId);
+        if (useScheduledTask) {
+            scheduleTask(() => renewWithAccessToken(newToken));
+        }
+        else {
+            renewWithAccessToken(newToken);
+        }
+    }
+    catch (error) {
+        client.log('Proactive token renewal failed, will retry when token expires', error);
+        // Will fallback to expired token flow
+    }
+};
+
 const ABOUT_TO_EXPIRE_THRESHOLD = 80 / 100;
 const COMPENSATED_DELAY = 5 * MINUTE;
 /*
@@ -9339,10 +9605,11 @@ const isAboutToExpire = (params) => {
  *
  * @category private
  */
-const accessTokenExpiryWatcher = (sessionHandler) => {
-    const interval = setInterval(() => {
+const accessTokenExpiryWatcher = () => {
+    const interval = setInterval(async () => {
         const client = getActiveClient();
-        if (!client.token)
+        const { sessionHandler, accessTokenHandler, loginType } = client;
+        if (!client.token || !client.userId)
             return;
         const { issuedAt, expiresAt } = client.token;
         if (isExpired(expiresAt)) {
@@ -9353,18 +9620,38 @@ const accessTokenExpiryWatcher = (sessionHandler) => {
              */
             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
+             * Check loginType to determine which handler to use:
+             * - 'accessToken' = use accessTokenHandler
+             * - 'userId' = use sessionHandler
              */
-            scheduleTask(() => sessionHandler.sessionWillRenewAccessToken(renewal()));
+            if (loginType === 'accessToken' && accessTokenHandler) {
+                await renewTokenWithHandler({ useScheduledTask: false });
+            }
+            else if (loginType === 'userId' && sessionHandler) {
+                /*
+                 * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Automatically-initiate-renewal-flow
+                 *
+                 * Why scheduled 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());
+            /*
+             * Check loginType to determine which handler to use for proactive renewal:
+             * - 'accessToken' = use accessTokenHandler
+             * - 'userId' = use sessionHandler
+             */
+            if (loginType === 'accessToken' && accessTokenHandler) {
+                await renewTokenWithHandler({ useScheduledTask: false });
+            }
+            else if (loginType === 'userId' && sessionHandler) {
+                sessionHandler.sessionWillRenewAccessToken(renewal());
+            }
         }
     }, ACCESS_TOKEN_WATCHER_INTERVAL);
     return () => clearInterval(interval);
@@ -9918,6 +10205,7 @@ const secureLogout = async () => {
 };
 /* end_public_function */
 
+/* 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
@@ -9927,38 +10215,6 @@ let subscriptions$1 = [];
 async function runMqtt() {
     await modifyMqttConnection();
 }
-const isSameUserId = (token) => {
-    var _a;
-    const client = getActiveClient();
-    const decoded = jwtDecode__default["default"](token);
-    return ((_a = decoded === null || decoded === void 0 ? void 0 : decoded.user) === null || _a === void 0 ? void 0 : _a.publicUserId) === client.userId;
-};
-const validateAccessToken = async ({ token, userId }) => {
-    const client = getActiveClient();
-    // begin establishing session
-    setSessionState("establishing" /* Amity.SessionStates.ESTABLISHING */);
-    const { data: { users }, } = await client.http.get(`/api/v3/users/${userId}`, {
-        headers: {
-            Authorization: `Bearer ${token.accessToken}`,
-        },
-    });
-    const user = users.find((u) => u.userId === userId);
-    client.http.defaults.headers.common.Authorization = `Bearer ${token.accessToken}`;
-    client.http.defaults.metadata = {
-        tokenExpiry: token.expiresAt,
-        isGlobalBanned: false,
-        isUserDeleted: false,
-    };
-    client.upload.defaults.headers.common.Authorization = `Bearer ${token.accessToken}`;
-    client.upload.defaults.metadata = {
-        tokenExpiry: token.expiresAt,
-        isGlobalBanned: false,
-        isUserDeleted: false,
-    };
-    client.token = token;
-    setSessionState("established" /* Amity.SessionStates.ESTABLISHED */);
-    return user;
-};
 /* begin_public_function
   id: client.resumeSession
 */
@@ -10007,6 +10263,7 @@ const resumeSession = async (params, sessionHandler, config) => {
         }
     }
     try {
+        setSessionState("establishing" /* Amity.SessionStates.ESTABLISHING */);
         const user = await validateAccessToken(params);
         if (user == null) {
             throw new ASCError(`${params.userId} has not been found`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
@@ -10113,13 +10370,13 @@ class GlobalFileAccessType {
     }
 }
 _GlobalFileAccessType_fileAccessType = new WeakMap();
-let instance;
+let instance$1;
 var GlobalFileAccessType$1 = {
     getInstance: () => {
-        if (!instance) {
-            instance = new GlobalFileAccessType();
+        if (!instance$1) {
+            instance$1 = new GlobalFileAccessType();
         }
-        return instance;
+        return instance$1;
     },
 };
 
@@ -10334,11 +10591,12 @@ const loginAsBot = async (params) => {
         [user] = users;
         client.userId = user.userId;
         client.sessionHandler = params.sessionHandler;
+        client.loginType = 'userId';
         /*
          * Cannot push to subscriptions as watcher needs to continue working even if
          * token expires
          */
-        unsubWatcher = client.accessTokenExpiryWatcher(params.sessionHandler);
+        unsubWatcher = client.accessTokenExpiryWatcher();
         setCurrentUser({ user, userType });
     }
     catch (error) {
@@ -10367,6 +10625,53 @@ const loginAsBot = async (params) => {
 };
 /* end_public_function */
 
+/* begin_public_function
+  id: client.setAccessTokenHandler
+*/
+/**
+ * ```js
+ * import { setAccessTokenHandler } from '@amityco/ts-sdk'
+ *
+ * const tokenHandler = {
+ *   async onTokenRenew() {
+ *     const response = await fetch('https://your-backend.com/api/refresh-token', {
+ *       method: 'POST',
+ *       credentials: 'include',
+ *     });
+ *     const data = await response.json();
+ *     return data.accessToken;
+ *   }
+ * };
+ *
+ * setAccessTokenHandler(tokenHandler);
+ * ```
+ *
+ * Registers a custom handler for managing access token renewal and expiration events.
+ * This enables automatic token refresh and graceful handling of expired tokens.
+ *
+ * Must be called before loginWithAccessToken() to ensure the handler is available
+ * when token expiry is detected.
+ *
+ * @param accessTokenHandler Handler object implementing token renewal callbacks
+ * @returns void
+ *
+ * @category Client API
+ */
+const setAccessTokenHandler = (accessTokenHandler) => {
+    const client = getActiveClient();
+    client.log('client/api/setAccessTokenHandler', {
+        apiKey: client.apiKey,
+        sessionState: client.sessionState,
+        hasOnTokenRenew: typeof (accessTokenHandler === null || accessTokenHandler === void 0 ? void 0 : accessTokenHandler.onTokenRenew) === 'function',
+    });
+    // Validate handler has required method
+    if (!accessTokenHandler || typeof accessTokenHandler.onTokenRenew !== 'function') {
+        throw new Error('AccessTokenHandler must implement onTokenRenew() method');
+    }
+    // Register the handler
+    client.accessTokenHandler = accessTokenHandler;
+};
+
 /**
  * ```js
  * import { onChannelMarkerFetched } from '@amityco/ts-sdk-react-native'
@@ -10726,6 +11031,7 @@ var index$r = /*#__PURE__*/Object.freeze({
     setActiveUser: setActiveUser,
     createClient: createClient,
     login: login,
+    loginWithAccessToken: loginWithAccessToken,
     logout: logout,
     secureLogout: secureLogout,
     resumeSession: resumeSession,
@@ -10747,6 +11053,7 @@ var index$r = /*#__PURE__*/Object.freeze({
     getCurrentUser: getCurrentUser,
     getCurrentUserType: getCurrentUserType,
     setCurrentUserType: setCurrentUserType,
+    setAccessTokenHandler: setAccessTokenHandler,
     onConnectionError: onConnectionError,
     onClientDisconnected: onClientDisconnected,
     onClientBanned: onClientBanned,
@@ -17104,33 +17411,186 @@ removeReaction.optimistically = (referenceType, referenceId, reactionName) => {
     return !((_d = reaction === null || reaction === void 0 ? void 0 : reaction.myReactions) === null || _d === void 0 ? void 0 : _d.includes(reactionName));
 };
 
-const updateStreamReferences = (streams, streamId, postId) => {
-    if (!streamId)
-        return streams;
-    return streams.map(stream => stream.streamId === streamId
-        ? Object.assign(Object.assign({}, stream), { referenceType: 'post', referenceId: postId, postId }) : stream);
-};
-const preparePostPayload = (payload) => {
-    const { posts: postsData, postChildren, videoStreamings } = payload, postPayload = __rest(payload, ["posts", "postChildren", "videoStreamings"]);
-    // Unpack community payload by mapping payload field to postSetting value.
-    const communitiesWithPostSetting = addPostSetting({ communities: postPayload.communities });
-    // map users with community
-    const mappedCommunityUsers = postPayload.communityUsers.map(communityUser => {
-        const user = postPayload.users.find(user => user.userId === communityUser.userId);
-        return Object.assign(Object.assign({}, communityUser), { user });
-    });
-    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
-    let mappedNewStream = [];
+class ResetTask {
+    constructor(postId, latestCreatedAt, serverCommentCount) {
+        this.postId = postId;
+        this.latestCreatedAt = latestCreatedAt;
+        this.serverCommentCount = serverCommentCount;
+    }
+}
+
+// Task to track comment creation
+class CreateTask {
+    constructor(postId, commentId, createdAt) {
+        this.postId = postId;
+        this.commentId = commentId;
+        this.createdAt = createdAt;
+    }
+}
+
+// Task to track comment deletion
+class DeleteTask {
+    constructor(postId, commentId) {
+        this.postId = postId;
+        this.commentId = commentId;
+    }
+}
+
+class CommentChange {
+    constructor(latestCreatedAt, serverCommentCount) {
+        this.latestCommentCreatedAt = latestCreatedAt;
+        this.serverCommentCount = serverCommentCount;
+        this.createdCommentIds = new Set();
+        this.deletedCommentIds = new Set();
+    }
+}
+
+class PostCommentCountEngine {
+    constructor() {
+        this.isProcessing = false;
+        this.tasks = [];
+        this.commentChangeTracker = new Map();
+    }
+    queueCommentChangeTask(task) {
+        this.tasks.push(task);
+        if (!this.isProcessing) {
+            this.processCommentChangeTask();
+        }
+    }
+    processCommentChangeTask() {
+        if (this.isProcessing) {
+            return;
+        }
+        this.isProcessing = true;
+        if (this.tasks.length === 0) {
+            this.isProcessing = false;
+            return;
+        }
+        // Process in capped batches, coalescing updates
+        const batch = this.tasks.splice(0, PostCommentCountEngine.BATCH_SIZE);
+        const modifiedPostIds = new Set();
+        batch.forEach(task => {
+            let modified = false;
+            if (task instanceof ResetTask) {
+                modified = this.processResetTaskInternal(task);
+            }
+            else if (task instanceof CreateTask) {
+                modified = this.processCreateTaskInternal(task);
+            }
+            else if (task instanceof DeleteTask) {
+                modified = this.processDeleteTaskInternal(task);
+            }
+            if (modified) {
+                modifiedPostIds.add(task.postId);
+            }
+        });
+        // Publish one update per modified post
+        modifiedPostIds.forEach(postId => {
+            const count = this.computeCommentCount(postId);
+            PostCommentCountEngine.publishUpdate(postId, count);
+        });
+        this.isProcessing = false;
+        // Recurse if more tasks remain
+        if (this.tasks.length > 0) {
+            this.processCommentChangeTask();
+        }
+    }
+    processResetTaskInternal(task) {
+        // Always creates/overwrites tracker
+        this.commentChangeTracker.set(task.postId, new CommentChange(task.latestCreatedAt, task.serverCommentCount));
+        return true;
+    }
+    processCreateTaskInternal(task) {
+        const tracker = this.commentChangeTracker.get(task.postId);
+        if (!tracker)
+            return false; // No tracker, skip
+        if (tracker.createdCommentIds.has(task.commentId))
+            return false; // Deduplication
+        if (task.createdAt <= tracker.latestCommentCreatedAt)
+            return false; // Timestamp filtering
+        tracker.createdCommentIds.add(task.commentId);
+        return true;
+    }
+    processDeleteTaskInternal(task) {
+        const tracker = this.commentChangeTracker.get(task.postId);
+        if (!tracker)
+            return false; // No tracker, skip
+        if (tracker.deletedCommentIds.has(task.commentId))
+            return false; // Deduplication
+        tracker.deletedCommentIds.add(task.commentId);
+        return true;
+    }
+    computeCommentCount(postId) {
+        const tracker = this.commentChangeTracker.get(postId);
+        if (!tracker)
+            return 0;
+        const count = tracker.serverCommentCount + tracker.createdCommentIds.size - tracker.deletedCommentIds.size;
+        return Math.max(0, count);
+    }
+    static publishUpdate(postId, newCount) {
+        var _a;
+        const queryKey = ['post', 'get', postId];
+        mergeInCache(queryKey, {
+            localCommentCount: newCount,
+        });
+        const postPayload = (_a = pullFromCache(queryKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!postPayload)
+            return;
+        fireEvent('local.post.updated', {
+            posts: [postPayload],
+        });
+    }
+}
+PostCommentCountEngine.BATCH_SIZE = 50;
+let instance;
+var PostCommentCountEngine$1 = {
+    getInstance: () => {
+        if (!instance) {
+            instance = new PostCommentCountEngine();
+        }
+        return instance;
+    },
+};
+
+const updateStreamReferences = (streams, streamId, postId) => {
+    if (!streamId)
+        return streams;
+    return streams.map(stream => stream.streamId === streamId
+        ? Object.assign(Object.assign({}, stream), { referenceType: 'post', referenceId: postId, postId }) : stream);
+};
+const preparePostPayload = (payload) => {
+    const { posts: postsData, postChildren, videoStreamings } = payload, postPayload = __rest(payload, ["posts", "postChildren", "videoStreamings"]);
+    // Unpack community payload by mapping payload field to postSetting value.
+    const communitiesWithPostSetting = addPostSetting({ communities: postPayload.communities });
+    // map users with community
+    const mappedCommunityUsers = postPayload.communityUsers.map(communityUser => {
+        const user = postPayload.users.find(user => user.userId === communityUser.userId);
+        return Object.assign(Object.assign({}, communityUser), { user });
+    });
+    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
+    let mappedNewStream = [];
     // feed type
     const posts = postsData.map(post => {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const feedType = (_a = postPayload.feeds.find(feed => feed.feedId === post.feedId)) === null || _a === void 0 ? void 0 : _a.feedType;
         const childPosts = payload.postChildren.filter(children => children.parentPostId === post.postId);
         if (childPosts.length > 0 && isAmityLivestreamPost(childPosts[0])) {
             mappedNewStream = updateStreamReferences(videoStreamings, (_b = childPosts[0].data) === null || _b === void 0 ? void 0 : _b.streamId, post.postId);
         }
+        // --- Computed Comment Count: ResetTask integration ---
+        // Find all comments for this post (referenceType === 'post' && referenceId === postId)
+        const allComments = (payload.comments || []).filter((c) => c.referenceType === 'post' && c.referenceId === post.postId);
+        // Compute latestCreatedAt
+        const latestCreatedAt = allComments.length === 0
+            ? new Date().toISOString()
+            : allComments
+                .map(c => c.createdAt)
+                .sort()
+                .at(-1);
+        // Queue ResetTask for this post
+        PostCommentCountEngine$1.getInstance().queueCommentChangeTask(new ResetTask(post.postId, latestCreatedAt, (_c = post.commentsCount) !== null && _c !== void 0 ? _c : 0));
         return Object.assign(Object.assign({}, post), { childPosts,
-            feedType });
+            feedType, localCommentCount: (_d = post.localCommentCount) !== null && _d !== void 0 ? _d : post.commentsCount });
     });
     return Object.assign(Object.assign({}, postPayload), { postChildren, videoStreamings: mappedNewStream, posts, communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
 };
@@ -17232,14 +17692,12 @@ const createLocalPostEventSubscriber = (event, callback) => {
             callback(payload.posts[0]);
         }
         else {
-            const data = preparePostPayload(payload);
-            const { communities } = data;
-            ingestInCache(data);
+            const { communities } = payload;
             if ((communities === null || communities === void 0 ? void 0 : communities[0]) && !['local.post.updated'].includes(event)) {
                 fireEvent('community.updated', {
                     communities,
                     categories: [],
-                    communityUsers: data.communityUsers,
+                    communityUsers: payload.communityUsers,
                     feeds: [],
                     files: [],
                     users: [],
@@ -17510,7 +17968,7 @@ const createCommentEventSubscriber = (event, callback) => {
 const createLocalCommentEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         if (!client.cache) {
             // TODO: here we are missing specific properties here!
             callback(LinkedObject.comment(payload.comments[0]));
@@ -17550,7 +18008,13 @@ const createLocalCommentEventSubscriber = (event, callback) => {
                             }
                         }
                     }
-                    const queries = (_a = queryCache(['comment', 'query'])) === null || _a === void 0 ? void 0 : _a.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
+                    else {
+                        const postCacheKey = ['post', 'get', comments[0].referenceId];
+                        const postCache = (_a = pullFromCache(postCacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                        postCache === null || postCache === void 0 ? void 0 : postCache.comments.push((_b = comments[0]) === null || _b === void 0 ? void 0 : _b.commentId);
+                        pushToCache(postCacheKey, postCache);
+                    }
+                    const queries = (_c = queryCache(['comment', 'query'])) === null || _c === void 0 ? void 0 : _c.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
                     queries === null || queries === void 0 ? void 0 : queries.map(({ key, data }) => upsertInCache(key, data, { cachedAt: -1 }));
                 }
                 if (['local.comment.deleted'].includes(event)) {
@@ -17582,7 +18046,13 @@ const createLocalCommentEventSubscriber = (event, callback) => {
                             }
                         }
                     }
-                    const queries = (_b = queryCache(['comment', 'query'])) === null || _b === void 0 ? void 0 : _b.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
+                    else {
+                        const postCacheKey = ['post', 'get', comments[0].referenceId];
+                        const postCache = (_d = pullFromCache(postCacheKey)) === null || _d === void 0 ? void 0 : _d.data;
+                        const updatedPost = Object.assign(Object.assign({}, postCache), { comments: postCache === null || postCache === void 0 ? void 0 : postCache.comments.filter(commentId => { var _a; return commentId !== ((_a = comments[0]) === null || _a === void 0 ? void 0 : _a.commentId); }) });
+                        pushToCache(postCacheKey, updatedPost);
+                    }
+                    const queries = (_e = queryCache(['comment', 'query'])) === null || _e === void 0 ? void 0 : _e.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
                     queries === null || queries === void 0 ? void 0 : queries.map(({ key, data }) => upsertInCache(key, data, { cachedAt: -1 }));
                 }
                 callback(LinkedObject.comment(comment.data));
@@ -25292,7 +25762,6 @@ getCommentByIds.locally = (commentIds) => {
  * @async
  */
 const createComment = async (bundle) => {
-    var _a;
     const client = getActiveClient();
     client.log('comment/createComment', bundle);
     const { data } = await client.http.post('/api/v3/comments', bundle);
@@ -25304,22 +25773,7 @@ const createComment = async (bundle) => {
     if (client.cache)
         ingestInCache(data, { cachedAt });
     if (['post', 'content'].includes(bundle.referenceType)) {
-        const post = (_a = pullFromCache(['post', 'get', bundle.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
-        if (post) {
-            post.commentsCount += 1;
-            fireEvent('local.post.updated', {
-                posts: [post],
-                categories: [],
-                comments: [],
-                communities: [],
-                communityUsers: data.communityUsers,
-                feeds: [],
-                files: data.files,
-                postChildren: [],
-                users: data.users,
-                videoStreamings: [],
-            });
-        }
+        PostCommentCountEngine$1.getInstance().queueCommentChangeTask(new CreateTask(bundle.referenceId, comments[0].commentId, data.comments[0].createdAt));
     }
     else if (bundle.referenceType === 'story') {
         const storyIndex = pullFromCache([
@@ -25478,7 +25932,7 @@ getStoryByStoryId$1.locally = (storyId) => {
  * @async
  */
 const deleteComment = async (commentId, permanent = false) => {
-    var _a;
+    var _a, _b;
     const client = getActiveClient();
     const comment = await getComment$2(commentId);
     // API-FIX: This endpoint has not been implemented yet.
@@ -25511,26 +25965,14 @@ const deleteComment = async (commentId, permanent = false) => {
     else {
         const post = (_a = pullFromCache(['post', 'get', comment.data.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
         if (post) {
-            let removeCount;
-            if (!deleted.parentId) {
-                // NOTE: delete the parent comment will remove all children comments
-                removeCount = deleted.childrenNumber + 1;
+            const engine = PostCommentCountEngine$1.getInstance();
+            engine.queueCommentChangeTask(new DeleteTask(post.postId, commentId));
+            if (!deleted.parentId && ((_b = deleted.children) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                // NOTE: delete the parent comment will also remove all children comments
+                deleted.children.forEach((childCommentId) => {
+                    engine.queueCommentChangeTask(new DeleteTask(post.postId, childCommentId));
+                });
             }
-            else
-                removeCount = 1;
-            post.commentsCount -= removeCount;
-            fireEvent('local.post.updated', {
-                posts: [post],
-                categories: [],
-                comments: [],
-                communities: [],
-                communityUsers: [],
-                feeds: [],
-                files: [],
-                postChildren: [],
-                users: [],
-                videoStreamings: [],
-            });
         }
     }
     fireEvent('local.comment.deleted', {
@@ -26096,47 +26538,6 @@ var index$d = /*#__PURE__*/Object.freeze({
     getComments: getComments
 });
 
-const getPost$1 = async (postId) => {
-    const client = getActiveClient();
-    client.log('post/getPost', postId);
-    isInTombstone('post', postId);
-    let payload;
-    try {
-        // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/posts/${encodeURIComponent(postId)}`);
-        payload = response.data;
-    }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('post', postId);
-        }
-        throw error;
-    }
-    const data = prepareMembershipPayload(payload, 'communityUsers');
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { posts } = data;
-    const result = posts.find(post => post.postId === postId);
-    return {
-        data: result,
-        cachedAt,
-    };
-};
-getPost$1.locally = (postId) => {
-    const client = getActiveClient();
-    client.log('post/getPost.locally', postId);
-    if (!client.cache)
-        return;
-    const cached = pullFromCache(['post', 'get', postId]);
-    if (!cached)
-        return;
-    return {
-        data: cached.data,
-        cachedAt: cached.cachedAt,
-    };
-};
-
 /**
  * ```js
  * import { onLocalPostDeleted } from '@amityco/ts-sdk-react-native'
@@ -26235,7 +26636,6 @@ const commentEventHandler$1 = (callback, eventHandler, cacheKey) => {
         const currentCollection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
         if (!currentCollection || !currentCollection.data.includes(comment.referenceId))
             return;
-        await getPost$1(comment.referenceId);
         callback(comment);
     });
 };
@@ -26243,12 +26643,8 @@ const generateCommentSubscriptions$1 = (cacheKey) => {
     const eventHandlers = [
         onCommentCreated,
         onCommentDeleted,
-        onCommentReactionAdded,
-        onCommentReactionRemoved,
         onCommentCreatedLocal,
         onCommentDeleteLocal,
-        onLocalCommentReactionAdded,
-        onLocalCommentReactionRemoved,
     ];
     return eventHandlers.map(handler => ({
         fn: convertEventPayload((callback) => commentEventHandler$1(callback, handler, cacheKey), 'referenceId', 'post'),
@@ -26612,6 +27008,47 @@ class UserFeedQueryStreamController extends QueryStreamController {
     }
 }
 
+const getPost$1 = async (postId) => {
+    const client = getActiveClient();
+    client.log('post/getPost', postId);
+    isInTombstone('post', postId);
+    let payload;
+    try {
+        // API-FIX: endpoint should not be /list, parameters should be querystring.
+        const response = await client.http.get(`/api/v3/posts/${encodeURIComponent(postId)}`);
+        payload = response.data;
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('post', postId);
+        }
+        throw error;
+    }
+    const data = prepareMembershipPayload(payload, 'communityUsers');
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    const { posts } = data;
+    const result = posts.find(post => post.postId === postId);
+    return {
+        data: result,
+        cachedAt,
+    };
+};
+getPost$1.locally = (postId) => {
+    const client = getActiveClient();
+    client.log('post/getPost.locally', postId);
+    if (!client.cache)
+        return;
+    const cached = pullFromCache(['post', 'get', postId]);
+    if (!cached)
+        return;
+    return {
+        data: cached.data,
+        cachedAt: cached.cachedAt,
+    };
+};
+
 class UserFeedLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
         const queryStreamId = hash__default["default"](query);
@@ -26745,12 +27182,240 @@ const getUserFeed = (params, callback, config) => {
 };
 /* end_public_function */
 
+class CommunityFeedPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted, communityId } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted", "communityId"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v5/posts`, {
+            params: Object.assign(Object.assign({}, params), { targetId: communityId, targetType: 'community', isDeleted: inferIsDeleted(includeDeleted), matchingOnlyParentPost: true, options }),
+        });
+        return queryResponse;
+    }
+}
+
+class CommunityFeedQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = await this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.posts.map(getResolver('post')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const posts = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...posts, ...response.posts.map(getResolver('post'))])] }));
+        }
+    }
+    reactor(action) {
+        return (post) => {
+            var _a, _b;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (action === EnumPostActions.OnPostDeleted) {
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            if (post.parentPostId && post.isDeleted) {
+                const parentPost = (_b = pullFromCache([
+                    'post',
+                    'get',
+                    post.parentPostId,
+                ])) === null || _b === void 0 ? void 0 : _b.data;
+                if (!parentPost)
+                    return;
+                parentPost.children = parentPost.children.filter(childId => childId !== post.postId);
+                pushToCache(['post', 'get', parentPost.postId], parentPost);
+            }
+            if (action === EnumPostActions.OnPostDeclined) {
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            if (action === EnumPostActions.OnPostCreated || action === EnumPostActions.OnPostApproved) {
+                collection.data = [...new Set([post.postId, ...collection.data])];
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+const commentEventHandler = (callback, eventHandler, cacheKey, resolveId) => {
+    return eventHandler(async (comment) => {
+        var _a;
+        const currentCollection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!currentCollection ||
+            !currentCollection.data.includes(resolveId ? resolveId(comment.referenceId) : comment.referenceId))
+            return;
+        callback(comment);
+    });
+};
+const generateCommentSubscriptions = ({ cacheKey, resolveId, }) => {
+    const eventHandlers = [
+        onCommentCreated,
+        onCommentDeleted,
+        onCommentCreatedLocal,
+        onCommentDeleteLocal,
+    ];
+    return eventHandlers.map(handler => ({
+        fn: convertEventPayload((callback) => commentEventHandler(callback, handler, cacheKey, resolveId), 'referenceId', 'post'),
+        action: EnumPostActions.OnPostUpdated,
+    }));
+};
+const getPostSubscription = (cacheKey) => {
+    return [
+        { fn: onPostCreated, action: EnumPostActions.OnPostCreated },
+        { fn: onPostUpdated, action: EnumPostActions.OnPostUpdated },
+        { fn: onPostUpdatedLocal, action: EnumPostActions.OnPostUpdated },
+        { fn: onPostDeleted, action: EnumPostActions.OnPostDeleted },
+        { fn: onPostFlagged, action: EnumPostActions.OnPostFlagged },
+        { fn: onPostUnflagged, action: EnumPostActions.OnPostUnflagged },
+        { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
+        { fn: onPostDeclined, action: EnumPostActions.OnPostDeclined },
+        { fn: onPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
+        { fn: onPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+        { fn: onLocalPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
+        { fn: onLocalPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+        { fn: onLocalPostDeleted, action: EnumPostActions.OnPostDeleted },
+        ...generateCommentSubscriptions({ cacheKey }),
+    ];
+};
+const resolvePostIdsFromRooms = (rooms, posts) => {
+    var _a;
+    return ((_a = rooms
+        .map(room => {
+        const post = posts.find(post => post.postId === room.referenceId);
+        return post ? getResolver('post')({ postId: post === null || post === void 0 ? void 0 : post.postId }) : undefined;
+    })
+        .filter(isNonNullable)) !== null && _a !== void 0 ? _a : []);
+};
+
+class CommunityFeedLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['communityFeed', 'collection', queryStreamId];
+        const paginationController = new CommunityFeedPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new CommunityFeedQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), preparePostPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE(getPostSubscription(this.cacheKey));
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = ((_b = collection.data
+            .map(id => pullFromCache(['post', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.post);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+}
+
+/* begin_public_function
+  id: feed.query.community_feed
+*/
+/**
+ * ```js
+ * import { FeedRepository } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsubscribe = FeedRepository.getCommunityFeed({
+ *   communityId: 'community-id',
+ *   sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated',
+ *   includeDeleted?: boolean,
+ *   feedType?: 'reviewing' | 'published' | 'declined',
+ *   tags?: string[],
+ *   includeMixedStructure?: boolean,
+ *   limit?: number,
+ * }, response => processResponse(response))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given community feed.
+ *
+ * @param params - Parameters for querying the community feed:
+ *   @param params.communityId The ID of the community (required)
+ *   @param params.sortBy The sorting order of the feed (optional)
+ *   @param params.includeDeleted Whether to include deleted posts (optional)
+ *   @param params.feedType The type of the feed: 'reviewing', 'published', or 'declined' (optional)
+ *   @param params.tags Array of tags to filter posts (optional)
+ *   @param params.includeMixedStructure Whether to include mixed structure posts (optional)
+ *   @param params.limit The maximum number of posts to retrieve (optional)
+ * @param callback The function to call when new data are available
+ * @param config Additional live collection configuration (optional)
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the feed
+ *
+ * @category Posts Live Collection
+ */
+const getCommunityFeed = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getCommunityFeed(tmpid: ${timestamp}) > listen`);
+    const communityFeedLiveCollection = new CommunityFeedLiveCollectionController(params, callback);
+    const disposers = communityFeedLiveCollection.startSubscription();
+    const cacheKey = communityFeedLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getCommunityFeed(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
 var index$c = /*#__PURE__*/Object.freeze({
     __proto__: null,
     queryGlobalFeed: queryGlobalFeed,
     getCustomRankingGlobalFeed: getCustomRankingGlobalFeed,
     getGlobalFeed: getGlobalFeed,
-    getUserFeed: getUserFeed
+    getUserFeed: getUserFeed,
+    getCommunityFeed: getCommunityFeed
 });
 
 /* begin_public_function
@@ -27496,61 +28161,6 @@ class PostQueryStreamController extends QueryStreamController {
     }
 }
 
-const commentEventHandler = (callback, eventHandler, cacheKey, resolveId) => {
-    return eventHandler(async (comment) => {
-        var _a;
-        const currentCollection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (!currentCollection ||
-            !currentCollection.data.includes(resolveId ? resolveId(comment.referenceId) : comment.referenceId))
-            return;
-        await getPost$1(comment.referenceId);
-        callback(comment);
-    });
-};
-const generateCommentSubscriptions = ({ cacheKey, resolveId, }) => {
-    const eventHandlers = [
-        onCommentCreated,
-        onCommentDeleted,
-        onCommentReactionAdded,
-        onCommentReactionRemoved,
-        onCommentCreatedLocal,
-        onCommentDeleteLocal,
-        onLocalCommentReactionAdded,
-        onLocalCommentReactionRemoved,
-    ];
-    return eventHandlers.map(handler => ({
-        fn: convertEventPayload((callback) => commentEventHandler(callback, handler, cacheKey, resolveId), 'referenceId', 'post'),
-        action: EnumPostActions.OnPostUpdated,
-    }));
-};
-const getPostSubscription = (cacheKey) => {
-    return [
-        { fn: onPostCreated, action: EnumPostActions.OnPostCreated },
-        { fn: onPostUpdated, action: EnumPostActions.OnPostUpdated },
-        { fn: onPostUpdatedLocal, action: EnumPostActions.OnPostUpdated },
-        { fn: onPostDeleted, action: EnumPostActions.OnPostDeleted },
-        { fn: onPostFlagged, action: EnumPostActions.OnPostFlagged },
-        { fn: onPostUnflagged, action: EnumPostActions.OnPostUnflagged },
-        { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
-        { fn: onPostDeclined, action: EnumPostActions.OnPostDeclined },
-        { fn: onPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
-        { fn: onPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
-        { fn: onLocalPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
-        { fn: onLocalPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
-        { fn: onLocalPostDeleted, action: EnumPostActions.OnPostDeleted },
-        ...generateCommentSubscriptions({ cacheKey }),
-    ];
-};
-const resolvePostIdsFromRooms = (rooms, posts) => {
-    var _a;
-    return ((_a = rooms
-        .map(room => {
-        const post = posts.find(post => post.postId === room.referenceId);
-        return post ? getResolver('post')({ postId: post === null || post === void 0 ? void 0 : post.postId }) : undefined;
-    })
-        .filter(isNonNullable)) !== null && _a !== void 0 ? _a : []);
-};
-
 class PostLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
         const queryStreamId = hash__default["default"](query);