@amityco/ts-sdk-react-native 6.24.2-7ddc891.0 → 6.25.0

package/src/streamRepository/api/disposeStream.ts

@@ -8,18 +8,18 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * const stream = await disposeStream(streamId)
  * ```
  *
- * Dispose a {@link Amity.Stream}.
+ * Dispose a {@link Amity.InternalStream}.
  * Streaming status will be updated to "ended" and streaming url will be invalidated
  *
- * @param streamId The {@link Amity.Stream} ID to dispose
- * @returns the associated {@link Amity.Stream} object
+ * @param streamId The {@link Amity.InternalStream} ID to dispose
+ * @returns the associated {@link Amity.InternalStream} object
  *
  * @category Stream API
  * @async
  */
 export const disposeStream = async (
-  streamId: Amity.Stream['streamId'],
-): Promise<Amity.Cached<Amity.Stream>> => {
+  streamId: Amity.InternalStream['streamId'],
+): Promise<Amity.Cached<Amity.InternalStream>> => {
   const client = getActiveClient();
   client.log('stream/disposeStream', streamId);
 

package/src/streamRepository/api/queryStreams.ts

@@ -14,10 +14,10 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * const streams = await getStreams()
  * ```
  *
- * Queries a paginable list of {@link Amity.Stream} objects
+ * Queries a paginable list of {@link Amity.InternalStream} objects
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.Stream} objects
+ * @returns A page of {@link Amity.InternalStream} objects
  *
  * @category Stream API
  * @async
@@ -27,9 +27,9 @@ export const queryStreams = async (query?: {
   statuses?: Amity.StreamStatus[];
   userPublicIds?: Amity.InternalUser['userId'][];
   sortBy?: 'lastCreated' | 'firstCreated';
-  isDeleted?: Amity.Stream['isDeleted'];
+  isDeleted?: Amity.InternalStream['isDeleted'];
   page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Stream>>> => {
+}): Promise<Amity.Cached<Amity.Paged<Amity.InternalStream>>> => {
   const client = getActiveClient();
   client.log('stream/queryStreams', query);
 

package/src/streamRepository/api/updateStream.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: stream.update
@@ -38,7 +39,7 @@ export const updateStream = async (
   const { videoStreamings } = data;
 
   return {
-    data: videoStreamings.find(stream => stream.streamId === streamId)!,
+    data: LinkedObject.stream(videoStreamings.find(stream => stream.streamId === streamId)!),
     cachedAt,
   };
 };

package/src/streamRepository/events/index.ts

@@ -1,3 +1,5 @@
 export { onStreamStarted } from './onStreamStarted';
 export { onStreamStopped } from './onStreamStopped';
 export { onStreamRecorded } from './onStreamRecorded';
+export { onStreamFlagged } from './onStreamFlagged';
+export { onStreamTerminated } from './onStreamTerminated';

package/src/streamRepository/events/onStreamFlagged.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onStreamFlagged } from '@amityco/ts-sdk-react-native'
+ * const dispose = onStreamFlagged(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalStream} has started airing
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamFlagged = (
+  callback: Amity.Listener<Amity.InternalStream>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.StreamPayload) => {
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamFlagged',
+    'v3.video-streaming.didFlag',
+    filter,
+  );
+};

package/src/streamRepository/events/onStreamRecorded.ts

@@ -11,14 +11,16 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * })
  * ```
  *
- * Fired when the recordings of a {@link Amity.Stream} are available
+ * Fired when the recordings of a {@link Amity.InternalStream} are available
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Stream Events
  */
-export const onStreamRecorded = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+export const onStreamRecorded = (
+  callback: Amity.Listener<Amity.InternalStream>,
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.StreamPayload) => {

package/src/streamRepository/events/onStreamStarted.ts

@@ -11,14 +11,16 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * })
  * ```
  *
- * Fired when a {@link Amity.Stream} has started airing
+ * Fired when a {@link Amity.InternalStream} has started airing
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Stream Events
  */
