@amityco/ts-sdk-react-native 6.23.0 → 6.23.1-d8b4c4c.0

package/src/streamRepository/observers/getStreams/GetStreamsLiveCollectionController.ts

@@ -0,0 +1,114 @@
+import hash from 'object-hash';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { LinkedObject } from '~/utils/linkedObject';
+import { filterByPropEquality, sortByFirstCreated, sortByLastCreated } from '~/core/query';
+import {
+  onStreamFlagged,
+  onStreamRecorded,
+  onStreamStarted,
+  onStreamStopped,
+  onStreamTerminated,
+} from '~/streamRepository/events';
+import { GetStreamsPageController } from '~/streamRepository/observers/getStreams/GetStreamsPageController';
+import { GetStreamsQueryStreamController } from '~/streamRepository/observers/getStreams/GetStreamsQueryStreamController';
+
+export class GetStreamsLiveCollectionController extends LiveCollectionController<
+  'stream',
+  Amity.StreamLiveCollection,
+  Amity.Stream,
+  GetStreamsPageController
+> {
+  private queryStreamController: GetStreamsQueryStreamController;
+
+  private query: Amity.StreamLiveCollection;
+
+  constructor(
+    query: Amity.StreamLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Stream>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['streams', 'collection', queryStreamId];
+    const paginationController = new GetStreamsPageController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+
+    this.queryStreamController = new GetStreamsQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      paginationController,
+    );
+
+    this.paginationController = paginationController;
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.StreamLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    let data = collection.data
+      .map(streamId => pullFromCache<Amity.InternalStream>(['stream', 'get', streamId])!)
+      .filter(Boolean)
+      .map(stream => LinkedObject.stream(stream.data));
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    data = this.applyFilter(data);
+
+    this.callback({
+      onNextPage: () =>
+        this.loadPage({ initial: false, direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onStreamRecorded, action: 'onStreamRecorded' },
+      { fn: onStreamStarted, action: 'onStreamStarted' },
+      { fn: onStreamStopped, action: 'onStreamStopped' },
+      { fn: onStreamFlagged, action: 'onStreamFlagged' },
+      { fn: onStreamTerminated, action: 'onStreamTerminated' },
+    ]);
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.StreamLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected persistModel(response: Amity.StreamPayload) {
+    this.queryStreamController.saveToMainDB(response);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'stream'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  private applyFilter = (data: Amity.InternalStream[]): Amity.InternalStream[] => {
+    let streams = filterByPropEquality(data, 'isDeleted', this.query.isDeleted);
+
+    streams = streams.sort(
+      this.query.sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+    );
+
+    return streams;
+  };
+}

package/src/streamRepository/observers/getStreams/GetStreamsPageController.ts

@@ -0,0 +1,23 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+export class GetStreamsPageController extends PaginationController<
+  'stream',
+  Amity.StreamLiveCollection
+> {
+  async getRequest(queryParams: Amity.StreamLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<
+      { results: Amity.StreamPayload } & Amity.Pagination
+    >(`/api/v3/video-streaming`, {
+      params: {
+        ...params,
+        options,
+      },
+    });
+
+    return { ...queryResponse.results, paging: queryResponse.paging };
+  }
+}

package/src/streamRepository/observers/getStreams/GetStreamsQueryStreamController.ts

@@ -0,0 +1,83 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { getActiveClient } from '~/client';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { GetStreamsPageController } from '~/streamRepository/observers/getStreams/GetStreamsPageController';
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+export class GetStreamsQueryStreamController extends QueryStreamController<
+  Amity.StreamPayload,
+  Amity.StreamLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private paginationController: GetStreamsPageController;
+
+  constructor(
+    query: Amity.StreamLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    paginationController: GetStreamsPageController,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.paginationController = paginationController;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  saveToMainDB(response: Amity.StreamPayload) {
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(response, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.StreamPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.videoStreamings.map(getResolver('stream')),
+        query: this.query,
+      });
+    } else {
+      const collection = pullFromCache<Amity.StreamLiveCollectionCache>(this.cacheKey)?.data;
+
+      const messages = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data:
+          direction === 'next'
+            ? [...new Set([...messages, ...response.videoStreamings.map(getResolver('stream'))])]
+            : [...new Set([...response.videoStreamings.map(getResolver('stream')), ...messages])],
+      });
+    }
+  }
+
+  reactor(action: string) {
+    return (payload: Amity.InternalStream) => {
+      const collection = pullFromCache<Amity.StreamLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      collection.data = [...new Set([payload.streamId, ...collection.data])];
+
+      pushToCache(this.cacheKey, collection);
+
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: Amity.Listener<Amity.InternalStream>) => Amity.Unsubscriber;
+      action: string;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/streamRepository/observers/getStreams/getStreams.ts

@@ -0,0 +1,32 @@
+import { getActiveClient } from '~/client';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { dropFromCache } from '~/cache/api';
+import { GetStreamsLiveCollectionController } from '~/streamRepository/observers/getStreams/GetStreamsLiveCollectionController';
+
+export const getStreams = (
+  params: Amity.StreamLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Stream>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache, userId } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getStreams(tmpid: ${timestamp}) > listen`);
+
+  const liveCollection = new GetStreamsLiveCollectionController(params, callback);
+  const disposers = liveCollection.startSubscription();
+  const cacheKey = liveCollection.getCacheKey();
+
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
+
+  return () => {
+    log(`getStreams(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/streamRepository/observers/getStreams/index.ts

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

package/src/streamRepository/observers/tests/getStreamById.test.ts

@@ -6,7 +6,7 @@ const STREAM_ID = streamResponse.data.videoStreamings[0].streamId;
 
 const getSnapshot = (params?: Record<string, any>) => {
   return {
-    data: undefined as undefined | Amity.Stream,
+    data: undefined as undefined | Amity.InternalStream,
     loading: true,
     error: undefined as any,
     ...params,

package/src/subChannelRepository/observers/getSubChannel.ts

@@ -20,7 +20,7 @@ import { getActiveClient } from '~/client';
 import { getSubChannelMessagePreviewWithUser } from '~/messagePreview/utils';
 import { isEqual } from '~/utils/isEqual';
 import { updateSubChannelCache } from '../utils/updateSubChannelCache';
-import { onUserFeedMarkerUpdated } from '~/marker/events/onUserFeedMarkerUpdated';
+import { onSubChannelUnreadUpdatedLocal } from '~/marker/events/onSubChannelUnreadUpdatedLocal';
 
 /* begin_public_function
   id: subchannel.get
@@ -221,7 +221,7 @@ export const getSubChannel = (
         'subChannelId',
         'subChannel',
       ),
-      convertEventPayload(onUserFeedMarkerUpdated, 'feedId', 'subChannel'),
+      convertEventPayload(onSubChannelUnreadUpdatedLocal, 'subChannelId', 'subChannel'),
     ],
     {
       forceDispatch: true,

package/src/subChannelRepository/observers/getSubChannels/SubChannelLiveCollectionController.ts

@@ -29,7 +29,7 @@ import { getSubChannel } from '~/subChannelRepository/api/getSubChannel';
 import { updateSubChannelCache } from '~/subChannelRepository/utils/updateSubChannelCache';
 import { prepareSubChannelPayload } from '~/subChannelRepository/utils';
 import { onSubChannelFetched } from '~/subChannelRepository/events/onSubChannelFetched';
-import { onUserFeedMarkerUpdated } from '~/marker/events/onUserFeedMarkerUpdated';
+import { onSubChannelUnreadUpdatedLocal } from '~/marker/events/onSubChannelUnreadUpdatedLocal';
 
 export class SubChannelLiveCollectionController extends LiveCollectionController<
   'subChannel',
@@ -59,7 +59,7 @@ export class SubChannelLiveCollectionController extends LiveCollectionController
       prepareSubChannelPayload,
     );
     this.callback = callback.bind(this);
-    this.loadPage(true);
+    this.loadPage({ initial: true });
   }
 
   protected setup() {
@@ -294,7 +294,7 @@ export class SubChannelLiveCollectionController extends LiveCollectionController
         action: 'onUpdate',
       },
       {
-        fn: convertEventPayload(onUserFeedMarkerUpdated, 'feedId', 'subChannel'),
+        fn: convertEventPayload(onSubChannelUnreadUpdatedLocal, 'subChannelId', 'subChannel'),
         action: 'onUpdate',
       },
     ]);
@@ -315,7 +315,7 @@ export class SubChannelLiveCollectionController extends LiveCollectionController
     if (!this.shouldNotify(data) && origin === 'event') return;
 
     this.callback({
-      onNextPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.NEXT),
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
       data,
       hasNextPage: !!this.paginationController.getNextToken(),
       loading,

package/src/utils/linkedObject/index.ts

@@ -1,4 +1,5 @@
 import { storyLinkedObject } from '~/utils/linkedObject/storyLinkedObject';
+import { streamLinkedObject } from '~/utils/linkedObject/streamLinkedObject';
 import { categoryLinkedObject } from './categoryLinkedObject';
 import { commentLinkedObject } from './commentLinkedObject';
 import { userLinkedObject } from './userLinkedObject';
@@ -13,6 +14,7 @@ export const LinkedObject = {
   post: postLinkedObject,
   user: userLinkedObject,
   category: categoryLinkedObject,
+  stream: streamLinkedObject,
   story: storyLinkedObject,
   storyTarget: storyTargetLinkedObject,
   message: messageLinkedObject,

package/src/utils/linkedObject/streamLinkedObject.ts

@@ -0,0 +1,11 @@
+import { pullFromCache } from '~/cache/api';
+
+export const streamLinkedObject = (stream: Amity.InternalStream): Amity.Stream => {
+  return {
+    ...stream,
+    get moderation() {
+      return pullFromCache<Amity.StreamModeration>(['streamModeration', 'get', stream.streamId])
+        ?.data;
+    },
+  };
+};

package/src/utils/liveObject.ts

@@ -10,6 +10,9 @@ import { convertGetterPropsToStatic } from '~/utils/object';
 
 import { isEqual } from './isEqual';
 
+/**
+ * @deprecated This function is deprecated
+ */
 export const liveObject = <
   T extends Amity.Model,
   K extends keyof T,

package/dist/streamRepository/api/getStreams.d.ts

@@ -1,39 +0,0 @@
-/**
- * ```js
- * import { getStreams } from '@amityco/ts-sdk-react-native'
- * const streams = await getStreams()
- * ```
- *
- * Queries a paginable list of {@link Amity.Stream} objects
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Stream} objects
- *
- * @category Stream API
- * @async
- */
-export declare const getStreams: {
-    (query?: {
-        isLive?: boolean;
-        statuses?: Amity.StreamStatus[];
-        userPublicIds?: Amity.InternalUser['userId'][];
-        sortBy?: 'lastCreated' | 'firstCreated';
-        isDeleted?: Amity.Stream['isDeleted'];
-        page?: Amity.Page;
-    }): Promise<Amity.Cached<Amity.Paged<Amity.Stream>>>;
-    /**
-     * ```js
-     * import { getStreams } from '@amityco/ts-sdk-react-native'
-     * const streams = getStreams.locally()
-     * ```
-     *
-     * Queries a paginable list of {@link Amity.Stream} objects from cache
-     *
-     * @param query The query parameters
-     * @returns streams
-     *
-     * @category Stream API
-     */
-    locally(query: Parameters<typeof getStreams>[0]): void;
-};
-//# sourceMappingURL=getStreams.d.ts.map

package/dist/streamRepository/api/getStreams.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getStreams.d.ts","sourceRoot":"","sources":["../../../src/streamRepository/api/getStreams.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU;aAAkB;QACvC,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,YAAY,EAAE,CAAC;QAChC,aAAa,CAAC,EAAE,MAAM,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC/C,MAAM,CAAC,EAAE,aAAa,GAAG,cAAc,CAAC;QACxC,SAAS,CAAC,EAAE,MAAM,MAAM,CAAC,WAAW,CAAC,CAAC;QACtC,IAAI,CAAC,EAAE,MAAM,IAAI,CAAC;KACnB,GAAG,QAAQ,MAAM,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,MAAM,CAAC,CAAC,CAAC;IAiCpD;;;;;;;;;;;;OAYG;mBAC0B,WAAW,iBAAiB,CAAC,CAAC,CAAC,CAAC;CAhB5D,CAAC"}

package/dist/streamRepository/observers/getStreams.d.ts

@@ -1,17 +0,0 @@
-/**
- * ```js
- * import { StreamRepository } from '@amityco/ts-sdk-react-native'
- * const streams = await StreamRepository.getStreams()
- * ```
- *
- * Observe all mutations on a list of {@link Amity.Stream}s
- *
- * @param params for querying streams
- * @param callback the function to call when new data are available
- * @param config
- * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the streams
- *
- * @category Stream Live Collection
- */
-export declare const getStreams: (params: Amity.StreamLiveCollection, callback: Amity.LiveCollectionCallback<Amity.Stream>, config?: Amity.LiveCollectionConfig) => () => void;
-//# sourceMappingURL=getStreams.d.ts.map

package/dist/streamRepository/observers/getStreams.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getStreams.d.ts","sourceRoot":"","sources":["../../../src/streamRepository/observers/getStreams.ts"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,WACb,MAAM,oBAAoB,YACxB,MAAM,sBAAsB,CAAC,MAAM,MAAM,CAAC,WAC3C,MAAM,oBAAoB,eA0GpC,CAAC"}

package/src/streamRepository/api/getStreams.ts

@@ -1,81 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { toPage, toToken } from '~/core/query';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-/* begin_public_function
-  id: stream.query
-*/
-/**
- * ```js
- * import { getStreams } from '@amityco/ts-sdk-react-native'
- * const streams = await getStreams()
- * ```
- *
- * Queries a paginable list of {@link Amity.Stream} objects
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Stream} objects
- *
- * @category Stream API
- * @async
- */
-export const getStreams = async (query?: {
-  isLive?: boolean;
-  statuses?: Amity.StreamStatus[];
-  userPublicIds?: Amity.InternalUser['userId'][];
-  sortBy?: 'lastCreated' | 'firstCreated';
-  isDeleted?: Amity.Stream['isDeleted'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Stream>>> => {
-  const client = getActiveClient();
-  client.log('stream/getStreams', query);
-
-  const { page, ...params } = query ?? {};
-
-  const { data } = await client.http.get<{ results: Amity.StreamPayload } & Amity.Pagination>(
-    `/api/v3/video-streaming`,
-    {
-      params: {
-        ...params,
-        options: {
-          token: toToken(page, 'skiplimit'),
-        },
-      },
-    },
-  );
-
-  // API-FIX: backend to response Amity.Response: const { paging, videoStreamings } = unwrapPayload(data)
-  // API-FIX: seems returned data has a results identifier on top of data, like no other apis, and this is beautiful
-  const { paging, results: payload } = data;
-  const { videoStreamings } = payload;
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(payload as Amity.StreamPayload, { cachedAt });
-
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
-
-  return { data: videoStreamings, cachedAt, prevPage, nextPage };
-};
-/* end_public_function */
-
-/**
- * ```js
- * import { getStreams } from '@amityco/ts-sdk-react-native'
- * const streams = getStreams.locally()
- * ```
- *
- * Queries a paginable list of {@link Amity.Stream} objects from cache
- *
- * @param query The query parameters
- * @returns streams
- *
- * @category Stream API
- */
-getStreams.locally = (query: Parameters<typeof getStreams>[0]) => {
-  const client = getActiveClient();
-  client.log('stream/getStreams.locally', query);
-
-  // TODO
-};

package/src/streamRepository/observers/getStreams.ts

@@ -1,152 +0,0 @@
-/* eslint-disable no-use-before-define */
-import { getResolver } from '~/core/model';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { getActiveClient } from '~/client/api';
-
-import {
-  createQuery,
-  filterByPropEquality,
-  queryOptions,
-  runQuery,
-  sortByFirstCreated,
-  sortByLastCreated,
-} from '~/core/query';
-
-import {
-  COLLECTION_DEFAULT_CACHING_POLICY,
-  COLLECTION_DEFAULT_PAGINATION_LIMIT,
-  ENABLE_CACHE_MESSAGE,
-} from '~/utils/constants';
-
-import { queryStreams as _queryStreams } from '../internalApi/queryStreams';
-import { onStreamRecorded, onStreamStarted, onStreamStopped } from '../events';
-
-/* begin_public_function
-  id: stream.query
-*/
-/**
- * ```js
- * import { StreamRepository } from '@amityco/ts-sdk-react-native'
- * const streams = await StreamRepository.getStreams()
- * ```
- *
- * Observe all mutations on a list of {@link Amity.Stream}s
- *
- * @param params for querying streams
- * @param callback the function to call when new data are available
- * @param config
- * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the streams
- *
- * @category Stream Live Collection
- */
-export const getStreams = (
-  params: Amity.StreamLiveCollection,
-  callback: Amity.LiveCollectionCallback<Amity.Stream>,
-  config?: Amity.LiveCollectionConfig,
-) => {
-  const { log, cache } = getActiveClient();
-
-  if (!cache) {
-    console.log(ENABLE_CACHE_MESSAGE);
-  }
-
-  const timestamp = Date.now();
-  log(`getStreams(tmpid: ${timestamp}) > listen`);
-
-  const { limit: queryLimit, ...queryParams } = params;
-
-  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
-  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
-
-  const disposers: Amity.Unsubscriber[] = [];
-  const cacheKey = ['streams', 'collection', params];
-
-  const applyFilter = (data: Amity.Stream[]): Amity.Stream[] => {
-    let streams = filterByPropEquality(data, 'isDeleted', params.isDeleted);
-
-    streams = streams.sort(
-      params.sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
-    );
-
-    return streams;
-  };
-
-  const responder = (data: Amity.StreamLiveCollectionCache, isEventModel = false) => {
-    const streams: Amity.Stream[] =
-      data.data
-        .map(streamId => {
-          return pullFromCache<Amity.Stream>(['stream', 'get', streamId])!;
-        })
-        .filter(Boolean)
-        .map(({ data }) => data) ?? [];
-
-    callback({
-      onNextPage: onFetch,
-      /*
-       * Only apply filter to RTE Model
-       */
-      data: isEventModel ? applyFilter(streams) : streams,
-      hasNextPage: !!data.params?.page,
-      loading: data.loading,
-      error: data.error,
-    });
-  };
-
-  const realtimeRouter = (_: Amity.StreamActionType) => (stream: Amity.Stream) => {
-    const collection = pullFromCache<Amity.StreamLiveCollectionCache>(cacheKey)?.data;
-    if (!collection) return;
-
-    collection.data = [...new Set([stream.streamId, ...collection.data])];
-
-    pushToCache(cacheKey, collection);
-    responder(collection, true);
-  };
-
-  const onFetch = (initial = false) => {
-    const collection = pullFromCache<Amity.StreamLiveCollectionCache>(cacheKey)?.data;
-
-    const streams = collection?.data ?? [];
-
-    if (!initial && streams.length > 0 && !collection?.params.page) return;
-
-    const query = createQuery(_queryStreams, {
-      ...queryParams,
-      limit: initial ? limit : undefined,
-      page: !initial ? collection?.params.page : undefined,
-    });
-
-    runQuery(
-      query,
-      ({ data: result, error, loading, paging }) => {
-        const data = {
-          loading,
-          error,
-          params: { page: paging?.next },
-          data: streams,
-        };
-
-        if (result) {
-          data.data = [...new Set([...streams, ...result.map(getResolver('stream'))])];
-        }
-        pushToCache(cacheKey, data);
-
-        responder(data);
-      },
-      queryOptions(policy),
-    );
-  };
-
-  disposers.push(
-    onStreamRecorded(realtimeRouter('onStreamRecorded')),
-    onStreamStarted(realtimeRouter('onStreamStarted')),
-    onStreamStopped(realtimeRouter('onStreamStopped')),
-  );
-
-  onFetch(true);
-
-  return () => {
-    log(`getStreams(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};
-/* end_public_function */