@amityco/ts-sdk 6.17.1-e9b6af1.0 → 6.17.2-ea577e1.0

package/src/client/utils/markerSyncEngine.ts

@@ -8,7 +8,7 @@ import { onUserMarkerSync } from '~/marker/events/onUserMarkerSync';
 import { setIntervalTask } from '~/utils/timer';
 import { getUserMarker } from '~/marker/api';
 import { onFeedMarkerUpdated } from '~/marker/events';
-import { onMessageCreated } from '~/messageRepository/events';
+import { onMessageCreatedMqtt } from '~/messageRepository/events';
 import { onSubChannelCreated, onSubChannelDeleted } from '~/subChannelRepository/events';
 import { isUnreadCountSupport } from '~/subChannelRepository/utils';
 
@@ -22,25 +22,27 @@ let isSyncRunning = false;
 let disposers: (() => void)[] = [];
 let isWaitingForResponse = false;
 
-let deviceLastSyncAt: string | null = null;
+let deviceLastSyncAt: Date | null = null;
 
 const getDeviceLastSyncAt = () => {
   if (deviceLastSyncAt == null) {
-    return new Date().toISOString();
+    return new Date();
   }
 
   return deviceLastSyncAt;
 };
 
-const saveDeviceLastSyncAt = (lastSyncAt: string) => {
-  if (!deviceLastSyncAt || new Date(lastSyncAt).getTime() > new Date(deviceLastSyncAt).getTime()) {
+const saveDeviceLastSyncAt = (lastSyncAt: Date | null) => {
+  if (lastSyncAt == null) return;
+  if (!deviceLastSyncAt || lastSyncAt.getTime() > deviceLastSyncAt.getTime()) {
     deviceLastSyncAt = lastSyncAt;
   }
 };
 
 const fetchDeviceLastSyncAt = async () => {
   const { data: userMarker } = await getUserMarker();
-  saveDeviceLastSyncAt(userMarker.lastSyncAt);
+  if (userMarker == null) return;
+  saveDeviceLastSyncAt(new Date(userMarker.lastSyncAt));
 };
 
 /**
@@ -84,24 +86,41 @@ export const markerSyncTrigger = async () => {
     // no event that require to call marker sync API
     return;
   }
-
-  isWaitingForResponse = true;
-
-  // any past events are considered processed here.
-  // however during waiting for the response, RTE could add the new message event;
-  // which will make the engine trigger another call next round.
-  events = [];
-
-  const response = await markerSync(getDeviceLastSyncAt());
-
-  saveDeviceLastSyncAt(response.data.userMarkers[0].lastSyncAt);
-
-  if (response.hasMore) {
-    events.push(Amity.MarkerSyncEvent.HAS_MORE);
+  try {
+    isWaitingForResponse = true;
+    // any past events are considered processed here.
+    // however during waiting for the response, RTE could add the new message event;
+    // which will make the engine trigger another call next round.
+    events = [];
+
+    const response = await markerSync(getDeviceLastSyncAt().toISOString());
+
+    const latestLastSyncAt: Date | null = response.data.userMarkers.reduce(
+      (maxLastSyncAt, userMarker) => {
+        if (
+          maxLastSyncAt == null ||
+          maxLastSyncAt.getTime() < new Date(userMarker.lastSyncAt).getTime()
+        ) {
+          return new Date(userMarker.lastSyncAt);
+        }
+
+        return maxLastSyncAt;
+      },
+      null as Date | null,
+    );
+
+    saveDeviceLastSyncAt(latestLastSyncAt);
+
+    if (response.hasMore) {
+      events.push(Amity.MarkerSyncEvent.HAS_MORE);
+    }
+  } catch {
+    // prevent sync from stopping
+  } finally {
+    if (isWaitingForResponse) {
+      isWaitingForResponse = false;
+    }
   }
-
-  // eslint-disable-next-line require-atomic-updates
-  isWaitingForResponse = false;
 };
 
 const registerEventListeners = () => {
@@ -119,15 +138,10 @@ const registerEventListeners = () => {
       events.push(Amity.MarkerSyncEvent.RESUME);
     }),
 
-    onMessageCreated(
-      message => {
-        // only conversation, community and broadcast types can sync
-        if (isUnreadCountSupport(message)) events.push(Amity.MarkerSyncEvent.NEW_MESSAGE);
-      },
-      // only trigger sync from remote events to prevent an unread count equal `-1`
-      // when an optimistic message creation is performed.
-      false,
-    ),
+    onMessageCreatedMqtt(message => {
+      // only conversation, community and broadcast types can sync
+      if (isUnreadCountSupport(message)) events.push(Amity.MarkerSyncEvent.NEW_MESSAGE);
+    }),
 
     onChannelCreated(() => events.push(Amity.MarkerSyncEvent.CHANNEL_CREATED)),
     onChannelDeleted(() => events.push(Amity.MarkerSyncEvent.CHANNEL_DELETED)),

package/src/marker/api/getUserMarker.ts

@@ -4,7 +4,7 @@ import { fireEvent } from '~/core/events';
 // import { convertMarkerResponse } from '~/utils/marker';
 import { convertUserMarkerResponse } from '~/utils/marker';
 
-export const getUserMarker = async (): Promise<Amity.Cached<Amity.UserMarker>> => {
+export const getUserMarker = async (): Promise<Amity.Cached<Amity.UserMarker | null>> => {
   const client = getActiveClient();
   client.log('channel/getUserMarker');
 
@@ -14,8 +14,8 @@ export const getUserMarker = async (): Promise<Amity.Cached<Amity.UserMarker>> =
 
   const { userMarkers: UserMarkersPayload } = payload;
 
-  /* 
-    change field isMentioned from backend to be hasMentioned 
+  /*
+    change field isMentioned from backend to be hasMentioned
   */
   const userMarkers = convertUserMarkerResponse(UserMarkersPayload);
 
@@ -24,5 +24,16 @@ export const getUserMarker = async (): Promise<Amity.Cached<Amity.UserMarker>> =
 
   fireEvent('local.userMarker.fetched', { userMarkers });
 
-  return { data: userMarkers[0], cachedAt };
+  const latestUserMarker = userMarkers.reduce((maxUserMarker, userMarker) => {
+    if (
+      maxUserMarker == null ||
+      new Date(maxUserMarker.lastSyncAt).getTime() < new Date(userMarker.lastSyncAt).getTime()
+    ) {
+      return userMarker;
+    }
+
+    return maxUserMarker;
+  }, null as Amity.UserMarker | null);
+
+  return { data: latestUserMarker, cachedAt };
 };

package/src/marker/events/onChannelMarkerFetched.ts

@@ -22,7 +22,9 @@ export const onChannelMarkerFetched = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.Events['local.channelMarker.fetched']) => {
-    callback(payload.userEntityMarkers[0]);
+    payload.userEntityMarkers.forEach(marker => {
+      callback(marker);
+    });
   };
 
   return createEventSubscriber(

package/src/marker/events/onUserMarkerFetched.ts

@@ -17,6 +17,23 @@ import { createEventSubscriber } from '~/core/events';
  * @category UserMarker Events
  */
 export const onUserMarkerFetched = (
+  callback: Amity.Listener<Amity.UserMarker[]>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.userMarker.fetched']) => {
+    callback(payload.userMarkers);
+  };
+
+  return createEventSubscriber(
+    client,
+    'userMarker/onUserMarkerFetched',
+    'local.userMarker.fetched',
+    filter,
+  );
+};
+
+export const onUserMarkerFetchedLegacy = (
   callback: Amity.Listener<Amity.UserMarker>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();

package/src/messageRepository/api/tests/createMessage.test.ts

@@ -5,7 +5,7 @@ import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/a
 import { client, convertRawMessage, generateRawMessage, pause } from '~/utils/tests';
 import { createQuery, runQuery } from '~/core/query';
 
-import { onMessageCreated } from '../../events';
+import { onMessageCreatedMqtt } from '../../events';
 import { createMessage } from '../createMessage';
 import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
 
@@ -72,7 +72,7 @@ describe('createMessage', () => {
     client.http.post = jest.fn().mockResolvedValueOnce(response);
 
     const callbackPromise = new Promise(resolve => {
-      dispose = onMessageCreated(resolve);
+      dispose = onMessageCreatedMqtt(resolve);
     }).finally(dispose);
 
     await createMessage(messageWithoutId);
@@ -134,7 +134,7 @@ describe('createMessage.optimistically', () => {
     let dispose;
 
     const callbackPromise = new Promise(resolve => {
-      dispose = onMessageCreated(resolve);
+      dispose = onMessageCreatedMqtt(resolve);
     }).finally(dispose);
 
     createMessage.optimistically(messageWithoutId);
@@ -193,7 +193,7 @@ describe('uniqueId / referenceId', () => {
     };
     const callback = jest.fn();
 
-    onMessageCreated(callback);
+    onMessageCreatedMqtt(callback);
     client.emitter.emit('message.created', {
       messages: [rawNewMessage],
       messageFeeds: [],

package/src/messageRepository/events/onMessageCreated.ts

@@ -19,31 +19,43 @@ import { prepareMessagePayload } from '../utils';
  *
  * @category Message Events
  */
-export const onMessageCreated = (
+export const onMessageCreatedMqtt = (
   callback: Amity.Listener<Amity.Message>,
-  local = true,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = async (rawPayload: Amity.MessagePayload) => {
     const payload = await prepareMessagePayload(rawPayload);
-    const message = payload.messages[0];
 
     // Update in cache
     ingestInCache(payload);
 
-    callback(message);
+    payload.messages.forEach(message => {
+      callback(message);
+    });
   };
 
   const disposers = [
     createEventSubscriber(client, 'message/onMessageCreated', 'message.created', filter),
   ];
 
-  if (local) {
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};
+
+export const onMessageCreatedLocal = (
+  callback: Amity.Listener<Amity.Message>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const disposers = [
     createEventSubscriber(client, 'message/onMessageCreated', 'local.message.created', payload =>
-      callback(payload.messages[0]),
-    );
-  }
+      payload.messages.forEach(message => {
+        callback(message);
+      }),
+    ),
+  ];
 
   return () => {
     disposers.forEach(fn => fn());

package/src/messageRepository/events/tests/events.test.ts

@@ -1,7 +1,7 @@
 import { client, generateRawMessage, pause } from '~/utils/tests';
 import { convertFromRaw } from '~/messageRepository/utils';
 import {
-  onMessageCreated,
+  onMessageCreatedMqtt,
   onMessageUpdated,
   onMessageDeleted,
   onMessageFlagged,
@@ -18,7 +18,7 @@ describe('Message Events', () => {
   const cases: Array<
     [(callback: Amity.Listener<Amity.Message>) => Amity.Unsubscriber, keyof Amity.MqttMessageEvents]
   > = [
-    [onMessageCreated, 'message.created'],
+    [onMessageCreatedMqtt, 'message.created'],
     [onMessageUpdated, 'message.updated'],
     [onMessageDeleted, 'message.deleted'],
     [onMessageFlagged, 'message.flagged'],

package/src/messageRepository/observers/getMessages/MessageLiveCollectionController.ts

@@ -3,7 +3,7 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { MessagePaginationController } from './MessagePaginationController';
 import { MessageQueryStreamController } from './MessageQueryStreamController';
 import {
-  onMessageCreated,
+  onMessageCreatedMqtt,
   onMessageDeleted,
   onMessageFlagCleared,
   onMessageFlagged,
@@ -75,7 +75,7 @@ export class MessageLiveCollectionController extends LiveCollectionController<
 
   startSubscription() {
     return this.queryStreamController.subscribeRTE([
-      { fn: onMessageCreated, action: 'onCreate' },
+      { fn: onMessageCreatedMqtt, action: 'onCreate' },
       { fn: onMessageDeleted, action: 'onDelete' },
       { fn: onMessageUpdated, action: 'onUpdate' },
       { fn: onMessageFlagged, action: 'onFlagged' },

package/src/messageRepository/observers/observeMessages.ts

@@ -2,7 +2,12 @@ import { getActiveClient } from '~/client/api';
 import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
 import { convertEventPayload } from '~/utils/event';
 
-import { onMessageCreated, onMessageUpdated, onMessageDeleted } from '../events';
+import {
+  onMessageCreatedMqtt,
+  onMessageUpdated,
+  onMessageDeleted,
+  onMessageCreatedLocal,
+} from '../events';
 
 /**
  * ```js
@@ -48,7 +53,8 @@ export const observeMessages = (
   };
 
   disposers.push(
-    onMessageCreated(data => router({ data, loading: false, origin: 'event' }, 'onCreate')),
+    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')),
     convertEventPayload(

package/src/messageRepository/utils/prepareMessagePayload.ts

@@ -92,6 +92,9 @@ const preUpdateMessageCache = (rawPayload: Amity.MessagePayload) => {
   });
 };
 
+const DEBOUNCE_TIME = 2000;
+const currentDebounceMap: Record<string, NodeJS.Timeout | undefined> = {};
+
 export const prepareMessagePayload = async (
   payload: Amity.MessagePayload,
   event?: keyof Amity.MqttMessageEvents,
@@ -102,11 +105,18 @@ export const prepareMessagePayload = async (
     // since the get markers method requires a channel cache to function with the reducer.
     preUpdateMessageCache(payload);
 
-    try {
-      await getMessageMarkers(markerIds);
-    } catch (e) {
-      // empty block (from the spec, allow marker fetch to fail without having to do anything)
+    const markerIdsKey = markerIds.join('');
+
+    if (currentDebounceMap[markerIdsKey]) {
+      clearTimeout(currentDebounceMap[markerIdsKey]);
     }
+    currentDebounceMap[markerIdsKey] = setTimeout(() => {
+      try {
+        getMessageMarkers(markerIds);
+      } catch (_error) {
+        // do nothing
+      }
+    }, DEBOUNCE_TIME);
   }
 
   const { messageFeeds, ...restPayload } = payload;

package/src/storyRepository/constants.ts

@@ -1,6 +1,7 @@
 export const enum STORY_KEY_CACHE {
   STORY = 'story',
   SYNC_STATE = 'story-sync-state',
+  STORY_TARGET_IDS = 'story-target-ids',
   IS_SEEN = 'story-seen',
   LAST_SEEN = 'story-last-seen',
   EXPIRE = 'story-expire',

package/src/storyRepository/observers/getStoriesByTargetIds/StoryLiveCollectionController.ts

@@ -0,0 +1,113 @@
+import hash from 'object-hash';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { LinkedObject } from '~/utils/linkedObject';
+import { sortByFirstCreated, sortByLastCreated } from '~/core/query';
+import { onStoryCreated } from '~/storyRepository/events/onStoryCreated';
+import { onStoryUpdated } from '~/storyRepository/events/onStoryUpdated';
+import { onStoryDeleted } from '~/storyRepository/events/onStoryDeleted';
+import { onStoryError } from '~/storyRepository/events/onStoryError';
+import { STORY_KEY_CACHE } from '~/storyRepository/constants';
+import { StoryQueryStreamController } from './StoryQueryStreamController';
+import { StoryPaginationNoPageController } from './StoryPaginationNoPageController';
+
+export class StoryLiveCollectionController extends LiveCollectionController<
+  'story',
+  Amity.StoryLiveCollection,
+  Amity.Story,
+  StoryPaginationNoPageController
+> {
+  private queryStreamController: StoryQueryStreamController;
+
+  private query: Amity.StoryLiveCollection;
+
+  constructor(
+    query: Amity.StoryLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Story>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = [STORY_KEY_CACHE.STORY_TARGET_IDS, 'collection', queryStreamId];
+    const paginationController = new StoryPaginationNoPageController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+
+    this.queryStreamController = new StoryQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      paginationController,
+    );
+
+    this.paginationController = paginationController;
+    this.callback = callback.bind(this);
+    this.loadPage(true);
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.StoryLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected persistModel(response: Amity.StoryPayload) {
+    this.queryStreamController.saveToMainDB(response);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'story'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.StoryLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    let data = collection.data
+      .map(
+        referenceId =>
+          pullFromCache<Amity.InternalStory>([STORY_KEY_CACHE.STORY, 'get', referenceId])!, // Story use referenceId instead of storyId
+      )
+      .filter(Boolean)
+      .map(internStory => LinkedObject.story(internStory.data));
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    data = this.applyFilter(data);
+
+    this.callback({
+      onNextPage: undefined,
+      data,
+      hasNextPage: false,
+      loading,
+      error,
+    });
+  }
+
+  private applyFilter(data: Amity.Story[]) {
+    const internalStories = data;
+
+    const orderBy = this.query?.options?.orderBy || 'desc';
+
+    return orderBy === 'asc'
+      ? internalStories.sort(sortByFirstCreated)
+      : internalStories.sort(sortByLastCreated);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onStoryCreated, action: Amity.StoryActionType.OnCreate },
+      { fn: onStoryUpdated, action: Amity.StoryActionType.OnUpdate },
+      { fn: onStoryDeleted, action: Amity.StoryActionType.OnDelete },
+      { fn: onStoryError, action: Amity.StoryActionType.OnError },
+    ]);
+  }
+}

package/src/storyRepository/observers/getStoriesByTargetIds/StoryPaginationNoPageController.ts

@@ -0,0 +1,18 @@
+/* eslint-disable no-use-before-define */
+
+import { PaginationNoPageController } from '~/core/liveCollection/PaginationNoPageController';
+
+export class StoryPaginationNoPageController extends PaginationNoPageController<
+  'story',
+  Pick<Amity.StoryLiveCollection, 'targets'>
+> {
+  async getRequest(queryParams: Pick<Amity.StoryLiveCollection, 'targets'>) {
+    const { data: queryResponse } = await this.http.get<Amity.StoryPayload>(
+      '/api/v4/stories-by-targets',
+      {
+        params: { ...queryParams },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/storyRepository/observers/getStoriesByTargetIds/StoryQueryStreamController.ts

@@ -0,0 +1,97 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { updateLocalLastStoryExpires } from '~/storyRepository/utils/updateLocalLastStoryExpires';
+import { mappingStoryIdToReferenceId } from '~/storyRepository/utils/mappingStoryIdToReferenceId';
+import { convertStoryRawToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { StoryPaginationNoPageController } from './StoryPaginationNoPageController';
+
+export class StoryQueryStreamController extends QueryStreamController<
+  Amity.StoryPayload,
+  Amity.StoryLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private paginationController: StoryPaginationNoPageController;
+
+  constructor(
+    query: Amity.StoryLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    paginationController: StoryPaginationNoPageController,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.paginationController = paginationController;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  saveToMainDB(response: Amity.StoryPayload) {
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    const convertedData: Amity.StoryPayload = convertStoryRawToInternal(response);
+
+    if (client.cache) {
+      ingestInCache(convertedData, { cachedAt });
+
+      // Update local last story expires
+      updateLocalLastStoryExpires(convertedData.stories);
+
+      // Map storyId to referenceId
+      mappingStoryIdToReferenceId(convertedData.stories);
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  getStoryReferenceIds(story: Amity.RawStory) {
+    if (story?.referenceId) {
+      return story.referenceId;
+    }
+    return story.storyId;
+  }
+
+  appendToQueryStream(
+    response: Amity.StoryPayload,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.stories.map(this.getStoryReferenceIds),
+      });
+    } else {
+      const collection = pullFromCache<Amity.StoryLiveCollectionCache>(this.cacheKey)?.data;
+      const stories = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...stories, ...response.stories.map(this.getStoryReferenceIds)])],
+      });
+    }
+  }
+
+  reactor(action: Amity.StoryActionType) {
+    return (payload: Amity.InternalStory[]) => {
+      const collection = pullFromCache<Amity.StoryLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      const newReferenceIds = payload.map(({ referenceId }) => referenceId);
+
+      collection.data = [...new Set([...newReferenceIds, ...collection.data])];
+      pushToCache(this.cacheKey, collection);
+
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: Amity.Listener<Amity.InternalStory[]>) => Amity.Unsubscriber;
+      action: Amity.StoryActionType;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/storyRepository/observers/getStoriesByTargetIds/getStoriesByTargetIds.ts

@@ -0,0 +1,32 @@
+import { dropFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { StoryLiveCollectionController } from './StoryLiveCollectionController';
+
+export const getStoriesByTargetIds = (
+  params: { targets: Amity.StoryTargetQueryParam[]; options?: Amity.StorySortOption },
+  callback: Amity.LiveCollectionCallback<Amity.Story>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache, userId } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getStoriesByTargetIds(tmpid: ${timestamp}) > listen`);
+
+  const storyLiveCollection = new StoryLiveCollectionController(params, callback);
+  const disposers = storyLiveCollection.startSubscription();
+  const cacheKey = storyLiveCollection.getCacheKey();
+
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
+
+  return () => {
+    log(`getStoriesByTargetIds(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/storyRepository/observers/getStoriesByTargetIds/index.ts

@@ -0,0 +1 @@
+export * from './getStoriesByTargetIds';

package/src/storyRepository/observers/index.ts

@@ -2,3 +2,4 @@ export * from './getActiveStoriesByTarget';
 export * from './getStoryByStoryId';
 export * from './getTargetById';
 export * from './getTargetsByTargetIds';
+export * from './getStoriesByTargetIds';