@amityco/ts-sdk 6.20.1 → 6.21.0

package/dist/index.cjs.js

@@ -98,8 +98,8 @@ const PostContentType = Object.freeze({
 
 function getVersion() {
     try {
-        // the string ''v6.20.1-cjs'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v6.20.1-cjs';
+        // the string ''v6.21.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v6.21.0-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -504,7 +504,7 @@ const idResolvers = {
     user: ({ userId }) => userId,
     file: ({ fileId }) => fileId,
     role: ({ roleId }) => roleId,
-    channel: ({ channelId }) => channelId,
+    channel: ({ channelInternalId }) => channelInternalId,
     subChannel: ({ subChannelId }) => subChannelId,
     channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
     message: ({ messageId }) => messageId,
@@ -1067,7 +1067,7 @@ const filterByChannelMembership = (collection, membership, userId) => {
             return true;
         // get resolver for the channel by user
         const channelUserCacheKey = getResolver('channelUsers')({
-            channelId: c.channelId,
+            channelId: c.channelPublicId,
             userId,
         });
         const channelUser = (_a = pullFromCache([
@@ -1308,6 +1308,9 @@ const WS_EVENTS = [
     'sessionStateChange',
     // for internal use by accessTokenExpiryWatcher
     'tokenExpired',
+    'v3.video-streaming.didRecord',
+    'v3.video-streaming.didStart',
+    'v3.video-streaming.didStop',
 ];
 const MQTT_EVENTS = [
     'connect',
@@ -5647,6 +5650,16 @@ const messageLinkedObject = (message) => {
         } });
 };
 
+const reactorLinkedObject = (reactor) => {
+    return Object.assign(Object.assign({}, reactor), { get user() {
+            var _a;
+            const user = (_a = pullFromCache(['user', 'get', reactor.userId])) === null || _a === void 0 ? void 0 : _a.data;
+            if (!user)
+                return undefined;
+            return userLinkedObject(user);
+        } });
+};
+
 const LinkedObject = {
     comment: commentLinkedObject,
     post: postLinkedObject,
@@ -5655,6 +5668,7 @@ const LinkedObject = {
     story: storyLinkedObject,
     storyTarget: storyTargetLinkedObject,
     message: messageLinkedObject,
+    reactor: reactorLinkedObject,
 };
 
 const getChannelMessagePreviewWithUser = (channel) => {
@@ -5976,7 +5990,8 @@ const getSubChannelsUnreadCount = (channel, marker) => {
     var _a, _b, _c, _d, _e;
     const client = getActiveClient();
     if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        return (_b = (_a = getUnreadInfoCached$1(channel.channelId)) === null || _a === void 0 ? void 0 : _a.unreadCount) !== null && _b !== void 0 ? _b : 0;
+        // Marker service API uses channelInternalId as channelId
+        return (_b = (_a = getUnreadInfoCached$1(channel.channelInternalId)) === null || _a === void 0 ? void 0 : _a.unreadCount) !== null && _b !== void 0 ? _b : 0;
     }
     if (marker === null || marker === void 0 ? void 0 : marker.isDeleted) {
         // NOTE: This is a temporary solution to handle the channel marker when the user is forced to
@@ -5984,7 +5999,7 @@ const getSubChannelsUnreadCount = (channel, marker) => {
         // from a channel or the channel is deleted the channel's unread count will reset to zero
         return 0;
     }
-    return (_e = (_c = marker === null || marker === void 0 ? void 0 : marker.unreadCount) !== null && _c !== void 0 ? _c : (_d = getCachedMarker$1(channel.channelId)) === null || _d === void 0 ? void 0 : _d.unreadCount) !== null && _e !== void 0 ? _e : 0;
+    return (_e = (_c = marker === null || marker === void 0 ? void 0 : marker.unreadCount) !== null && _c !== void 0 ? _c : (_d = getCachedMarker$1(channel.channelInternalId)) === null || _d === void 0 ? void 0 : _d.unreadCount) !== null && _e !== void 0 ? _e : 0;
 };
 
 const getCachedMarker = (entityId) => {
@@ -6015,11 +6030,11 @@ const getChannelIsMentioned = (channel, marker) => {
     var _a, _b, _c, _d;
     const client = getActiveClient();
     if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        return (_b = (_a = getUnreadInfoCached(channel.channelId)) === null || _a === void 0 ? void 0 : _a.isMentioned) !== null && _b !== void 0 ? _b : false;
+        return (_b = (_a = getUnreadInfoCached(channel.channelPublicId)) === null || _a === void 0 ? void 0 : _a.isMentioned) !== null && _b !== void 0 ? _b : false;
     }
     return (marker === null || marker === void 0 ? void 0 : marker.hasMentioned) !== undefined
         ? marker === null || marker === void 0 ? void 0 : marker.hasMentioned
-        : (_d = (_c = getCachedMarker(channel.channelId)) === null || _c === void 0 ? void 0 : _c.hasMentioned) !== null && _d !== void 0 ? _d : false;
+        : (_d = (_c = getCachedMarker(channel.channelPublicId)) === null || _c === void 0 ? void 0 : _c.hasMentioned) !== null && _d !== void 0 ? _d : false;
 };
 
 const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
@@ -6046,7 +6061,7 @@ function convertFromRaw$2(channel, options = { isMessagePreviewUpdated: true })
         },
         get subChannelsUnreadCount() {
             return getSubChannelsUnreadCount(channel);
-        } }, channel), { defaultSubChannelId: channel._id, isUnreadCountSupport: isUnreadCountSupport$2(channel), messagePreviewId });
+        } }, channel), { defaultSubChannelId: channel.channelInternalId, isUnreadCountSupport: isUnreadCountSupport$2(channel), messagePreviewId });
 }
 const preUpdateChannelCache = (rawPayload, options = { isMessagePreviewUpdated: true }) => {
     ingestInCache({
@@ -6065,7 +6080,7 @@ const prepareChannelPayload = async (rawPayload, options = { isMessagePreviewUpd
     const markerIds = rawPayload.channels
         // filter channel by type. Only conversation, community and broadcast type are included.
         .filter(isUnreadCountSupport$2)
-        .map(({ channelId }) => channelId);
+        .map(({ channelInternalId }) => channelInternalId);
     if (markerIds.length > 0) {
         // since the get markers method requires a channel cache to function with the reducer.
         preUpdateChannelCache(rawPayload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated });
@@ -6085,6 +6100,85 @@ const prepareChannelPayload = async (rawPayload, options = { isMessagePreviewUpd
         channelUsers });
 };
 
+/**
+ * ```js
+ * import { getSubChannelMarkers } from '@amityco/ts-sdk'
+ * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
+ * ```
+ *
+ * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ *
+ * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.SubChannelMarker} objects
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+const getUserMessageFeedMakers = async (channelIds) => {
+    const client = getActiveClient();
+    client.log('channel/getUserMessageFeedMakers', channelIds);
+    const { data } = await client.http.get(`/api/v1/markers/user-message-feed`, {
+        params: {
+            channelIds,
+        },
+    });
+    fireEvent('local.userMessageFeedMarker.fetched', { userMessageFeedMarker: data });
+    return data;
+};
+
+const persistUnreadCountInfo = (payload) => {
+    const { feedMarkers, userFeedMarkers } = payload;
+    // calculate sub channel unread info and channel unread info
+    if (feedMarkers.length > 0 && userFeedMarkers.length > 0) {
+        const channelIds = [];
+        const feedMarkerMap = new Map(feedMarkers.map(fm => [fm.feedId, fm]));
+        userFeedMarkers.forEach(userFeedMarker => {
+            const feedMarker = feedMarkerMap.get(userFeedMarker.feedId);
+            if (!feedMarker)
+                return;
+            if (feedMarker.feedId === userFeedMarker.feedId) {
+                const unreadCount = feedMarker.lastSegment - userFeedMarker.readToSegment;
+                const subChannelUnreadInfo = {
+                    subChannelId: feedMarker.feedId,
+                    channelId: feedMarker.entityId,
+                    readToSegment: userFeedMarker.readToSegment,
+                    lastSegment: feedMarker.lastSegment,
+                    lastMentionSegment: userFeedMarker.lastMentionSegment,
+                    unreadCount: Math.max(0, unreadCount),
+                    isMentioned: userFeedMarker.isMentioned,
+                    isDeleted: feedMarker.isDeleted,
+                    createdAt: userFeedMarker.createdAt,
+                    updatedAt: userFeedMarker.updatedAt,
+                };
+                // update sub channel unread info in cache
+                ingestInCache({ subChannelUnreadInfo: [subChannelUnreadInfo] });
+                if (!channelIds.includes(feedMarker.entityId)) {
+                    channelIds.push(feedMarker.entityId);
+                }
+            }
+        });
+        // re-calculate channel unread info in cache
+        channelIds.forEach(channelId => {
+            reCalculateChannelUnreadInfo(channelId);
+        });
+    }
+};
+
+const prepareUnreadCountInfo = async (rawPayload) => {
+    const client = getActiveClient();
+    // if consistent mode is enabled, persist the unread count info to the cache
+    // Marker service API uses channelInternalId as channelId
+    const queryPayload = await getUserMessageFeedMakers(rawPayload.channels.map(({ channelInternalId }) => channelInternalId));
+    const { feedMarkers, userFeedMarkers } = queryPayload;
+    persistUnreadCountInfo({
+        feedMarkers,
+        userFeedMarkers,
+    });
+    client.log('channel/prepareUnreadCountInfo', rawPayload.channels);
+};
+
 /**
  * ```js
  * import { getChannelByIds } from '@amityco/ts-sdk'
@@ -6114,12 +6208,16 @@ const getChannelByIds = async (channelIds) => {
     catch (error) {
         channelIds.forEach(channelId => {
             if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+                // NOTE: use channelPublicId as tombstone cache key since we cannot get the channelPrivateId that come along with channel data from server
                 pushToTombstone('channel', channelId);
             }
         });
         throw error;
     }
     const data = await prepareChannelPayload(payload);
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        await prepareUnreadCountInfo(payload);
+    }
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
@@ -6143,18 +6241,18 @@ const getChannelByIds = async (channelIds) => {
  * @category Channel API
  */
 getChannelByIds.locally = (channelIds) => {
-    var _a;
+    var _a, _b;
     const client = getActiveClient();
     client.log('channel/getChannelByIds.locally', channelIds);
     if (!client.cache)
         return;
-    const cached = channelIds
-        .map(channelId => pullFromCache(['channel', 'get', channelId]))
-        .filter(Boolean);
-    if ((cached === null || cached === void 0 ? void 0 : cached.length) < channelIds.length)
+    const cached = (_a = queryCache(['channel', 'get'])) === null || _a === void 0 ? void 0 : _a.filter(({ data }) => {
+        return channelIds.includes(data.channelPublicId);
+    });
+    if (!cached || (cached === null || cached === void 0 ? void 0 : cached.length) < channelIds.length)
         return;
     const channels = cached.map(({ data }) => data);
-    const oldest = (_a = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _a === void 0 ? void 0 : _a[0];
+    const oldest = (_b = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _b === void 0 ? void 0 : _b[0];
     return {
         data: channels,
         cachedAt: oldest.cachedAt,
@@ -6194,44 +6292,6 @@ const getMessageMarkers = async (messageIds) => {
     return { data: contentMarkers, cachedAt };
 };
 
-const persistUnreadCountInfo = (payload) => {
-    const { feedMarkers, userFeedMarkers } = payload;
-    // calculate sub channel unread info and channel unread info
-    if (feedMarkers.length > 0 && userFeedMarkers.length > 0) {
-        const channelIds = [];
-        const feedMarkerMap = new Map(feedMarkers.map(fm => [fm.feedId, fm]));
-        userFeedMarkers.forEach(userFeedMarker => {
-            const feedMarker = feedMarkerMap.get(userFeedMarker.feedId);
-            if (!feedMarker)
-                return;
-            if (feedMarker.feedId === userFeedMarker.feedId) {
-                const unreadCount = feedMarker.lastSegment - userFeedMarker.readToSegment;
-                const subChannelUnreadInfo = {
-                    subChannelId: feedMarker.feedId,
-                    channelId: feedMarker.entityId,
-                    readToSegment: userFeedMarker.readToSegment,
-                    lastSegment: feedMarker.lastSegment,
-                    lastMentionSegment: userFeedMarker.lastMentionSegment,
-                    unreadCount: Math.max(0, unreadCount),
-                    isMentioned: userFeedMarker.isMentioned,
-                    isDeleted: feedMarker.isDeleted,
-                    createdAt: userFeedMarker.createdAt,
-                    updatedAt: userFeedMarker.updatedAt,
-                };
-                // update sub channel unread info in cache
-                ingestInCache({ subChannelUnreadInfo: [subChannelUnreadInfo] });
-                if (!channelIds.includes(feedMarker.entityId)) {
-                    channelIds.push(feedMarker.entityId);
-                }
-            }
-        });
-        // re-calculate channel unread info in cache
-        channelIds.forEach(channelId => {
-            reCalculateChannelUnreadInfo(channelId);
-        });
-    }
-};
-
 /**
  * ```js
  * import { getSubChannelMarkers } from '@amityco/ts-sdk'
@@ -7145,7 +7205,7 @@ const getSocialSettings = async () => {
 
 const checkUserPermission = (userId, permission) => {
     var _a;
-    const user = (_a = pullFromCache(['users', 'get', userId])) === null || _a === void 0 ? void 0 : _a.data;
+    const user = (_a = pullFromCache(['user', 'get', userId])) === null || _a === void 0 ? void 0 : _a.data;
     if (!user)
         return false;
     return user.permissions.some(x => x === permission);
@@ -7521,32 +7581,19 @@ const onOffline = (callback) => {
     return () => console.error('Unsupported environment');
 };
 
-/**
- * ```js
- * import { getSubChannelMarkers } from '@amityco/ts-sdk'
- * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
- * ```
- *
- * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
- *
- * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
- * @param page
- * @returns A page of {@link Amity.SubChannelMarker} objects
- *
- * @category Channel API
- * @async
- * @private
- */
-const getUserMessageFeedMakers = async (channelIds) => {
-    const client = getActiveClient();
-    client.log('channel/getUserMessageFeedMakers', channelIds);
-    const { data } = await client.http.get(`/api/v1/markers/user-message-feed`, {
-        params: {
-            channelIds,
-        },
+const resolveChannels = async (channelIds) => {
+    const { data: channels } = await getChannelByIds(channelIds);
+    fireEvent('local.channel.resolved', channels);
+};
+
+const resolveUserMessageFeedMarkers = async (channelIds) => {
+    const queryPayload = await getUserMessageFeedMakers(channelIds);
+    const { feedMarkers, userFeedMarkers } = queryPayload;
+    persistUnreadCountInfo({
+        feedMarkers,
+        userFeedMarkers,
     });
-    fireEvent('local.userMessageFeedMarker.fetched', { userMessageFeedMarker: data });
-    return data;
+    fireEvent('local.userMessageFeedMarkers.resolved', { feedMarkers, userFeedMarkers });
 };
 
 class ObjectResolverEngine {
@@ -7613,9 +7660,9 @@ class ObjectResolverEngine {
         // Incase of failure: Ignore
         // Incase of success: Persist in Domain DB & Notify Live collection
         if (channelIds.length > 0)
-            getChannelByIds(channelIds);
+            resolveChannels(channelIds);
         if (userMessageFeedMarkerIds.length > 0)
-            getUserMessageFeedMakers(userMessageFeedMarkerIds);
+            resolveUserMessageFeedMarkers(userMessageFeedMarkerIds);
         // After sending request
         this.isResolvingTask = false;
     }
@@ -8685,9 +8732,7 @@ const login = async (params, sessionHandler, config) => {
         // FIXME: events are duplicated if connectClient is called few times without disconnectClient
         // wire websocket events to our event emitter
         proxyWebsocketEvents(client.ws, client.emitter);
-        client.ws.once('connect', () => {
-            client.ws.open();
-        });
+        client.ws.open();
         client.userId = user.userId;
         client.sessionHandler = sessionHandler;
         /*
@@ -13103,7 +13148,7 @@ const onReactionRemoved = (referenceType, referenceId, callback) => {
  * })
  * ```
  *
- * Fired when an {@link Amity.Reactor} has been added
+ * Fired when an {@link Amity.InternalReactor} has been added
  *
  * @param {@link Amity.ReactableType} referenceType
  * @param {string} referenceId
@@ -13166,7 +13211,7 @@ const onReactorAdded = (referenceType, referenceId, callback) => {
  * })
  * ```
  *
- * Fired when an {@link Amity.Reactor} has been removed
+ * Fired when an {@link Amity.InternalReactor} has been removed
  *
  * @param {@link Amity.ReactableType} referenceType
  * @param {string} referenceId
@@ -13273,10 +13318,10 @@ const queryReactions = async (query) => {
  * })
  * ```
  *
- * Queries a paginable list of {@link Amity.Reactor} objects
+ * Queries a paginable list of {@link Amity.InternalReactor} objects
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.Reactor} objects
+ * @returns A page of {@link Amity.InternalReactor} objects
  *
  * @reaction Reaction API
  * @async
@@ -13302,7 +13347,7 @@ const queryReactor = async (query) => {
  * }, response => merge(reactions, response.data))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Reactor} for a given target object
+ * Observe all mutations on a list of {@link Amity.InternalReactor} for a given target object
  *
  * @param params for querying reactions
  * @param callback the function to call when new data are available
@@ -13332,7 +13377,7 @@ const getReactions = (params, callback, config) => {
         const reactions = (_a = data.data
             .map(reactorId => pullFromCache(['reactor', 'get', reactorId]))
             .filter(Boolean)
-            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
+            .map(({ data }) => LinkedObject.reactor(data))) !== null && _a !== void 0 ? _a : [];
         callback({
             onNextPage: onFetch,
             data: reactions,
@@ -13607,18 +13652,6 @@ const updateChannel = async (channelId, patch) => {
 };
 /* end_public_function */
 
-const prepareUnreadCountInfo = async (rawPayload) => {
-    const client = getActiveClient();
-    // if consistent mode is enabled, persist the unread count info to the cache
-    const queryPayload = await getUserMessageFeedMakers(rawPayload.channels.map(({ channelId }) => channelId));
-    const { feedMarkers, userFeedMarkers } = queryPayload;
-    persistUnreadCountInfo({
-        feedMarkers,
-        userFeedMarkers,
-    });
-    client.log('channel/prepareUnreadCountInfo', rawPayload.channels);
-};
-
 /**
  * ```js
  * import { getChannel } from '@amityco/ts-sdk'
@@ -13647,6 +13680,7 @@ const getChannel$1 = async (channelId) => {
     }
     catch (error) {
         if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            // NOTE: use channelPublicId as tombstone cache key since we cannot get the channelPrivateId that come along with channel data from server
             pushToTombstone('channel', channelId);
         }
         throw error;
@@ -13674,16 +13708,20 @@ const getChannel$1 = async (channelId) => {
  * @category Channel API
  */
 getChannel$1.locally = (channelId) => {
+    var _a;
     const client = getActiveClient();
     client.log('channel/getChannel.locally', channelId);
     if (!client.cache)
         return;
-    const cached = pullFromCache(['channel', 'get', channelId]);
-    if (!cached)
+    // use queryCache to get all channel caches and filter by channelPublicId since we use channelPrivateId as cache key
+    const cached = (_a = queryCache(['channel', 'get'])) === null || _a === void 0 ? void 0 : _a.filter(({ data }) => {
+        return data.channelPublicId === channelId;
+    });
+    if (!cached || (cached === null || cached === void 0 ? void 0 : cached.length) === 0)
         return;
     return {
-        data: cached.data,
-        cachedAt: cached.cachedAt,
+        data: cached[0].data,
+        cachedAt: cached[0].cachedAt,
     };
 };
 
@@ -16327,6 +16365,7 @@ const getChannel = (channelId, callback) => {
                 await handleMessageCreated(message);
                 if (message.channelId !== channelId)
                     return;
+                // channelId from message is channelInternalId
                 const channel = (_a = pullFromCache(['channel', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
                 if (!channel)
                     return;
@@ -16346,6 +16385,7 @@ const getChannel = (channelId, callback) => {
                 await handleMessageCreated(message);
                 if (message.channelId !== channelId)
                     return;
+                // channelId from message is channelInternalId
                 const channel = (_a = pullFromCache(['channel', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
                 if (!channel)
                     return;
@@ -16509,15 +16549,15 @@ class ChannelQueryStreamController extends QueryStreamController {
             if ([
                 "onCreate" /* Amity.ChannelActionType.OnCreate */,
                 "onJoin" /* Amity.ChannelActionType.OnJoin */,
-                "onFetch" /* Amity.ChannelActionType.OnFetch */,
-                "onUserMessageFeedMarkerFetch" /* Amity.ChannelActionType.OnUserMessageFeedMarkerFetch */,
+                "onResolve" /* Amity.ChannelActionType.OnResolve */,
             ].includes(action)) {
-                if (Array.isArray(payload))
+                if (Array.isArray(payload)) {
                     collection.data = [
-                        ...new Set([...payload.map(({ channelId }) => channelId), ...collection.data]),
+                        ...new Set([...payload.map(getResolver('channel')), ...collection.data]),
                     ];
+                }
                 else
-                    collection.data = [...new Set([payload.channelId, ...collection.data])];
+                    collection.data = [...new Set([payload.channelInternalId, ...collection.data])];
             }
             pushToCache(this.cacheKey, collection);
             this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
@@ -16528,62 +16568,50 @@ class ChannelQueryStreamController extends QueryStreamController {
     }
 }
 
+const resolveUnreadInfoOnChannelEvent = (channel, callback) => {
+    const client = getActiveClient();
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        const objectResolverEngine = ObjectResolverEngine$1.getInstance();
+        objectResolverEngine.resolve(channel.channelId, "userMessageFeedMarker" /* Amity.ReferenceType.USER_MESSAGE_FEED_MARKER */);
+    }
+    else
+        callback(channel);
+};
+
 /**
- * ```js
- * import { onChannelFetched } from '@amityco/ts-sdk'
- * const dispose = onChannelFetched(channel => {
- *   // ...
- * })
- * ```
+ * Internal used only
  *
- * Fired when any {@link Amity.Channel} list have been fetched
+ * Fired when any {@link Amity.Channel} have been resolved by Object resolver
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Channel Events
  */
-const onChannelFetched = (callback) => {
+const onChannelResolved = (callback) => {
     const client = getActiveClient();
     const filter = async (payload) => {
         callback(payload);
     };
-    return createEventSubscriber(client, 'onChannelFetched', 'local.channel.fetched', filter);
+    return createEventSubscriber(client, 'onChannelResolved', 'local.channel.resolved', filter);
 };
 
 /**
- * ```js
- * import { onFeedMarkerUpdated } from '@amityco/ts-sdk'
- * const dispose = onFeedMarkerUpdated(feedMarker => {
- *   // ...
- * })
- * ```
+ * Internal used only
  *
- * Fired when an {@link Amity.UserMessageFeedMarkerPayload} has been updated
+ * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category FeedMarker Events
+ * @category MessageMarker Events
  */
-const onUserFeedMarkerFetched = (callback) => {
+const onUserMessageFeedMarkerResolved = (callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        // update sub channel unread info and channel unread info in cache
-        persistUnreadCountInfo(payload.userMessageFeedMarker);
-        callback(payload.userMessageFeedMarker);
+        callback(payload);
     };
-    return createEventSubscriber(client, 'feedMarker/onUserFeedMarkerFetched', 'local.userMessageFeedMarker.fetched', filter);
-};
-
-const resolveUnreadInfoOnChannelEvent = (channel, callback) => {
-    const client = getActiveClient();
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        const objectResolverEngine = ObjectResolverEngine$1.getInstance();
-        objectResolverEngine.resolve(channel.channelId, "userMessageFeedMarker" /* Amity.ReferenceType.USER_MESSAGE_FEED_MARKER */);
-    }
-    else
-        callback(channel);
+    return createEventSubscriber(client, 'userMessageFeedMarker/onUserMessageFeedMarkerResolved', 'local.userMessageFeedMarkers.resolved', filter);
 };
 
 /* eslint-disable no-use-before-define */
@@ -16720,7 +16748,6 @@ class ChannelLiveCollectionController extends LiveCollectionController {
     getSubscriptions() {
         const subscriptions = [
             {
-                // TODO: merge this code to another onMessageCreated in this file
                 fn: convertEventPayload((callback) => {
                     return onMessageCreatedMqtt(message => {
                         var _a;
@@ -16731,6 +16758,7 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                         ])) === null || _a === void 0 ? void 0 : _a.data;
                         if (!cacheData) {
                             const objectResolverEngine = ObjectResolverEngine$1.getInstance();
+                            // channelId from message event payload is channelInternalId
                             objectResolverEngine.resolve(message.channelId, "channel" /* Amity.ReferenceType.CHANNEL */);
                         }
                         else {
@@ -16744,7 +16772,6 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                 action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
-                // TODO: merge this code to another onMessageCreated in this file
                 fn: convertEventPayload((callback) => {
                     return onMessageCreatedLocal(message => {
                         var _a;
@@ -16936,23 +16963,25 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                 action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
             {
-                fn: onChannelFetched,
-                action: "onFetch" /* Amity.ChannelActionType.OnFetch */,
+                fn: onChannelResolved,
+                action: "onResolve" /* Amity.ChannelActionType.OnResolve */,
             },
             {
                 fn: (callback) => {
-                    const handleUserFeedMarkerFetch = async (marker) => {
+                    const handleUserFeedMarkerResolved = async (marker) => {
                         if (marker.feedMarkers) {
-                            const channelIds = marker.feedMarkers.map(feedMarker => feedMarker.entityId);
+                            const channelIds = [
+                                ...new Set(marker.feedMarkers.map(feedMarker => feedMarker.entityId)),
+                            ];
                             const channels = channelIds
                                 .map(channelId => { var _a; return (_a = pullFromCache(['channel', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data; })
                                 .filter(Boolean);
                             callback(channels);
                         }
                     };
-                    return onUserFeedMarkerFetched(handleUserFeedMarkerFetch);
+                    return onUserMessageFeedMarkerResolved(handleUserFeedMarkerResolved);
                 },
-                action: "onUserMessageFeedMarkerFetch" /* Amity.ChannelActionType.OnUserMessageFeedMarkerFetch */,
+                action: "onResolve" /* Amity.ChannelActionType.OnResolve */,
             },
         ];
         if (this.paginationController instanceof PaginationController) {
@@ -21576,7 +21605,7 @@ const onStreamStarted = (callback) => {
         ingestInCache(payload);
         callback(payload.videoStreamings[0]);
     };
-    return createEventSubscriber(client, 'stream/onStreamStarted', 'video-streaming.didStart', filter);
+    return createEventSubscriber(client, 'stream/onStreamStarted', 'v3.video-streaming.didStart', filter);
 };
 
 /**
@@ -21600,7 +21629,7 @@ const onStreamStopped = (callback) => {
         ingestInCache(payload);
         callback(payload.videoStreamings[0]);
     };
-    return createEventSubscriber(client, 'stream/onStreamStarted', 'video-streaming.didStop', filter);
+    return createEventSubscriber(client, 'stream/onStreamStropped', 'v3.video-streaming.didStop', filter);
 };
 
 /**
@@ -21624,7 +21653,7 @@ const onStreamRecorded = (callback) => {
         ingestInCache(payload);
         callback(payload.videoStreamings[0]);
     };
-    return createEventSubscriber(client, 'stream/onStreamRecorded', 'video-streaming.didRecord', filter);
+    return createEventSubscriber(client, 'stream/onStreamRecorded', 'v3.video-streaming.didRecord', filter);
 };
 
 /* eslint-disable no-use-before-define */