@amityco/ts-sdk 6.18.1-c018952.0 → 6.19.0

package/dist/marker/api/getUserMessageFeedMarkers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getUserMessageFeedMarkers.d.ts","sourceRoot":"","sources":["../../../src/marker/api/getUserMessageFeedMarkers.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,eACvB,MAAM,UAAU,CAAC,WAAW,CAAC,EAAE,KAC1C,QAAQ,MAAM,4BAA4B,CAc5C,CAAC"}
+{"version":3,"file":"getUserMessageFeedMarkers.d.ts","sourceRoot":"","sources":["../../../src/marker/api/getUserMessageFeedMarkers.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,eACvB,MAAM,UAAU,CAAC,WAAW,CAAC,EAAE,KAC1C,QAAQ,MAAM,4BAA4B,CAgB5C,CAAC"}

package/dist/marker/events/onUserFeedMarkerFetched.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ```js
+ * import { onFeedMarkerUpdated } from '@amityco/ts-sdk'
+ * const dispose = onFeedMarkerUpdated(feedMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.UserMessageFeedMarkerPayload} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category FeedMarker Events
+ */
+export declare const onUserFeedMarkerFetched: (callback: Amity.Listener<Amity.UserMessageFeedMarkerPayload>) => Amity.Unsubscriber;
+//# sourceMappingURL=onUserFeedMarkerFetched.d.ts.map

package/dist/marker/events/onUserFeedMarkerFetched.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onUserFeedMarkerFetched.d.ts","sourceRoot":"","sources":["../../../src/marker/events/onUserFeedMarkerFetched.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB,aACxB,MAAM,QAAQ,CAAC,MAAM,4BAA4B,CAAC,KAC3D,MAAM,YAeR,CAAC"}

package/dist/marker/utils/addFlagSubChannelUnreadByChannelId.d.ts

@@ -0,0 +1,2 @@
+export declare const addFlagSubChannelUnreadByChannelId: (channelId: string) => void;
+//# sourceMappingURL=addFlagSubChannelUnreadByChannelId.d.ts.map

package/dist/marker/utils/addFlagSubChannelUnreadByChannelId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addFlagSubChannelUnreadByChannelId.d.ts","sourceRoot":"","sources":["../../../src/marker/utils/addFlagSubChannelUnreadByChannelId.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kCAAkC,cAAe,MAAM,SAgBnE,CAAC"}

package/dist/marker/utils/addFlagSubChannelUnreadBySubChannelId.d.ts

@@ -0,0 +1,2 @@
+export declare const addFlagSubChannelUnreadBySubChannelId: (subChannelId: string) => void;
+//# sourceMappingURL=addFlagSubChannelUnreadBySubChannelId.d.ts.map

package/dist/marker/utils/addFlagSubChannelUnreadBySubChannelId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addFlagSubChannelUnreadBySubChannelId.d.ts","sourceRoot":"","sources":["../../../src/marker/utils/addFlagSubChannelUnreadBySubChannelId.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,qCAAqC,iBAAkB,MAAM,SAUzE,CAAC"}

package/dist/messageRepository/observers/tests/markReadMessage.test.d.ts

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

package/dist/messageRepository/observers/tests/markReadMessage.test.d.ts.map

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

package/dist/reactionRepository/events/onReactionAdded.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onReactionAdded.d.ts","sourceRoot":"","sources":["../../../src/reactionRepository/events/onReactionAdded.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;KAgBK;AACL,eAAO,MAAM,eAAe,kBACX,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,wIAEzC,MAAM,YAsCR,CAAC"}
+{"version":3,"file":"onReactionAdded.d.ts","sourceRoot":"","sources":["../../../src/reactionRepository/events/onReactionAdded.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;KAgBK;AACL,eAAO,MAAM,eAAe,kBACX,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,wIAEzC,MAAM,YAuCR,CAAC"}

package/dist/subChannelRepository/events/onSubChannelCreated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onSubChannelCreated.d.ts","sourceRoot":"","sources":["../../../src/subChannelRepository/events/onSubChannelCreated.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,aAAc,MAAM,QAAQ,CAAC,MAAM,UAAU,CAAC,uBAgB7E,CAAC"}
+{"version":3,"file":"onSubChannelCreated.d.ts","sourceRoot":"","sources":["../../../src/subChannelRepository/events/onSubChannelCreated.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,aAAc,MAAM,QAAQ,CAAC,MAAM,UAAU,CAAC,uBAuB7E,CAAC"}

package/dist/subChannelRepository/utils/persistOptimisticUnreadInfo.d.ts

@@ -1,2 +1,2 @@
-export declare const persistOptimisticUnreadInfo: (rawPayload: Amity.SubChannelPayload) => void;
+export declare const persistOptimisticUnreadInfo: (subChannelOptimisticInfo: Pick<Amity.SubChannel, 'channelId' | 'subChannelId' | 'createdAt' | 'updatedAt'>) => void;
 //# sourceMappingURL=persistOptimisticUnreadInfo.d.ts.map

package/dist/subChannelRepository/utils/persistOptimisticUnreadInfo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"persistOptimisticUnreadInfo.d.ts","sourceRoot":"","sources":["../../../src/subChannelRepository/utils/persistOptimisticUnreadInfo.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,2BAA2B,eAAgB,MAAM,iBAAiB,SAoB9E,CAAC"}
+{"version":3,"file":"persistOptimisticUnreadInfo.d.ts","sourceRoot":"","sources":["../../../src/subChannelRepository/utils/persistOptimisticUnreadInfo.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,2BAA2B,6BACZ,KACxB,MAAM,UAAU,EAChB,WAAW,GAAG,cAAc,GAAG,WAAW,GAAG,WAAW,CACzD,SAqBF,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"liveObject.d.ts","sourceRoot":"","sources":["../../src/utils/liveObject.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,UAAU,uPASiC,MAAM,YAAY,wEAEvE,MAAM,YAkFR,CAAC"}
+{"version":3,"file":"liveObject.d.ts","sourceRoot":"","sources":["../../src/utils/liveObject.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,UAAU,uPASiC,MAAM,YAAY,wEAEvE,MAAM,YAmFR,CAAC"}

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

@@ -1,7 +1,8 @@
 export declare function generateRawMessage(params?: Partial<Amity.RawMessage>): Amity.RawMessage;
-export declare const convertRawMessage: ({ channelPublicId, childCount, creatorPublicId, mentionedUsers, messageFeedId, reactionCount, reactions, referenceId, segment, messageId, myReactions, ...rest }: Amity.RawMessage) => Amity.Message;
+export declare const convertRawMessage: ({ channelPublicId, childCount, creatorPublicId, mentionedUsers, messageFeedId, reactionCount, reactions, referenceId, segment, messageId, myReactions, creatorId, ...rest }: Amity.RawMessage) => Amity.InternalMessage;
+export declare const withLinkedObject: (message: Amity.InternalMessage) => Amity.Message;
 export declare const convertRawMessagePayload: (rawPayload: Amity.MessagePayload) => Amity.ProcessedMessagePayload;
-export declare const message11: Amity.Message;
+export declare const message11: Amity.InternalMessage;
 export declare const messages: {
     subChannelId: string;
     page1: string[];
@@ -17,7 +18,7 @@ export declare const messagesDesc: {
 };
 export declare const messageQueryResponse: {
     data: {
-        messages: Amity.Message<any>[];
+        messages: Amity.InternalMessage<any>[];
         files: never[];
         users: never[];
         paging: {
@@ -27,7 +28,7 @@ export declare const messageQueryResponse: {
     };
 };
 export declare const messagePayload: {
-    messages: Amity.Message<any>[];
+    messages: Amity.InternalMessage<any>[];
     files: Amity.File<"image">[];
     users: Amity.User[];
 };

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

@@ -1 +1 @@
-{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/message.ts"],"names":[],"mappings":"AAGA,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,KAAK,CAAC,UAAU,CAyBvF;AAED,eAAO,MAAM,iBAAiB,qKAa3B,MAAM,UAAU,KAAG,MAAM,OAmB1B,CAAC;AAEH,eAAO,MAAM,wBAAwB,eACvB,MAAM,cAAc,KAC/B,MAAM,uBAGP,CAAC;AAEH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,OAM7B,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;CAMpB,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;CAKxB,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;CAUhC,CAAC;AAGF,eAAO,MAAM,cAAc;;;;CAI1B,CAAC"}
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/message.ts"],"names":[],"mappings":"AAGA,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,KAAK,CAAC,UAAU,CAyBvF;AAED,eAAO,MAAM,iBAAiB,gLAc3B,MAAM,UAAU,KAAG,MAAM,eAkB1B,CAAC;AAEH,eAAO,MAAM,gBAAgB,YAAa,MAAM,eAAe,KAAG,MAAM,OAOtE,CAAC;AAEH,eAAO,MAAM,wBAAwB,eACvB,MAAM,cAAc,KAC/B,MAAM,uBAGP,CAAC;AAEH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,eAM7B,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;CAMpB,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;CAKxB,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;CAUhC,CAAC;AAGF,eAAO,MAAM,cAAc;;;;CAI1B,CAAC"}

package/package.json

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

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

@@ -164,6 +164,7 @@ declare global {
 
     type LocalEvents = {
       'local.channel.updated': MakeRequired<Amity.ProcessedChannelPayload, 'channels'>;
+      'local.channel.fetched': Amity.InternalChannel[];
       'local.channel-moderator.role-added': Amity.ProcessedChannelPayload;
       'local.channel-moderator.role-removed': Amity.ProcessedChannelPayload;
       'local.message.created': MakeRequired<Amity.ProcessedMessagePayload, 'messages'>;
@@ -183,6 +184,10 @@ declare global {
       'local.messageMarker.fetched': MakeRequired<Amity.MessageMarkerPayload, 'contentMarkers'>;
       'local.userMarker.fetched': { userMarkers: Amity.UserMarker[] };
 
+      'local.userMessageFeedMarker.fetched': {
+        userMessageFeedMarker: Amity.UserMessageFeedMarkerPayload;
+      };
+
       'local.story.created': Amity.StoryPayload;
       'local.story.updated': Amity.StoryPayload;
       'local.story.deleted': Amity.StoryPayload;

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

@@ -0,0 +1,14 @@
+export {};
+
+declare global {
+  namespace Amity {
+    const enum ReferenceType {
+      CHANNEL = 'channel',
+      USER_MESSAGE_FEED_MARKER = 'userMessageFeedMarker',
+    }
+
+    type ObjectIdBuffer = {
+      [key in ReferenceType]: string[];
+    };
+  }
+}

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

@@ -15,16 +15,18 @@ declare global {
       | 'onChannelMemberRoleAdded'
       | 'onChannelMemberRoleRemoved';
 
-    type ChannelActionType =
-      | 'onFetch'
-      | 'onCreate'
-      | 'onUpdate'
-      | 'onDelete'
-      | 'onJoin'
-      | 'onLeft'
-      | 'onMute'
-      | 'onMemberAdded'
-      | 'onMemberRemoved';
+    const enum ChannelActionType {
+      OnFetch = 'onFetch',
+      OnCreate = 'onCreate',
+      OnUpdate = 'onUpdate',
+      OnDelete = 'onDelete',
+      OnJoin = 'onJoin',
+      OnLeft = 'onLeft',
+      OnMute = 'onMute',
+      OnMemberAdded = 'onMemberAdded',
+      OnMemberRemoved = 'onMemberRemoved',
+      OnUserMessageFeedMarkerFetch = 'onUserMessageFeedMarkerFetch',
+    }
 
     type RawChannel<T extends ChannelType = any> = {
       _id: string;

package/src/analytic/api/syncEvent.ts

@@ -6,7 +6,5 @@ export const syncEvent = async (events: Amity.AnalyticEventModel[]) => {
     activities: events,
   };
 
-  await client.http.post<Amity.ChannelPayload>('/api/v1/analytics/activities', {
-    activities: events,
-  });
+  await client.http.post<Amity.ChannelPayload>('/api/v1/analytics/activities', params);
 };

package/src/analytic/service/analytic/AnalyticsEngine.ts

@@ -1,8 +1,6 @@
 import { getActiveClient } from '~/client/api/activeClient';
-import { dropFromCache } from '~/cache/api';
 import { AnalyticsEventSyncer } from './AnalyticsEventSyncer';
 import { AnalyticsEventCapturer } from './AnalyticsEventCapturer';
-import { ANALYTIC_CACHE_KEY } from '../../constant';
 
 class AnalyticsEngine {
   private _client: Amity.Client;
@@ -49,14 +47,16 @@ class AnalyticsEngine {
   }
 
   handleTokenExpired() {
-    this._eventSyncer.stop();
+    this._stopAndDestroy();
   }
 
   destroy() {
-    this._eventSyncer.stop();
+    this._stopAndDestroy();
+  }
 
-    // query and destroy all objects.
-    dropFromCache(ANALYTIC_CACHE_KEY);
+  _stopAndDestroy() {
+    this._eventSyncer.stop();
+    this._eventCapturer.resetAllBuckets();
   }
 }
 

package/src/analytic/service/analytic/AnalyticsEventCapturer.ts

@@ -1,7 +1,7 @@
 import { upsertInCache } from '~/cache/api/upsertInCache';
 import { pullFromCache } from '~/cache/api/pullFromCache';
 import { DAY, MINUTE } from '~/utils/constants';
-import { pushToCache } from '~/cache/api';
+import { dropFromCache, pushToCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 import { STORY_KEY_CACHE } from '~/storyRepository/constants';
 import { ANALYTIC_CACHE_KEY, HIGH_PRIORITY_ANALYTIC_CACHE_KEY } from '../../constant';
@@ -148,6 +148,14 @@ export class AnalyticsEventCapturer {
     }, 300);
   }
 
+  resetAllBuckets() {
+    this._recentViewed = {};
+    this._recentHighPriorityViewed = {};
+
+    dropFromCache(ANALYTIC_CACHE_KEY);
+    dropFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
+  }
+
   markStoryAsViewed(story: Amity.InternalStory) {
     this.markStory(story, Amity.AnalyticEventActivityType.View);
   }

package/src/analytic/service/analytic/AnalyticsEventSyncer.ts

@@ -22,9 +22,15 @@ export class AnalyticsEventSyncer {
   }
 
   stop() {
-    if (!this._timer) return;
-    clearInterval(this._timer);
-    this._timer = undefined;
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = undefined;
+    }
+
+    if (this._high_priority_timer) {
+      clearInterval(this._high_priority_timer);
+      this._high_priority_timer = undefined;
+    }
   }
 
   async syncCapturedEvent() {

package/src/channelRepository/api/getChannel.ts

@@ -8,6 +8,7 @@ import { checkIfShouldGoesToTombstone } from '~/cache/utils';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 import { prepareChannelPayload } from '../utils';
+import { prepareUnreadCountInfo } from '../utils/prepateUnreadCountInfo';
 
 /**
  * ```js
@@ -39,6 +40,10 @@ export const getChannel = async (
     );
 
     data = await prepareChannelPayload(payload);
+
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+      prepareUnreadCountInfo(payload);
+    }
   } catch (error) {
     if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
       pushToTombstone('channel', channelId);

package/src/channelRepository/api/getChannelByIds.ts

@@ -6,6 +6,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { checkIfShouldGoesToTombstone } from '~/cache/utils';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
 import { prepareChannelPayload } from '../utils';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -53,6 +54,8 @@ export const getChannelByIds = async (
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
+  fireEvent('local.channel.fetched', data.channels);
+
   return {
     data: data.channels,
     cachedAt,

package/src/channelRepository/events/onChannelFetched.ts

@@ -0,0 +1,28 @@
+import { createEventSubscriber } from '~/core/events';
+
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ * ```js
+ * import { onChannelFetched } from '@amityco/ts-sdk'
+ * const dispose = onChannelFetched(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} list have been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelFetched = (callback: Amity.Listener<Amity.InternalChannel[]>) => {
+  const client = getActiveClient();
+
+  const filter = async (payload: Amity.InternalChannel[]) => {
+    callback(payload);
+  };
+
+  return createEventSubscriber(client, 'onChannelFetched', 'local.channel.fetched', filter);
+};

package/src/channelRepository/observers/getChannels/ChannelLiveCollectionController.ts

@@ -22,6 +22,7 @@ import { onMessageUpdated } from '~/messageRepository/events/onMessageUpdated';
 import { onMessageDeleted } from '~/messageRepository/events/onMessageDeleted';
 import { onSubChannelUpdated } from '~/subChannelRepository/events/onSubChannelUpdated';
 import { onSubChannelDeleted } from '~/subChannelRepository/events/onSubChannelDeleted';
+import { onChannelFetched } from '~/channelRepository/events/onChannelFetched';
 import { convertEventPayload } from '~/utils/event';
 import { onChannelMarkerFetched } from '~/marker/events';
 import {
@@ -49,6 +50,11 @@ import { PaginationController } from '~/core/liveCollection/PaginationController
 import { onUserFeedMarkerUpdated } from '~/marker/events/onUserFeedMarkerUpdated';
 import { onSubChannelCreated } from '~/subChannelRepository';
 
+import ObjectResolverEngine from '~/client/utils/ObjectResolver/objectResolverEngine';
+import { prepareUnreadCountInfo } from '~/channelRepository/utils/prepateUnreadCountInfo';
+import { onUserFeedMarkerFetched } from '~/marker/events/onUserFeedMarkerFetched';
+import { resolveUnreadInfoOnChannelEvent } from '~/channelRepository/utils/resolveUnreadInfoOnChannelEvent';
+
 export class ChannelLiveCollectionController extends LiveCollectionController<
   'channel',
   Amity.ChannelLiveCollection,
@@ -74,7 +80,17 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       this.query,
       this.cacheKey,
       this.notifyChange.bind(this),
-      prepareChannelPayload,
+      async (channel: Amity.ChannelPayload) => {
+        try {
+          const client = getActiveClient();
+          if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+            await prepareUnreadCountInfo(channel);
+          }
+        } catch (e) {
+          console.error('Error while preparing unread count info', e);
+        }
+        return prepareChannelPayload(channel);
+      },
       paginationController,
     );
 
@@ -235,19 +251,23 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
                 message.channelId,
               ])?.data;
 
-              if (!cacheData) return;
+              if (!cacheData) {
+                const objectResolverEngine = ObjectResolverEngine.getInstance();
 
-              updateChannelCache(cacheData, {
-                lastActivity: message.createdAt,
-              });
+                objectResolverEngine.resolve(message.channelId, Amity.ReferenceType.CHANNEL);
+              } else {
+                updateChannelCache(cacheData, {
+                  lastActivity: message.createdAt,
+                });
 
-              callback(message);
+                callback(message);
+              }
             });
           },
           'messageId',
           'channel',
         ),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
       },
       {
         // TODO: merge this code to another onMessageCreated in this file
@@ -272,12 +292,19 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
           'messageId',
           'channel',
         ),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
+      },
+      { fn: onChannelDeleted, action: Amity.ChannelActionType.OnDelete },
+      { fn: onChannelUpdated, action: Amity.ChannelActionType.OnUpdate },
+      { fn: onChannelMuted, action: Amity.ChannelActionType.OnMute },
+      {
+        fn: (callback: Amity.Listener<Amity.InternalChannel>) => {
+          return onChannelJoined(channel => {
+            resolveUnreadInfoOnChannelEvent(channel, callback);
+          });
+        },
+        action: Amity.ChannelActionType.OnJoin,
       },
-      { fn: onChannelDeleted, action: 'onDelete' },
-      { fn: onChannelUpdated, action: 'onUpdate' },
-      { fn: onChannelMuted, action: 'onMute' },
-      { fn: onChannelJoined, action: 'onJoin' },
       {
         fn: (reactor: Amity.Listener<Amity.InternalChannel>) => {
           const callback = (
@@ -300,17 +327,17 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
           };
           return onChannelLeft(callback);
         },
-        action: 'onLeft',
+        action: Amity.ChannelActionType.OnLeft,
       },
-      { fn: onChannelMemberAdded, action: 'onMemberAdded' },
-      { fn: onChannelMemberRemoved, action: 'onMemberRemoved' },
+      { fn: onChannelMemberAdded, action: Amity.ChannelActionType.OnMemberAdded },
+      { fn: onChannelMemberRemoved, action: Amity.ChannelActionType.OnMemberRemoved },
       {
         fn: convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
       },
       {
         fn: convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
       },
       {
         fn: convertEventPayload(
@@ -344,7 +371,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
           'channelId',
           'channel',
         ),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
       },
       {
         fn: convertEventPayload(
@@ -378,7 +405,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
           'channelId',
           'channel',
         ),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
       },
       {
         fn: convertEventPayload(
@@ -400,7 +427,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
           'channelId',
           'channel',
         ),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
       },
       {
         fn: convertEventPayload(
@@ -434,7 +461,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
           'channelId',
           'channel',
         ),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
       },
       {
         fn: convertEventPayload(
@@ -461,7 +488,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
           'channelId',
           'channel',
         ),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
       },
       {
         fn: convertEventPayload(
@@ -487,20 +514,53 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
           'channelId',
           'channel',
         ),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
       },
       {
         fn: convertEventPayload(onUserFeedMarkerUpdated, 'entityId', 'channel'),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
       },
       {
         fn: convertEventPayload(onSubChannelCreated, 'channelId', 'channel'),
-        action: 'onUpdate',
+        action: Amity.ChannelActionType.OnUpdate,
+      },
+      {
+        fn: onChannelFetched,
+        action: Amity.ChannelActionType.OnFetch,
+      },
+      {
+        fn: (callback: Amity.Listener<Amity.InternalChannel[]>) => {
+          const handleUserFeedMarkerFetch = async (marker: Amity.UserMessageFeedMarkerPayload) => {
+            if (marker.feedMarkers) {
+              const channelIds = marker.feedMarkers.map(feedMarker => feedMarker.entityId);
+              const channels = channelIds
+                .map(
+                  channelId =>
+                    pullFromCache<Amity.InternalChannel>(['channel', 'get', channelId])?.data,
+                )
+                .filter(Boolean) as Amity.InternalChannel[];
+
+              callback(channels);
+            }
+          };
+          return onUserFeedMarkerFetched(handleUserFeedMarkerFetch);
+        },
+        action: Amity.ChannelActionType.OnUserMessageFeedMarkerFetch,
       },
     ];
 
     if (this.paginationController instanceof PaginationController) {
-      return [...subscriptions, { fn: onChannelCreated, action: 'onCreate' }];
+      return [
+        ...subscriptions,
+        {
+          fn: (callback: Amity.Listener<Amity.InternalChannel>) => {
+            return onChannelCreated(channel => {
+              resolveUnreadInfoOnChannelEvent(channel, callback);
+            });
+          },
+          action: Amity.ChannelActionType.OnCreate,
+        },
+      ];
     }
 
     return subscriptions;

package/src/channelRepository/observers/getChannels/ChannelQueryStreamController.ts

@@ -64,27 +64,40 @@ export class ChannelQueryStreamController extends QueryStreamController<
     }
   }
 
-  reactor(action: string) {
-    return (payload: Amity.Channel) => {
+  reactor(action: Amity.ChannelActionType) {
+    return (payload: Amity.InternalChannel | Amity.InternalChannel[]) => {
       const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(this.cacheKey)?.data;
       if (!collection) return;
 
+      if (this.paginationController instanceof ChannelPaginationNoPageController)
+        return this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+
       if (
-        this.paginationController instanceof ChannelPaginationController &&
-        action === 'onCreate'
+        [
+          Amity.ChannelActionType.OnCreate,
+          Amity.ChannelActionType.OnJoin,
+          Amity.ChannelActionType.OnFetch,
+          Amity.ChannelActionType.OnUserMessageFeedMarkerFetch,
+        ].includes(action)
       ) {
-        collection.data = [...new Set([payload.channelId, ...collection.data])];
-        pushToCache(this.cacheKey, collection);
+        if (Array.isArray(payload))
+          collection.data = [
+            ...new Set([...payload.map(({ channelId }) => channelId), ...collection.data]),
+          ];
+        else collection.data = [...new Set([payload.channelId, ...collection.data])];
       }
 
+      pushToCache(this.cacheKey, collection);
       this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
     };
   }
 
   subscribeRTE(
     createSubscriber: {
-      fn: (reactor: Amity.Listener<Amity.Channel>) => Amity.Unsubscriber;
-      action: string;
+      fn: (
+        reactor: Amity.Listener<Amity.InternalChannel | Amity.InternalChannel[]>,
+      ) => Amity.Unsubscriber;
+      action: Amity.ChannelActionType;
     }[],
   ) {
     return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));