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

package/src/messageRepository/utils/markReadMessage.ts

@@ -0,0 +1,8 @@
+import ReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/readReceiptSyncEngine';
+
+export const markReadMessage = (message: Amity.InternalMessage) => {
+  const { subChannelId, channelSegment } = message;
+  const markReadReceiptEngine = ReadReceiptSyncEngine.getInstance();
+
+  markReadReceiptEngine.markRead(subChannelId, channelSegment);
+};

package/src/postRepository/api/createPost.ts

@@ -26,7 +26,7 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @category Post API
  * @async
  */
-export const createPost = async <T extends Amity.PostContentType>(
+export const createPost = async <T extends Amity.PostContentType | string>(
   bundle: Pick<Amity.Post<T>, 'targetType' | 'targetId'> &
     Partial<Pick<Amity.Post<T>, 'metadata' | 'mentionees' | 'tags'>> & {
       dataType?: T;
@@ -37,7 +37,6 @@ export const createPost = async <T extends Amity.PostContentType>(
   const client = getActiveClient();
   client.log('post/createPost', bundle);
 
-  // API-FIX: backend rejects that we pass the dataType manually T_T
   if (!bundle.dataType || ['text', 'image', 'file', 'video'].includes(bundle.dataType)) {
     // eslint-disable-next-line no-param-reassign
     delete bundle.dataType;

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/storyRepository/utils/createOptimisticEvent.ts

@@ -21,32 +21,37 @@ export const createOptimisticEvent = (
 ) => {
   if (formData) {
     const files = formData.getAll('files');
-    const fileObject = (files[0] as File & { uri: string }) || undefined;
+    const fileObject = files[0] || undefined;
 
     if (!fileObject) return;
 
-    return callback(
-      saveOptimisticToCache(
-        isVideo
-          ? {
-              ...payload,
-              data: {
-                ...payload.data,
-                fileId: undefined,
-                videoFileId: { original: undefined },
-                fileData: fileObject.uri,
-              },
-            }
-          : {
-              ...payload,
-              data: {
-                ...payload.data,
-                fileId: undefined,
-                fileData: fileObject.uri,
+    const fileData = new FileReader();
+
+    fileData.readAsDataURL(fileObject as Blob);
+    fileData.onload = () => {
+      return callback(
+        saveOptimisticToCache(
+          isVideo
+            ? {
+                ...payload,
+                data: {
+                  ...payload.data,
+                  fileId: undefined,
+                  videoFileId: { original: undefined },
+                  fileData: fileData?.result,
+                },
+              }
+            : {
+                ...payload,
+                data: {
+                  ...payload.data,
+                  fileId: undefined,
+                  fileData: fileData?.result,
+                },
               },
-            },
-      ),
-    );
+        ),
+      );
+    };
   }
 
   return callback(

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