@amityco/ts-sdk 6.17.3 → 6.18.0

package/src/messageRepository/observers/observeMessages.ts

@@ -8,6 +8,7 @@ import {
   onMessageDeleted,
   onMessageCreatedLocal,
 } from '../events';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -53,20 +54,32 @@ export const observeMessages = (
   };
 
   disposers.push(
-    onMessageCreatedMqtt(data => router({ data, loading: false, origin: 'event' }, 'onCreate')),
-    onMessageCreatedLocal(data => router({ data, loading: false, origin: 'event' }, 'onCreate')),
-    onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
-    onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onMessageCreatedMqtt(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onCreate'),
+    ),
+    onMessageCreatedLocal(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onCreate'),
+    ),
+    onMessageUpdated(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onUpdate'),
+    ),
+    onMessageDeleted(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onDelete'),
+    ),
     convertEventPayload(
       onMessageMarkerFetched,
       'contentId',
       'message',
-    )(data => router({ data, loading: false, origin: 'event' }, 'onCreate')),
+    )(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onCreate'),
+    ),
     convertEventPayload(
       onMessageMarked,
       'contentId',
       'message',
-    )(data => router({ data, loading: false, origin: 'event' }, 'onCreate')),
+    )(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onCreate'),
+    ),
   );
 
   return () => {

package/src/messageRepository/utils/getMessageReadCount.ts

@@ -1,10 +1,11 @@
 import { pullFromCache } from '~/cache/api/pullFromCache';
 import { getResolver } from '~/core/model';
 
-const getCachedMarker = (message: Amity.Message | Amity.RawMessage) => {
+const getCachedMarker = (message: Amity.InternalMessage | Amity.RawMessage) => {
   const key = {
-    creatorId: message.creatorId,
-    feedId: (<Amity.RawMessage>message).messageFeedId ?? (<Amity.Message>message).subChannelId,
+    creatorId: 'creatorPrivateId' in message ? message.creatorPrivateId : message.creatorId,
+    feedId:
+      (<Amity.RawMessage>message).messageFeedId ?? (<Amity.InternalMessage>message).subChannelId,
     contentId: message.messageId,
   };
 
@@ -16,7 +17,7 @@ const getCachedMarker = (message: Amity.Message | Amity.RawMessage) => {
 };
 
 export const getMessageReadCount = (
-  message: Amity.Message | Amity.RawMessage,
+  message: Amity.InternalMessage | Amity.RawMessage,
   marker?: Amity.MessageMarker,
 ) =>
   // Look in the marker param first

package/src/messageRepository/utils/prepareMessagePayload.ts

@@ -1,6 +1,6 @@
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { getMessageMarkers } from '~/marker/api';
+import { getMessageMarkers } from '~/marker/api/getMessageMarkers';
 import { prepareMessagePayloadForCache } from '~/reactionRepository/utils/prepareMessagePayloadForCache';
 import { inferIsDeleted } from '~/utils/inferIsDeleted';
 
@@ -14,7 +14,7 @@ export function convertFromRaw(
   message: Amity.RawMessage,
   reactors?: Amity.Reactor[],
   event?: keyof Amity.MqttMessageEvents,
-): Amity.Message {
+): Amity.InternalMessage {
   const {
     channelPublicId,
     childCount,
@@ -27,6 +27,7 @@ export function convertFromRaw(
     referenceId,
     segment,
     messageId,
+    creatorId,
     ...rest
   } = message;
 
@@ -40,19 +41,14 @@ export function convertFromRaw(
     cache = pullFromCache(['message', 'get', messageId]);
   }
 
-  const out: Amity.Message = {
-    get readCount() {
-      return getMessageReadCount(message).readCount;
-    },
-    get deliveredCount() {
-      return getMessageReadCount(message).deliveredCount;
-    },
+  const out: Amity.InternalMessage = {
     ...rest,
     messageId,
     channelId: channelPublicId,
     channelSegment: segment,
     childrenNumber: childCount,
     creatorId: creatorPublicId,
+    creatorPrivateId: message.creatorId,
     reactions: reactions ?? {},
     /*
      * Previously, myReactions were added only if it was part of the payload.
@@ -129,7 +125,7 @@ export const prepareMessagePayload = async (
         {};
 
       // exclude getter properties from existing subChannel cache, update only other properties to existing subChannel cache
-      const { unreadCount, hasMentioned, ...restSubChannel } =
+      const { unreadCount, hasMentioned, isMentioned, ...restSubChannel } =
         convertSubChannelFromRaw(messageFeed);
 
       updateSubChannelCache(messageFeed.messageFeedId, subChannelCache, restSubChannel);

package/src/reactionRepository/events/onReactionAdded.ts

@@ -6,6 +6,7 @@ import { getResolver } from '~/core/model';
 import { onPostReactionAdded } from '~/postRepository/events';
 import { onCommentReactionAdded } from '~/commentRepository/events';
 import { prepareMessagePayload } from '~/messageRepository/utils';
+import { reaction11 } from '~/utils/tests';
 
 /**
  * ```js

package/src/reactionRepository/events/onReactorAdded.ts

@@ -65,6 +65,19 @@ export const onReactorAdded = (
     return createEventSubscriber(client, 'post.addReaction', 'post.addReaction', filter);
   }
 
+  if (referenceType === 'story') {
+    const filter = (payload: Amity.StoryReactionPayload) => {
+      const { reactions, ...rest } = payload;
+      ingestInCache(rest as Amity.StoryPayload);
+      ingestInCache({ reactors: reactions });
+
+      if (payload.stories.length === 0 || payload.reactions.length === 0) return;
+      callbackWrapper('story', payload.stories[0].storyId, payload.reactions[0]);
+    };
+
+    return createEventSubscriber(client, 'story.reactionAdded', 'story.reactionAdded', filter);
+  }
+
   const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
     const { reactor, ...rest } = payload;
 

package/src/reactionRepository/events/onReactorRemoved.ts

@@ -65,6 +65,19 @@ export const onReactorRemoved = (
     return createEventSubscriber(client, 'post.removeReaction', 'post.removeReaction', filter);
   }
 
+  if (referenceType === 'story') {
+    const filter = (payload: Amity.StoryReactionPayload) => {
+      const { reactions, ...rest } = payload;
+      ingestInCache(rest as Amity.StoryPayload);
+      ingestInCache({ reactors: reactions });
+
+      if (payload.stories.length === 0 || payload.reactions.length === 0) return;
+      callbackWrapper('story', payload.stories[0].storyId, payload.reactions[0]);
+    };
+
+    return createEventSubscriber(client, 'story.reactionRemoved', 'story.reactionRemoved', filter);
+  }
+
   const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
     const { reactor, ...rest } = payload;
 

package/src/reactionRepository/utils/fetchReference.ts

@@ -1,4 +1,4 @@
-import { getMessage } from '~/messageRepository/api/getMessage';
+import { getMessage } from '~/messageRepository/internalApi/getMessage';
 import { getPost } from '~/postRepository/api/getPost';
 import { getComment } from '~/commentRepository/api/getComment';
 

package/src/reactionRepository/utils/prepareMessagePayloadForCache.ts

@@ -7,7 +7,7 @@ import { getActiveClient } from '~/client/api/activeClient';
  * add myReactions to http response if the event was a reaction event
  */
 export const prepareMessagePayloadForCache = (
-  payload: Amity.Message,
+  payload: Amity.InternalMessage,
   reactors: Amity.Reactor[],
   event: Pick<Amity.Events, 'message.reactionAdded' | 'message.reactionRemoved'> | string,
 ) => {

package/src/reactionRepository/utils/prepareReactionPayloadFormEvent.ts

@@ -1,7 +1,9 @@
 import { pullFromCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 
-const getMyReactionsInCache = <T extends Amity.PostPayload | Amity.CommentPayload>(
+const getMyReactionsInCache = <
+  T extends Amity.PostPayload | Amity.CommentPayload | Amity.StoryPayload,
+>(
   payload: T,
   eventPrefix: string,
 ) => {
@@ -14,14 +16,23 @@ const getMyReactionsInCache = <T extends Amity.PostPayload | Amity.CommentPayloa
   } else if (eventPrefix === 'comment') {
     domain = 'comment';
     id = (<Amity.PostPayload>payload).comments[0].commentId;
+  } else if (eventPrefix === 'story') {
+    domain = 'story';
+    id = (<Amity.StoryPayload>payload).stories[0].referenceId!;
   } else {
     throw new Error(`Unknown event type`);
   }
 
-  return pullFromCache<Amity.InternalComment>([domain, 'get', id])?.data?.myReactions || [];
+  const cached = pullFromCache<Amity.InternalComment | Amity.InternalStory>([domain, 'get', id])
+    ?.data?.myReactions;
+
+  return cached || [];
 };
 
-const rebuildPayload = <T extends Amity.PostPayload | Amity.CommentPayload, K extends keyof T>(
+const rebuildPayload = <
+  T extends Amity.PostPayload | Amity.CommentPayload | Amity.StoryPayload,
+  K extends keyof T,
+>(
   payload: T,
   payloadKey: K,
   myReactions: Amity.Reactable['myReactions'],
@@ -31,6 +42,31 @@ const rebuildPayload = <T extends Amity.PostPayload | Amity.CommentPayload, K ex
   return { ...payload, [payloadKey]: [{ ...model, myReactions }] };
 };
 
+const remappingMyReaction = (
+  event: string,
+  userId: string,
+  reactionName: string,
+  myReactions: Amity.Reactable['myReactions'] = [],
+) => {
+  const eventSuffix = event.split('.')[1]; // 'addReaction' | 'removeReaction' | 'reactionAdded' | 'reactionRemoved'
+
+  let newMyReactions = myReactions;
+
+  if (getActiveClient().userId === userId) {
+    if (['addReaction', 'reactionAdded'].includes(eventSuffix)) {
+      if (!newMyReactions.includes(reactionName)) {
+        newMyReactions.push(reactionName);
+      }
+    } else if (['removeReaction', 'reactionRemoved'].includes(eventSuffix)) {
+      newMyReactions = newMyReactions.filter(reaction => reaction !== reactionName);
+    } else {
+      throw new Error(`Unknown event type: ${eventSuffix}`);
+    }
+  }
+
+  return newMyReactions;
+};
+
 /** @hidden */
 export const prepareReactionPayloadFormEvent = <
   T extends
@@ -44,21 +80,38 @@ export const prepareReactionPayloadFormEvent = <
   payload: P,
 ): P => {
   const eventPrefix = event.split('.')[0]; // 'post' | 'comment'
-  const eventSuffix = event.split('.')[1]; // 'addReaction' | 'removeReaction'
+
+  const myReactions: Amity.Reactable['myReactions'] = getMyReactionsInCache(payload, eventPrefix);
+
+  const newMyReaction = remappingMyReaction(
+    event,
+    payload.reactor.userId,
+    payload.reactor.reactionName,
+    myReactions,
+  );
+
+  return rebuildPayload(payload, <keyof P>`${eventPrefix}s`, newMyReaction);
+};
+
+export const prepareStoryReactionPayloadFormEvent = <
+  T extends 'story.reactionAdded' | 'story.reactionRemoved',
+  P extends Amity.Events[T],
+>(
+  event: T,
+  payload: P,
+): P => {
+  const eventPrefix = event.split('.')[0]; // 'post' | 'comment' | 'story'
 
   let myReactions: Amity.Reactable['myReactions'] = getMyReactionsInCache(payload, eventPrefix);
 
-  if (getActiveClient().userId === payload.reactor.userId) {
-    if (eventSuffix === 'addReaction') {
-      if (!myReactions.includes(payload.reactor.reactionName)) {
-        myReactions.push(payload.reactor.reactionName);
-      }
-    } else if (eventSuffix === 'removeReaction') {
-      myReactions = myReactions.filter(reaction => reaction !== payload.reactor.reactionName);
-    } else {
-      throw new Error(`Unknown event type: ${eventSuffix}`);
-    }
+  if (payload?.reactions && payload.reactions.length > 0) {
+    myReactions = remappingMyReaction(
+      event,
+      payload.reactions[0]?.userId,
+      payload.reactions[0]?.reactionName,
+      myReactions,
+    );
   }
 
-  return rebuildPayload(payload, <keyof P>`${eventPrefix}s`, myReactions);
+  return rebuildPayload(payload, 'stories', myReactions);
 };

package/src/storyRepository/api/createImageStory.ts

@@ -50,8 +50,15 @@ export const createImageStory = async (
     metadata,
   };
 
+  const date = new Date();
   pushToCache([STORY_KEY_CACHE.SYNC_STATE, targetId], Amity.SyncState.Syncing);
 
+  // Update local story expires time
+  pushToCache(
+    [STORY_KEY_CACHE.EXPIRE, targetId],
+    new Date(date.setFullYear(date.getFullYear() + 1)),
+  );
+
   // Fire optimistic event
   createOptimisticEvent({ payload, formData }, optimisticData => {
     fireEvent('local.story.created', optimisticData);

package/src/storyRepository/api/createVideoStory.ts

@@ -47,8 +47,15 @@ export const createVideoStory = async (
     metadata,
   };
 
+  const date = new Date();
   pushToCache([STORY_KEY_CACHE.SYNC_STATE, targetId], Amity.SyncState.Syncing);
 
+  // Update local story expires time
+  pushToCache(
+    [STORY_KEY_CACHE.EXPIRE, targetId],
+    new Date(date.setFullYear(date.getFullYear() + 1)),
+  );
+
   // Fire optimistic event
   createOptimisticEvent({ payload, formData, isVideo: true }, optimisticData => {
     fireEvent('local.story.created', optimisticData);

package/src/storyRepository/constants.ts

@@ -1,7 +1,9 @@
 export const enum STORY_KEY_CACHE {
   STORY = 'story',
+  STORY_TARGET = 'storyTarget',
   SYNC_STATE = 'story-sync-state',
   STORY_TARGET_IDS = 'story-target-ids',
+  STORY_GLOBAL_FEED = 'story-global-feed',
   IS_SEEN = 'story-seen',
   LAST_SEEN = 'story-last-seen',
   EXPIRE = 'story-expire',

package/src/storyRepository/events/onStoryCreated.ts

@@ -1,14 +1,14 @@
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertStoryRawToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { convertRawStoryToInternal } from '~/storyRepository/utils/convertRawToStory';
 
 export const onStoryCreated = (callback: Amity.Listener<Amity.InternalStory[]>) => {
   const client = getActiveClient();
 
   const filter = async (payload: Amity.StoryPayload) => {
     // Apply the necessary field for story payload
-    const convertPayload = convertStoryRawToInternal(payload);
+    const convertPayload = convertRawStoryToInternal(payload, true);
     ingestInCache(convertPayload);
     callback(convertPayload.stories);
   };

package/src/storyRepository/events/onStoryDeleted.ts

@@ -1,13 +1,13 @@
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertStoryRawToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { convertRawStoryToInternal } from '~/storyRepository/utils/convertRawToStory';
 
 export const onStoryDeleted = (callback: Amity.Listener<Amity.InternalStory[]>) => {
   const client = getActiveClient();
 
   const filter = async (payload: Amity.StoryPayload) => {
-    const convertPayload = convertStoryRawToInternal(payload);
+    const convertPayload = convertRawStoryToInternal(payload);
     ingestInCache(convertPayload);
     callback(convertPayload.stories);
   };

package/src/storyRepository/events/onStoryReactionAdded.ts

@@ -1,15 +1,21 @@
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertStoryRawToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { convertRawStoryToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { prepareStoryReactionPayloadFormEvent } from '~/reactionRepository/utils';
 
 export const onStoryReactionAdded = (callback: Amity.Listener<Amity.InternalStory[]>) => {
   const client = getActiveClient();
 
-  const filter = async (payload: Amity.StoryPayload) => {
-    const convertPayload = convertStoryRawToInternal(payload);
-    ingestInCache(convertPayload);
-    callback(convertPayload.stories);
+  const filter = async (payload: Amity.Events['story.reactionAdded']) => {
+    const { reactions, ...rest } = payload;
+    const internalStory = convertRawStoryToInternal(rest);
+    const convertedPayload = prepareStoryReactionPayloadFormEvent('story.reactionAdded', {
+      ...internalStory,
+      reactions,
+    });
+    ingestInCache(convertedPayload);
+    callback(convertedPayload.stories);
   };
 
   const disposers = [

package/src/storyRepository/events/onStoryReactionRemoved.ts

@@ -1,15 +1,21 @@
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertStoryRawToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { convertRawStoryToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { prepareStoryReactionPayloadFormEvent } from '~/reactionRepository/utils';
 
 export const onStoryReactionRemoved = (callback: Amity.Listener<Amity.InternalStory[]>) => {
   const client = getActiveClient();
 
-  const filter = async (payload: Amity.StoryPayload) => {
-    const convertPayload = convertStoryRawToInternal(payload);
-    ingestInCache(convertPayload);
-    callback(convertPayload.stories);
+  const filter = async (payload: Amity.Events['story.reactionRemoved']) => {
+    const { reactions, ...rest } = payload;
+    const internalStory = convertRawStoryToInternal(rest);
+    const convertedPayload = prepareStoryReactionPayloadFormEvent('story.reactionRemoved', {
+      ...internalStory,
+      reactions,
+    });
+    ingestInCache(convertedPayload);
+    callback(convertedPayload.stories);
   };
 
   const disposers = [

package/src/storyRepository/events/onStoryUpdated.ts

@@ -1,14 +1,14 @@
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertStoryRawToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { convertRawStoryToInternal } from '~/storyRepository/utils/convertRawToStory';
 
 export const onStoryUpdated = (callback: Amity.Listener<Amity.InternalStory[]>) => {
   const client = getActiveClient();
 
   const filter = async (payload: Amity.StoryPayload) => {
     // Apply the necessary field for story payload
-    const convertPayload = convertStoryRawToInternal(payload);
+    const convertPayload = convertRawStoryToInternal(payload);
     ingestInCache(convertPayload);
     callback(convertPayload.stories);
   };

package/src/storyRepository/internalApi/createStory.ts

@@ -1,6 +1,6 @@
 import { getActiveClient } from '~/client';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertStoryRawToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { convertRawStoryToInternal } from '~/storyRepository/utils/convertRawToStory';
 import { fireEvent } from '~/core/events';
 import { pushToCache } from '~/cache/api';
 import { STORY_KEY_CACHE } from '~/storyRepository/constants';
@@ -13,7 +13,7 @@ export const createStory = async (
 
   const response = await client.http.post<Amity.StoryPayload>('/api/v4/stories', payload);
 
-  const convertedResponse = convertStoryRawToInternal(response.data);
+  const convertedResponse = convertRawStoryToInternal(response.data);
 
   if (client.cache) ingestInCache(convertedResponse);
 

package/src/storyRepository/internalApi/deleteStory.ts

@@ -15,7 +15,7 @@ export const deleteStory = async (
     cached = getStoryCache(storyId);
     if (cached?.data) {
       const { data } = cached;
-      fireEvent('story.deleted', {
+      fireEvent('local.story.deleted', {
         categories: [],
         comments: [],
         communities: [],

package/src/storyRepository/internalApi/getActiveStoriesByTarget.ts

@@ -1,6 +1,6 @@
 import { getActiveClient } from '~/client';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertStoryRawToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { convertRawStoryToInternal } from '~/storyRepository/utils/convertRawToStory';
 import { updateLocalLastStoryExpires } from '~/storyRepository/utils/updateLocalLastStoryExpires';
 import { mappingStoryIdToReferenceId } from '~/storyRepository/utils/mappingStoryIdToReferenceId';
 
@@ -24,7 +24,7 @@ export const getActiveStoriesByTarget = async ({
     },
   });
 
-  const convertedData: Amity.StoryPayload = convertStoryRawToInternal(response.data);
+  const convertedData: Amity.StoryPayload = convertRawStoryToInternal(response.data);
 
   if (client.cache) {
     ingestInCache(convertedData);

package/src/storyRepository/internalApi/getStoryByStoryId.ts

@@ -5,6 +5,7 @@ import { checkIfShouldGoesToTombstone } from '~/cache/utils';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { STORY_KEY_CACHE } from '~/storyRepository/constants';
+import { convertRawStoryToInternal } from '~/storyRepository/utils/convertRawToStory';
 
 export const getStoryByStoryId = async (
   storyId: Amity.Story['storyId'],
@@ -26,7 +27,7 @@ export const getStoryByStoryId = async (
 
   try {
     const response = await client.http.get<Amity.StoryPayload>(`/api/v4/stories/${storyId}`);
-    data = response.data;
+    data = convertRawStoryToInternal(response.data);
   } catch (error) {
     if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
       pushToTombstone('story', storyId);

package/src/storyRepository/observers/getActiveStoriesByTarget.ts

@@ -137,6 +137,7 @@ export const getActiveStoriesByTarget = (
 
   const processNewData = (
     result: Amity.InternalStory[] | undefined,
+    event: string,
     initial = false,
     loading = false,
     error = false,
@@ -151,9 +152,14 @@ export const getActiveStoriesByTarget = (
     };
 
     if (result) {
-      data.data = initial
-        ? result.map(getResolver('story'))
-        : [...new Set([...data.data, ...result.map(getResolver('story'))])];
+      if (event === Amity.StoryActionType.OnDelete) {
+        const deletedIds = result.map(({ referenceId }) => referenceId);
+        data.data = data.data.filter(refId => !deletedIds.includes(refId!)) || [];
+      } else {
+        data.data = initial
+          ? result.map(getResolver('story'))
+          : [...new Set([...data.data, ...result.map(getResolver('story'))])];
+      }
     }
 
     pushToCache(cacheKey, data.data);
@@ -162,7 +168,7 @@ export const getActiveStoriesByTarget = (
   };
 
   const realtimeRouter = (event: Amity.StoryActionType) => (story: Amity.InternalStory[]) => {
-    processNewData(story);
+    processNewData(story, event);
   };
 
   const reloadData = () => (newData: { referenceIds: Amity.Story['referenceId'][] }) => {
@@ -191,7 +197,7 @@ export const getActiveStoriesByTarget = (
     const query = createQuery(_getActiveStoriesByTarget, params);
 
     runQuery(query, ({ data: result, error, loading }) => {
-      processNewData(result, initial, loading, error);
+      processNewData(result, 'fetch', initial, loading, error);
     });
   };