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

package/src/marker/events/onChannelUnreadUpdatedLocal.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * Internal used only
+ *
+ * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category MessageMarker Events
+ */
+export const onChannelUnreadUpdatedLocal = (
+  callback: Amity.Listener<Amity.Events['local.channelUnread.updated']>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.channelUnread.updated']) => {
+    callback(payload);
+  };
+
+  return createEventSubscriber(
+    client,
+    'channelMarker/onChannelUnreadUpdatedLocal',
+    'local.channelUnread.updated',
+    filter,
+  );
+};

package/src/marker/events/onSubChannelMarkerFetched.ts

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

package/src/marker/events/onSubChannelUnreadUpdatedLocal.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * Internal used only
+ *
+ * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category MessageMarker Events
+ */
+export const onSubChannelUnreadUpdatedLocal = (
+  callback: Amity.Listener<Amity.Events['local.subChannelUnread.updated']>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.subChannelUnread.updated']) => {
+    callback(payload);
+  };
+
+  return createEventSubscriber(
+    client,
+    'subChannelMarker/onSubChannelUnreadUpdatedLocal',
+    'local.subChannelUnread.updated',
+    filter,
+  );
+};

package/src/marker/events/onUserFeedMarkerUpdated.ts

@@ -23,10 +23,9 @@ export const onUserFeedMarkerUpdated = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.Events['marker.userFeed-updated']) => {
-    // update sub channel unread info and channel unread info in cache
-    persistUnreadCountInfo(payload);
-
-    callback(payload.feedMarkers[0]);
+    payload.feedMarkers.forEach(feedMarker => {
+      callback(feedMarker);
+    });
   };
 
   return createEventSubscriber(

package/src/marker/utils/reCalculateChannelUnreadInfo.ts

@@ -1,7 +1,7 @@
 import { pushToCache, queryCache } from '~/cache/api';
 import { pullFromCache } from '~/cache/api/pullFromCache';
 
-export const reCalculateChannelUnreadInfo = async (channelId: string) => {
+export const reCalculateChannelUnreadInfo = (channelId: string): Amity.ChannelUnreadInfo => {
   const cacheKeyChannelUnread = ['channelUnreadInfo', 'get', channelId];
   const cacheChannelUnreadInfo =
     pullFromCache<Amity.ChannelUnreadInfo>(cacheKeyChannelUnread)?.data;
@@ -25,7 +25,7 @@ export const reCalculateChannelUnreadInfo = async (channelId: string) => {
     isMentioned = subChannelUnreadsInfo.some(({ data }) => data.isMentioned);
   }
 
-  pushToCache(cacheKeyChannelUnread, {
+  const channelUnreadInfo = {
     ...(cacheChannelUnreadInfo ?? {
       channelId,
       createdAt: new Date().toISOString(),
@@ -33,5 +33,9 @@ export const reCalculateChannelUnreadInfo = async (channelId: string) => {
     updatedAt: new Date().toISOString(),
     unreadCount: channelUnreads,
     isMentioned,
-  });
+  };
+
+  pushToCache(cacheKeyChannelUnread, channelUnreadInfo);
+
+  return channelUnreadInfo;
 };

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

@@ -49,7 +49,7 @@ export class MessageLiveCollectionController extends LiveCollectionController<
     );
 
     this.callback = callback.bind(this);
-    this.loadPage(true);
+    this.loadPage({ initial: true });
   }
 
   protected setup() {
@@ -107,8 +107,8 @@ export class MessageLiveCollectionController extends LiveCollectionController<
     if (!this.shouldNotify(data) && origin === 'event') return;
 
     this.callback({
-      onNextPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.NEXT),
-      onPrevPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.PREV),
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      onPrevPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.PREV }),
       data,
       hasNextPage: !!this.paginationController.getNextToken(),
       hasPrevPage: !!this.paginationController.getPrevToken(),

package/src/postRepository/api/editPost.ts

@@ -47,7 +47,7 @@ export const editPost = async <T extends Amity.PostContentType>(
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('post.updated', data);
+  fireEvent('local.post.updated', data);
 
   const { posts } = data;
 

package/src/postRepository/api/updatePost.ts

@@ -51,7 +51,7 @@ export const updatePost = async <T extends Amity.PostContentType>(
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('post.updated', data);
+  fireEvent('local.post.updated', data);
 
   const { posts } = data;
 

package/src/postRepository/observers/getPost.ts

@@ -13,6 +13,8 @@ import {
 } from '../events';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { LinkedObject } from '~/utils/linkedObject';
+import { onCommentCreated, onCommentDeleted } from '~/commentRepository';
+import { convertEventPayload } from '~/utils/event';
 
 /* begin_public_function
   id: post.get
@@ -80,6 +82,30 @@ export const getPost = (
     },
     onPostUnflagged,
     onPostUpdated,
+    convertEventPayload(
+      (callback: Amity.Listener<Amity.InternalComment>) => {
+        return onCommentCreated(async (comment: Amity.InternalComment) => {
+          if (comment.referenceId === postId) {
+            await _getPost(postId);
+            callback(comment);
+          }
+        });
+      },
+      'referenceId',
+      'post',
+    ),
+    convertEventPayload(
+      (callback: Amity.Listener<Amity.InternalComment>) => {
+        return onCommentDeleted(async (comment: Amity.InternalComment) => {
+          if (comment.referenceId === postId) {
+            await _getPost(postId);
+            callback(comment);
+          }
+        });
+      },
+      'referenceId',
+      'post',
+    ),
   ]);
 };
 /* end_public_function */

package/src/postRepository/observers/getPosts.ts

@@ -2,6 +2,7 @@
 import { getResolver } from '~/core/model';
 import { getActiveClient } from '~/client/api';
 import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
+import { getPost as _getPost } from '../api/getPost';
 
 import {
   createQuery,
@@ -34,6 +35,8 @@ import {
   onPostUpdated,
 } from '../events';
 import { queryPosts } from '../api/queryPosts';
+import { convertEventPayload } from '~/utils/event';
+import { onCommentCreated, onCommentDeleted } from '~/commentRepository';
 
 /* begin_public_function
   id: post.query
@@ -204,6 +207,34 @@ export const getPosts = (
     onPostUnflagged(realtimeRouter('onUnflagged')),
     onPostReactionAdded(realtimeRouter('onReactionAdded')),
     onPostReactionRemoved(realtimeRouter('onReactionRemoved')),
+    convertEventPayload(
+      (callback: Amity.Listener<Amity.InternalComment>) => {
+        return onCommentCreated(async (comment: Amity.InternalComment) => {
+          const currentCollection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
+
+          if (!currentCollection || currentCollection.data.includes(comment.referenceId)) return;
+
+          await _getPost(comment.referenceId);
+          callback(comment);
+        });
+      },
+      'referenceId',
+      'post',
+    )(realtimeRouter('onUpdate')),
+    convertEventPayload(
+      (callback: Amity.Listener<Amity.InternalComment>) => {
+        return onCommentDeleted(async (comment: Amity.InternalComment) => {
+          const currentCollection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
+
+          if (!currentCollection || currentCollection.data.includes(comment.referenceId)) return;
+
+          await _getPost(comment.referenceId);
+          callback(comment);
+        });
+      },
+      'referenceId',
+      'post',
+    )(realtimeRouter('onUpdate')),
   );
 
   onFetch(true);

package/src/storyRepository/observers/getGlobalStoryTargets/GlobalStoryLiveCollectionController.ts

@@ -48,7 +48,7 @@ export class GlobalStoryLiveCollectionController extends LiveCollectionControlle
 
     this.paginationController = paginationController;
     this.callback = callback.bind(this);
-    this.loadPage(true);
+    this.loadPage({ initial: true });
   }
 
   protected setup() {
@@ -94,7 +94,7 @@ export class GlobalStoryLiveCollectionController extends LiveCollectionControlle
       ) as Amity.StoryTarget[];
 
     this.callback({
-      onNextPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.NEXT),
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
       data,
       hasNextPage: !!this.paginationController.getNextToken(),
       loading,

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

@@ -42,7 +42,7 @@ export class StoryLiveCollectionController extends LiveCollectionController<
 
     this.paginationController = paginationController;
     this.callback = callback.bind(this);
-    this.loadPage(true);
+    this.loadPage({ initial: true });
   }
 
   protected setup() {

package/src/streamRepository/api/createStream.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.create
@@ -11,16 +12,18 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * const created = await createStream({ title: 'my stream', 'thumbnailFileId': fileId  })
  * ```
  *
- * Creates an {@link Amity.Stream}
+ * Creates an {@link Amity.InternalStream}
  *
- * @param bundle The data necessary to create a new {@link Amity.Stream}
- * @returns The newly created {@link Amity.Stream}
+ * @param bundle The data necessary to create a new {@link Amity.InternalStream}
+ * @returns The newly created {@link Amity.InternalStream}
  *
  * @category Stream API
  * @async
  */
 export const createStream = async (
-  bundle: Pick<Amity.Stream, 'title' | 'thumbnailFileId' | 'description'> & { isSecure?: boolean },
+  bundle: Pick<Amity.InternalStream, 'title' | 'thumbnailFileId' | 'description'> & {
+    isSecure?: boolean;
+  },
 ): Promise<Amity.Cached<Amity.Stream>> => {
   const client = getActiveClient();
   client.log('stream/createStream', bundle);
@@ -33,7 +36,7 @@ export const createStream = async (
   const { videoStreamings } = data;
 
   return {
-    data: videoStreamings[0],
+    data: LinkedObject.stream(videoStreamings[0]),
     cachedAt,
   };
 };

package/src/streamRepository/api/deleteStream.ts

@@ -15,15 +15,17 @@ import { getStream } from './getStream';
  * const success = await deleteStream(streamId)
  * ```
  *
- * Deletes a {@link Amity.Stream}
+ * Deletes a {@link Amity.InternalStream}
  *
- * @param streamId The {@link Amity.Stream} ID to delete
- * @return A success boolean if the {@link Amity.Stream} was deleted
+ * @param streamId The {@link Amity.InternalStream} ID to delete
+ * @return A success boolean if the {@link Amity.InternalStream} was deleted
  *
  * @category Stream API
  * @async
  */
-export const deleteStream = async (streamId: Amity.Stream['streamId']): Promise<boolean> => {
+export const deleteStream = async (
+  streamId: Amity.InternalStream['streamId'],
+): Promise<boolean> => {
   const client = getActiveClient();
   client.log('stream/deleteStream', streamId);
 

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