@amityco/ts-sdk 6.7.2 → 6.7.3-cbeeb97.0

package/src/commentRepository/api/unflagComment.ts

@@ -19,7 +19,9 @@ import { fireEvent } from '~/core/events';
  * @category Comment API
  * @async
  * */
-export const unflagComment = async (commentId: Amity.Comment['commentId']): Promise<boolean> => {
+export const unflagComment = async (
+  commentId: Amity.InternalComment['commentId'],
+): Promise<boolean> => {
   const client = getActiveClient();
   client.log('comment/unflagComment', commentId);
 

package/src/commentRepository/api/updateComment.ts

@@ -14,19 +14,19 @@ import { fireEvent } from '~/core/events';
  * })
  * ```
  *
- * Updates an {@link Amity.Comment}
+ * Updates an {@link Amity.InternalComment}
  *
- * @param commentId The ID of the {@link Amity.Comment} to edit
+ * @param commentId The ID of the {@link Amity.InternalComment} to edit
  * @param patch The patch data to apply
- * @returns the updated {@link Amity.Comment} object
+ * @returns the updated {@link Amity.InternalComment} object
  *
  * @category Comment API
  * @async
  */
 export const updateComment = async (
-  commentId: Amity.Comment['commentId'],
-  patch: Patch<Amity.Comment, 'data' | 'metadata' | 'mentionees'>,
-): Promise<Amity.Cached<Amity.Comment>> => {
+  commentId: Amity.InternalComment['commentId'],
+  patch: Patch<Amity.InternalComment, 'data' | 'metadata' | 'mentionees'>,
+): Promise<Amity.Cached<Amity.InternalComment>> => {
   const client = getActiveClient();
   client.log('user/updateComment', patch);
 

package/src/commentRepository/events/onCommentCreated.ts

@@ -8,12 +8,13 @@ import { createCommentEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.Comment} has been created
+ * Fired when a {@link Amity.InternalComment} has been created
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
-export const onCommentCreated = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
-  createCommentEventSubscriber('comment.created', callback);
+export const onCommentCreated = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => createCommentEventSubscriber('comment.created', callback);

package/src/commentRepository/events/onCommentDeleted.ts

@@ -8,12 +8,13 @@ import { createCommentEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.Comment} has been deleted
+ * Fired when a {@link Amity.InternalComment} has been deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
-export const onCommentDeleted = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
-  createCommentEventSubscriber('comment.deleted', callback);
+export const onCommentDeleted = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => createCommentEventSubscriber('comment.deleted', callback);

package/src/commentRepository/events/onCommentFlagged.ts

@@ -8,12 +8,13 @@ import { createCommentEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.Comment} has been flagged
+ * Fired when a {@link Amity.InternalComment} has been flagged
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
-export const onCommentFlagged = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
-  createCommentEventSubscriber('comment.flagged', callback);
+export const onCommentFlagged = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => createCommentEventSubscriber('comment.flagged', callback);

package/src/commentRepository/events/onCommentReactionAdded.ts

@@ -12,15 +12,15 @@ import { prepareReactionPayloadFormEvent } from '~/reactionRepository/utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.Comment} has been reacted
+ * Fired when a {@link Amity.InternalComment} has been reacted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
 export const onCommentReactionAdded = (
-  callback: Amity.Listener<Amity.Comment>,
+  callback: Amity.Listener<Amity.InternalComment>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
@@ -33,7 +33,7 @@ export const onCommentReactionAdded = (
 
       ingestInCache(commentPayload as Amity.CommentPayload);
 
-      const comment = pullFromCache<Amity.Comment>([
+      const comment = pullFromCache<Amity.InternalComment>([
         'comment',
         'get',
         payload.comments[0].commentId,

package/src/commentRepository/events/onCommentReactionRemoved.ts

@@ -12,15 +12,15 @@ import { prepareReactionPayloadFormEvent } from '~/reactionRepository/utils';
  * })
  * ```
  *