-export const onStreamStarted = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+export const onStreamStarted = (
+  callback: Amity.Listener<Amity.InternalStream>,
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.StreamPayload) => {

package/src/streamRepository/events/onStreamStopped.ts

@@ -11,14 +11,16 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * })
  * ```
  *
- * Fired when a {@link Amity.Stream} has stopped airing
+ * Fired when a {@link Amity.InternalStream} has stopped airing
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Stream Events
  */
-export const onStreamStopped = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+export const onStreamStopped = (
+  callback: Amity.Listener<Amity.InternalStream>,
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.StreamPayload) => {

package/src/streamRepository/events/onStreamTerminated.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onStreamTerminated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onStreamTerminated(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalStream} has started airing
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamTerminated = (
+  callback: Amity.Listener<Amity.InternalStream>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.StreamPayload) => {
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamTerminated',
+    'v3.video-streaming.didTerminate',
+    filter,
+  );
+};

package/src/streamRepository/internalApi/queryStreams.ts

@@ -11,17 +11,17 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * const streams = await getStreams()
  * ```
  *
- * Queries a paginable list of {@link Amity.Stream} objects
+ * Queries a paginable list of {@link Amity.InternalStream} objects
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.Stream} objects
+ * @returns A page of {@link Amity.InternalStream} objects
  *
  * @category Stream API
  * @async
  */
 export const queryStreams = async (
   query?: Amity.QueryStreams,
-): Promise<Amity.Cached<Amity.PageToken<Amity.Stream>>> => {
+): Promise<Amity.Cached<Amity.PageToken<Amity.InternalStream>>> => {
   const client = getActiveClient();
   client.log('stream/queryStreams', query);
 

package/src/streamRepository/observers/getStreamById.ts

@@ -1,10 +1,13 @@
 /* eslint-disable no-use-before-define */
 
-import { onStreamRecorded, onStreamStarted, onStreamStopped } from '../events';
-import { getStream as _getStream } from '../api/getStream';
 import { liveObject } from '~/utils/liveObject';
 import { getActiveClient } from '~/client';
 import { pullFromCache } from '~/cache/api';
+import { onStreamFlagged } from '~/streamRepository/events/onStreamFlagged';
+import { onStreamTerminated } from '~/streamRepository/events/onStreamTerminated';
+import { LinkedObject } from '~/utils/linkedObject';
+import { getStream as _getStream } from '../api/getStream';
+import { onStreamRecorded, onStreamStarted, onStreamStopped } from '../events';
 
 /* begin_public_function
   id: stream.get
@@ -19,6 +22,7 @@ import { pullFromCache } from '~/cache/api';
  * Fetches a {@link Amity.Stream} object
  *
  * @param streamId the ID of the {@link Amity.Stream} to get
+ * @param callback
  * @returns the associated {@link Amity.Stream} object
  *
  * @category Stream Live Object
@@ -28,10 +32,19 @@ export const getStreamById = (
   streamId: Amity.Stream['streamId'],
   callback: Amity.LiveObjectCallback<Amity.Stream>,
 ): Amity.Unsubscriber => {
-  return liveObject(streamId, callback, 'streamId', _getStream, [
+  const reactor: Amity.LiveObjectCallback<Amity.InternalStream> = (
+    snapshot: Amity.LiveObject<Amity.InternalStream>,
+  ) => {
+    const { data } = snapshot;
+    callback({ ...snapshot, data: data ? LinkedObject.stream(snapshot.data) : data });
+  };
+
+  return liveObject(streamId, reactor, 'streamId', _getStream, [
     onStreamRecorded,
     onStreamStarted,
     onStreamStopped,
+    onStreamFlagged,
+    onStreamTerminated,
   ]);
 };
 /* end_public_function */
@@ -57,12 +70,12 @@ getStreamById.locally = (
 
   if (!client.cache) return;
 
-  const cached = pullFromCache<Amity.Stream>(['stream', 'get', streamId]);
+  const cached = pullFromCache<Amity.InternalStream>(['stream', 'get', streamId]);
 
   if (!cached) return;
 
   return {
-    data: cached.data,
+    data: LinkedObject.stream(cached.data),
     cachedAt: cached.cachedAt,
   };
 };

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/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;
+    },
+  };
+};