- * Fired when a reaction has been removed from a {@link Amity.Comment}
+ * Fired when a reaction has been removed from a {@link Amity.InternalComment}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
 export const onCommentReactionRemoved = (
-  callback: Amity.Listener<Amity.Comment>,
+  callback: Amity.Listener<Amity.InternalComment>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
@@ -33,7 +33,7 @@ export const onCommentReactionRemoved = (
 
       ingestInCache(commentPayload as Amity.CommentPayload);
 
-      const comment = pullFromCache<Amity.Comment>([
+      const comment = pullFromCache<Amity.InternalComment>([
         'comment',
         'get',
         payload.comments[0].commentId,

package/src/commentRepository/events/onCommentUnflagged.ts

@@ -8,12 +8,13 @@ import { createCommentEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a flag has been removed from a {@link Amity.Comment}
+ * Fired when a flag has been removed from a {@link Amity.InternalComment}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
-export const onCommentUnflagged = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
-  createCommentEventSubscriber('comment.unflagged', callback);
+export const onCommentUnflagged = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => createCommentEventSubscriber('comment.unflagged', callback);

package/src/commentRepository/events/onCommentUpdated.ts

@@ -8,12 +8,13 @@ import { createCommentEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.Comment} has been updated
+ * Fired when a {@link Amity.InternalComment} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment Events
+ * @category InternalComment Events
  */
-export const onCommentUpdated = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
-  createCommentEventSubscriber('comment.updated', callback);
+export const onCommentUpdated = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => createCommentEventSubscriber('comment.updated', callback);

package/src/commentRepository/events/utils.ts

@@ -1,11 +1,11 @@
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
-import { queryCache, upsertInCache, pullFromCache } from '~/cache/api';
+import { pullFromCache, queryCache, upsertInCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 export const createCommentEventSubscriber = (
   event: keyof Amity.MqttCommentEvents,
-  callback: Amity.Listener<Amity.Comment>,
+  callback: Amity.Listener<Amity.InternalComment>,
 ) => {
   const client = getActiveClient();
 
@@ -16,7 +16,7 @@ export const createCommentEventSubscriber = (
     } else {
       ingestInCache(payload);
 
-      const comment = pullFromCache<Amity.Comment>([
+      const comment = pullFromCache<Amity.InternalComment>([
         'comment',
         'get',
         payload.comments[0].commentId,

package/src/commentRepository/observers/getComment.ts

@@ -23,17 +23,17 @@ import {
  * });
  * ```
  *
- * Observe all mutation on a given {@link Amity.Comment}
+ * Observe all mutation on a given {@link Amity.InternalComment}
  *
  * @param commentId the ID of the comment to observe
  * @param callback the function to call when new data are available
  * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
  *
- * @category Comment Live Object
+ * @category InternalComment Live Object
  */
 export const getComment = (
-  commentId: Amity.Comment['commentId'],
-  callback: Amity.LiveObjectCallback<Amity.Comment>,
+  commentId: Amity.InternalComment['commentId'],
+  callback: Amity.LiveObjectCallback<Amity.InternalComment>,
 ): Amity.Unsubscriber => {
   return liveObject(commentId, callback, 'commentId', _getComment, [
     onCommentDeleted,

package/src/commentRepository/observers/getComments.ts

@@ -18,6 +18,7 @@ import {
 } from '~/utils/constants';
 
 import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
+import { LinkedObject } from '~/utils/linkedObject';
 import {
   onCommentCreated,
   onCommentDeleted,
@@ -38,12 +39,12 @@ import { queryComments } from '../api/queryComments';
  *
  * let comments = []
  * const unsub = getComments({
- *   referenceType: Amity.Comment['referenceType'];
- *   referenceId: Amity.Comment['referenceId'];
+ *   referenceType: Amity.InternalComment['referenceType'];
+ *   referenceId: Amity.InternalComment['referenceId'];
  * }, response => merge(comments, response.data))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Comment} for a given target object
+ * Observe all mutations on a list of {@link Amity.InternalComment} for a given target object
  *
  * @param referenceType the type of the target
  * @param referenceId the ID of the target
@@ -54,7 +55,7 @@ import { queryComments } from '../api/queryComments';
  */
 export const getComments = (
   params: Amity.CommentLiveCollection,
-  callback: Amity.LiveCollectionCallback<Amity.Comment>,
+  callback: Amity.LiveCollectionCallback<Amity.InternalComment>,
   config?: Amity.LiveCollectionConfig,
 ): Amity.Unsubscriber => {
   const { log, cache } = getActiveClient();
@@ -79,11 +80,11 @@ export const getComments = (
   ];
 
   const responder = (data: Amity.CommentLiveCollectionCache) => {
-    let comments: Amity.Comment[] =
+    let comments: Amity.InternalComment[] =
       data.data
-        .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
+        .map(commentId => pullFromCache<Amity.InternalComment>(['comment', 'get', commentId])!)
         .filter(Boolean)
-        .map(({ data }) => data) ?? [];
+        .map(({ data }) => LinkedObject.comment(data)) ?? [];
 
     if (!params.includeDeleted) {
       comments = filterByPropEquality(comments, 'isDeleted', false);
@@ -102,7 +103,7 @@ export const getComments = (
     });
   };
 
-  const realtimeRouter = (action: Amity.CommentActionType) => (comment: Amity.Comment) => {
+  const realtimeRouter = (action: Amity.CommentActionType) => (comment: Amity.InternalComment) => {
     const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
 
     if (

package/src/commentRepository/observers/observeComment.ts

@@ -1,16 +1,16 @@
 import { getActiveClient } from '~/client/api';
 
-import { createQuery, runQuery, queryOptions } from '~/core/query';
+import { createQuery, queryOptions, runQuery } from '~/core/query';
 
 import { getComment } from '../api/getComment';
 
 import {
-  onCommentUpdated,
   onCommentDeleted,
   onCommentFlagged,
-  onCommentUnflagged,
   onCommentReactionAdded,
   onCommentReactionRemoved,
+  onCommentUnflagged,
+  onCommentUpdated,
 } from '../events';
 
 /**
@@ -21,13 +21,13 @@ import {
  * const dispose = observeComment(commentId, ({ data }) => comment = data)
  * ```
  *
- * Observe all mutation on a given {@link Amity.Comment}
+ * Observe all mutation on a given {@link Amity.InternalComment}
  *
  * @param commentId the ID of the comment to observe
  * @param callback the function to call when new data are available
  * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
  *
- * @category Comment Observer
+ * @category InternalComment Observer
  */
 export const observeComment = <
   Events extends [
@@ -41,7 +41,7 @@ export const observeComment = <
   ],
 >(
   commentId: string,
-  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Comment | undefined>, Events>,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.InternalComment | undefined>, Events>,
   policy: Amity.QueryPolicy = 'cache_then_server',
 ): Amity.Unsubscriber => {
   const { log } = getActiveClient();
@@ -50,7 +50,10 @@ export const observeComment = <
   log(`observeComment(tmpid: ${timestamp}) > listen`);
 
   // wrapper function to make sure
-  const router = (result: Amity.Snapshot<Amity.Comment | undefined>, action: Events[number]) => {
+  const router = (
+    result: Amity.Snapshot<Amity.InternalComment | undefined>,
+    action: Events[number],
+  ) => {
     if (callback instanceof Function) return callback(result);
 
     if (action !== 'onFetch') callback.onEvent?.(action, result);
@@ -58,7 +61,10 @@ export const observeComment = <
     callback[action]?.(result);
   };
 
-  const realtimeRouter = (result: Amity.Snapshot<Amity.Comment>, action: Events[number]) => {
+  const realtimeRouter = (
+    result: Amity.Snapshot<Amity.InternalComment>,
+    action: Events[number],
+  ) => {
     if (result.data?.commentId !== commentId) return;
 
     router(result, action);

package/src/commentRepository/observers/observeComments.ts

@@ -2,12 +2,12 @@ import { getActiveClient } from '~/client/api';
 
 import {
   onCommentCreated,
-  onCommentUpdated,
   onCommentDeleted,
   onCommentFlagged,
-  onCommentUnflagged,
   onCommentReactionAdded,
   onCommentReactionRemoved,
+  onCommentUnflagged,
+  onCommentUpdated,
 } from '../events';
 
 /**
@@ -18,18 +18,18 @@ import {
  * const unsub = observeComments(postId, comment => merge(comments, comment))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Comment} for a given {@link Amity.Post} object
+ * Observe all mutations on a list of {@link Amity.InternalComment} for a given {@link Amity.Post} object
  *
  * @param postId the ID of the post where to observe the comments
  * @param callback the function to call when new data are available
  * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comments
  *
- * @category Comment Observer
+ * @category InternalComment Observer
  */
 export const observeComments = (
   postId: Amity.Post['postId'],
   callback: Amity.ObjectListener<
-    Amity.Comment,
+    Amity.InternalComment,
     [
       'onCreate',
       'onUpdate',
@@ -48,7 +48,10 @@ export const observeComments = (
 
   const disposers: Amity.Unsubscriber[] = [];
 
-  const router = (comment: Amity.Comment, action: Exclude<Amity.CommentActionType, 'onFetch'>) => {
+  const router = (
+    comment: Amity.InternalComment,
+    action: Exclude<Amity.CommentActionType, 'onFetch'>,
+  ) => {
     if (comment.referenceId !== postId) return;
 
     if (callback instanceof Function) return callback(comment);

package/src/commentRepository/observers/tests/getComment.test.ts

@@ -1,10 +1,10 @@
 import { disableCache, enableCache } from '~/cache/api';
 import {
-  pause,
   client,
   connectClient,
   disconnectClient,
   generateComment,
+  pause,
   user12,
 } from '~/utils/tests';
 import { getFutureDate } from '~/core/model';
@@ -50,6 +50,7 @@ describe('getComment', () => {
     client.emitter.emit(event, {
       comments: [update],
       commentChildren: [],
+      communityUsers: [],
       users: [],
       files: [],
     });
@@ -91,6 +92,7 @@ describe('getComment', () => {
       comments: [update],
       reactor,
       commentChildren: [],
+      communityUsers: [],
       users: [],
       files: [],
     });

package/src/marker/api/getChannelMarkers.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { fireEvent } from '~/core/events';
 import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { convertChannelMarkerResponse, convertUserMarkerResponse } from '~/utils/marker';
 
 /**
  * ```js
@@ -38,12 +39,17 @@ export const getChannelMarkers = async (
   });
 
   const { paging, ...payload } = queryPayload;
-  const { userEntityMarkers, userMarkers } = payload;
+  const { userEntityMarkers: userEntityMarkersPayload, userMarkers: userMarkersPayload } = payload;
+
+  const userMarkers = convertUserMarkerResponse(userMarkersPayload);
+  const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(payload as Amity.ChannelMarkerPayload, { cachedAt });
+  if (client.cache) ingestInCache({ userEntityMarkers, userMarkers }, { cachedAt });
 
-  fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+  fireEvent('local.channelMarker.fetched', {
+    userEntityMarkers,
+  });
   fireEvent('local.userMarker.fetched', { userMarkers });
 
   const nextPage = toPage(paging.next);

package/src/marker/api/getMessageMarkers.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { fireEvent } from '~/core/events';
 import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { convertUserMarkerResponse } from '~/utils/marker';
 
 /**
  * ```js
@@ -38,10 +39,12 @@ export const getMessageMarkers = async (
   });
 
   const { paging, ...payload } = queryPayload;
-  const { contentMarkers, feedMarkers, userMarkers } = payload;
+  const { contentMarkers, feedMarkers, userMarkers: userMarkersPayload } = payload;
+
+  const userMarkers = convertUserMarkerResponse(userMarkersPayload);
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(payload as Amity.MessageMarkerPayload, { cachedAt });
+  if (client.cache) ingestInCache({ contentMarkers, feedMarkers, userMarkers }, { cachedAt });
 
   fireEvent('local.feedMarker.fetched', { feedMarkers });
   fireEvent('local.messageMarker.fetched', { contentMarkers });

package/src/marker/api/getSubChannelMarkers.ts

@@ -2,6 +2,11 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { fireEvent } from '~/core/events';
 import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import {
+  convertChannelMarkerResponse,
+  convertSubChannelMarkerResponse,
+  convertUserMarkerResponse,
+} from '~/utils/marker';
 
 /**
  * ```js
@@ -38,10 +43,19 @@ export const getSubChannelMarkers = async (
   });
 
   const { paging, ...payload } = queryPayload;
-  const { userEntityMarkers, userFeedMarkers, userMarkers } = payload;
+  const {
+    userEntityMarkers: userEntityMarkersPayload,
+    userFeedMarkers: userFeedMarkersPayload,
+    userMarkers: userMarkersPayload,
+  } = payload;
+
+  const userMarkers = convertUserMarkerResponse(userMarkersPayload);
+  const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+  const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(payload as Amity.SubChannelMarkerPayload, { cachedAt });
+  if (client.cache)
+    ingestInCache({ userEntityMarkers, userFeedMarkers, userMarkers }, { cachedAt });
 
   fireEvent('local.channelMarker.fetched', { userEntityMarkers });
   fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });

package/src/marker/api/getUserMarker.ts

@@ -1,6 +1,8 @@
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getActiveClient } from '~/client/api/activeClient';
 import { fireEvent } from '~/core/events';
+// import { convertMarkerResponse } from '~/utils/marker';
+import { convertUserMarkerResponse } from '~/utils/marker';
 
 export const getUserMarker = async (): Promise<Amity.Cached<Amity.UserMarker>> => {
   const client = getActiveClient();
@@ -10,10 +12,15 @@ export const getUserMarker = async (): Promise<Amity.Cached<Amity.UserMarker>> =
     `/api/v1/markers/userMarker`,
   );
 
-  const { userMarkers } = payload;
+  const { userMarkers: UserMarkersPayload } = payload;
+
+  /* 
+    change field isMentioned from backend to be hasMentioned 
+  */
+  const userMarkers = convertUserMarkerResponse(UserMarkersPayload);
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(payload as Amity.UserMarkerPayload, { cachedAt });
+  if (client.cache) ingestInCache({ userMarkers }, { cachedAt });
 
   fireEvent('local.userMarker.fetched', { userMarkers });
 

package/src/marker/api/tests/getMessageMarkers.test.ts

@@ -7,6 +7,7 @@ import {
   generateFeedMarker,
   generateMessageMarker,
   generateUserMarker,
+  generateUserMarkerResponse,
 } from '~/utils/tests';
 
 import { getMessageMarkers } from '../getMessageMarkers';
@@ -25,6 +26,7 @@ const expectedMessageMarkers = [
 
 const expectedFeedMarkers = [generateFeedMarker({ feedId: 'sub-ch1', entityId: 'feed1' })];
 
+const userMarkersResponse = [generateUserMarkerResponse({ userId: 'currentUser1' })];
 const expectedUserMarkers = [generateUserMarker({ userId: 'currentUser1' })];
 
 const messageIds = expectedMessageMarkers.map(({ contentId }) => contentId);
@@ -35,7 +37,7 @@ const resolvedGetValue = {
   data: {
     contentMarkers: expectedMessageMarkers,
     feedMarkers: expectedFeedMarkers,
-    userMarkers: expectedUserMarkers,
+    userMarkers: userMarkersResponse,
     paging: pagingToken,
   } as Amity.MessageMarkerPayload,
 };

package/src/marker/api/tests/getSubChannelMarkers.test.ts

@@ -5,8 +5,11 @@ import { onSubChannelMarkerFetched, onUserMarkerFetched } from '~/marker/events'
 import {
   client,
   generateChannelMarker,
+  generateChannelMarkerResponse,
   generateSubChannelMarker,
+  generateSubChannelMarkerResponse,
   generateUserMarker,
+  generateUserMarkerResponse,
 } from '~/utils/tests';
 
 import { getSubChannelMarkers } from '../getSubChannelMarkers';
@@ -17,14 +20,19 @@ const pagingToken = {
 };
 
 const pagingCriteria = { limit: 10 };
+const subChannelMarkerResponse = [
+  generateSubChannelMarkerResponse({ feedId: 'sub-ch1', entityId: 'ch1' }),
+  generateSubChannelMarkerResponse({ feedId: 'sub-ch2', entityId: 'ch1' }),
+];
+const channelMarkersResponse = [
+  generateChannelMarkerResponse({ entityId: 'ch1', userId: 'user1' }),
+];
+const userMarkersResponse = [generateUserMarkerResponse({ userId: 'currentUser1' })];
 
 const expectedSubChannelMarkers = [
   generateSubChannelMarker({ feedId: 'sub-ch1', entityId: 'ch1' }),
   generateSubChannelMarker({ feedId: 'sub-ch2', entityId: 'ch1' }),
 ];
-
-const expectedChannelMarkers = [generateChannelMarker({ entityId: 'ch1', userId: 'user1' })];
-
 const expectedUserMarkers = [generateUserMarker({ userId: 'currentUser1' })];
 
 const subChannelIds = expectedSubChannelMarkers.map(({ feedId }) => feedId);
@@ -33,9 +41,9 @@ const subChannelMarkerCacheIds = expectedSubChannelMarkers.map(subChannelMarkerR
 
 const resolvedGetValue = {
   data: {
-    userFeedMarkers: expectedSubChannelMarkers,
-    userEntityMarkers: expectedChannelMarkers,
-    userMarkers: expectedUserMarkers,
+    userFeedMarkers: subChannelMarkerResponse,
+    userEntityMarkers: channelMarkersResponse,
+    userMarkers: userMarkersResponse,
     paging: pagingToken,
   } as Amity.SubChannelMarkerPayload,
 };
@@ -103,11 +111,11 @@ describe('getSubChannelMarkers', () => {
 
   test('should fire event `onUserMarkerFetched`', async () => {
     let dispose;
-    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue); // isMentioned
 
     const callbackPromise = new Promise(resolve => {
       dispose = onUserMarkerFetched(resolve);
-    }).finally(dispose);
+    }).finally(dispose); // hasMentioned
 
     await getSubChannelMarkers(subChannelIds);