@amityco/ts-sdk 7.5.4-ec2fdd4.0 → 7.6.1-65b44ce1.0

package/src/streamRepository/api/index.ts

@@ -2,3 +2,4 @@ export * from './createStream';
 export * from './updateStream';
 export * from './deleteStream';
 export * from './disposeStream';
+export * from './editStream';

package/src/streamRepository/api/updateStream.ts

@@ -7,6 +7,9 @@ import { LinkedObject } from '~/utils/linkedObject';
   id: stream.update
 */
 /**
+ * @deprecated this function is deprecated,
+ * please use {@link Amity.StreamRepository.editStream} instead.
+ *
  * ```js
  * import { updateStream } from '@amityco/ts-sdk'
  * const updated = await updateStream(streamId, { title: 'foobar' })
@@ -21,9 +24,13 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @category Stream API
  * @async
  */
+
 export const updateStream = async (
   streamId: Amity.Stream['streamId'],
-  patch: Patch<Amity.Stream, 'title' | 'thumbnailFileId' | 'description' | 'metadata'>,
+  patch: Patch<
+    Amity.Stream,
+    'title' | 'thumbnailFileId' | 'description' | 'metadata' | 'channelEnabled'
+  >,
 ): Promise<Amity.Cached<Amity.Stream>> => {
   const client = getActiveClient();
   client.log('stream/updateStream', streamId, patch);

package/src/streamRepository/internalApi/getLiveChat.ts

@@ -0,0 +1,59 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { mergeInCache, pullFromCache } from '~/cache/api';
+import { createChannel } from '~/channelRepository/api/createChannel';
+import { channelLinkedObject } from '~/utils/linkedObject/channelLinkedObject';
+import { getChannel } from '~/channelRepository/internalApi/getChannel';
+import { constructChannelObject } from '~/channelRepository/utils/constructChannelObject';
+
+/**
+ * ```js
+ * import { getStream } from '@amityco/ts-sdk'
+ * const stream = await getStream('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Channel} object linked with a current stream
+ *
+ * @param stream {@link Amity.Stream} that has linked live channel
+ * @returns the associated {@link Amity.Channel<'live'>} object
+ *
+ * @category Stream API
+ * @async
+ */
+
+export const getLiveChat = async (
+  stream: Amity.InternalStream,
+): Promise<Amity.Channel<'live'> | undefined> => {
+  const client = getActiveClient();
+  client.log('stream/getLiveChat', stream.streamId);
+
+  if (stream.channelId) {
+    const channel = pullFromCache<Amity.StaticInternalChannel>([
+      'channel',
+      'get',
+      stream.channelId,
+    ])?.data;
+
+    if (channel) return channelLinkedObject(constructChannelObject(channel));
+
+    const { data } = await getChannel(stream.channelId);
+    return channelLinkedObject(constructChannelObject(data));
+  }
+  // No Channel ID
+  // streamer: create a new live channel
+  if (stream.userId === client.userId) {
+    const { data: channel } = await createChannel({
+      type: 'live',
+      postId: stream.postId,
+      videoStreamId: stream.streamId,
+    });
+
+    // Update channelId to stream object in cache
+    mergeInCache(['stream', 'get', stream.streamId], {
+      channelId: channel.channelId,
+    });
+
+    return channel;
+  }
+  // watcher: return undefined
+  return undefined;
+};

package/src/streamRepository/internalApi/getStream.ts

@@ -22,7 +22,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const getStream = async (
   streamId: Amity.Stream['streamId'],
-): Promise<Amity.Cached<Amity.Stream>> => {
+): Promise<Amity.Cached<Amity.InternalStream>> => {
   const client = getActiveClient();
   client.log('stream/getStream', streamId);
 
@@ -57,13 +57,13 @@ export const getStream = async (
  */
 getStream.locally = (
   streamId: Amity.Stream['streamId'],
-): Amity.Cached<Amity.Stream> | undefined => {
+): Amity.Cached<Amity.InternalStream> | undefined => {
   const client = getActiveClient();
   client.log('stream/getStream', streamId);
 
   if (!client.cache) return;
 
-  const cached = pullFromCache<Amity.Stream>(['stream', 'get', streamId]);
+  const cached = pullFromCache<Amity.InternalStream>(['stream', 'get', streamId]);
 
   if (!cached) return;
 

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

@@ -102,7 +102,7 @@ export class GetStreamsLiveCollectionController extends LiveCollectionController
     this.queryStreamController.appendToQueryStream(response, direction, refresh);
   }
 
-  private applyFilter = (data: Amity.InternalStream[]): Amity.InternalStream[] => {
+  private applyFilter = (data: Amity.Stream[]): Amity.Stream[] => {
     let streams = filterByPropEquality(data, 'isDeleted', this.query.isDeleted);
 
     streams = streams.sort(

package/src/utils/linkedObject/channelLinkedObject.ts

@@ -1,8 +1,27 @@
 import { markAsRead } from '~/channelRepository/internalApi/markAsRead';
 import { shallowClone } from '../shallowClone';
+import { queryCache } from '~/cache/api';
+import { channelMemberLinkedObject } from './channelMemberLinkedObject';
 
 export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Channel => {
+  let previewMembers: Amity.Membership<'channel'>[] = [];
+
+  if (channel.type === 'conversation') {
+    const channelUsers = queryCache<Amity.Membership<'channel'>>(['channelUsers', 'get']);
+    if (channelUsers && channelUsers?.length > 0) {
+      previewMembers = (
+        channelUsers?.filter(({ data }) => data.channelId === channel.channelId) ?? []
+      )
+        // sort in ascending order by userInternalId
+        .sort((a, b) => a.data.userInternalId.localeCompare(b.data.userInternalId))
+        // Select only first 4 members
+        .slice(0, 4)
+        .map(({ data }) => channelMemberLinkedObject(data));
+    }
+  }
+
   return shallowClone(channel, {
     markAsRead: () => markAsRead(channel.channelInternalId),
+    previewMembers,
   });
 };

package/src/utils/linkedObject/channelMemberLinkedObject.ts

@@ -0,0 +1,20 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { userLinkedObject } from './userLinkedObject';
+
+export const channelMemberLinkedObject = (
+  channelMember: Amity.Membership<'channel'>,
+): Amity.Membership<'channel'> => {
+  const getUser = (): Amity.User | undefined => {
+    const cacheKey = ['user', 'get', channelMember.userId];
+    const internalUser = pullFromCache<Amity.InternalUser>(cacheKey)?.data;
+
+    return internalUser ? userLinkedObject(internalUser) : undefined;
+  };
+
+  return {
+    ...channelMember,
+    get user() {
+      return getUser();
+    },
+  };
+};

package/src/utils/linkedObject/index.ts

@@ -14,6 +14,7 @@ import { notificationTrayLinkedObject } from './notificationTrayLinkedObject';
 import { communityLinkedObject } from './communityLinkedObject';
 import { invitationLinkedObject } from './invitationLinkedObject';
 import { joinRequestLinkedObject } from './joinRequestLinkedObject';
+import { channelMemberLinkedObject } from './channelMemberLinkedObject';
 
 export const LinkedObject = {
   ad: adLinkedObject,
@@ -32,4 +33,5 @@ export const LinkedObject = {
   community: communityLinkedObject,
   invitation: invitationLinkedObject,
   joinRequest: joinRequestLinkedObject,
+  channelMember: channelMemberLinkedObject,
 };

package/src/utils/linkedObject/postLinkedObject.ts

@@ -2,12 +2,23 @@ import { pullFromCache } from '~/cache/api';
 import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
 import AnalyticsEngine from '../../analytic/service/analytic/AnalyticsEngine';
 import { userLinkedObject } from './userLinkedObject';
-import { isAmityFilePost, isAmityImagePost, isAmityVideoPost } from '../postTypePredicate';
+import {
+  isAmityFilePost,
+  isAmityImagePost,
+  isAmityLivestreamPost,
+  isAmityPollPost,
+  isAmityVideoPost,
+} from '../postTypePredicate';
+import { streamLinkedObject } from './streamLinkedObject';
+import { isNonNullable } from '..';
 
 export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
   return {
     ...post,
-
+    childrenPosts: post.children
+      .map(childPost => pullFromCache<Amity.InternalPost>(['post', 'get', childPost])?.data)
+      .filter(isNonNullable)
+      .map(postLinkedObject),
     analytics: {
       markAsViewed: () => {
         const analyticsEngineInstance = AnalyticsEngine.getInstance();
@@ -64,5 +75,24 @@ export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
         ? pullFromCache<Amity.File<'file'>>(['file', 'get', post?.data?.fileId])?.data
         : undefined;
     },
+
+    getLivestreamInfo(): Amity.Stream | undefined {
+      if (!isAmityLivestreamPost(post)) return;
+      const cache = pullFromCache<Amity.InternalStream>([
+        'stream',
+        'get',
+        post?.data?.streamId,
+      ])?.data;
+      if (!cache) return;
+
+      return streamLinkedObject(cache);
+    },
+
+    getPollInfo(): Amity.Poll | undefined {
+      if (!isAmityPollPost(post)) return;
+      const cache = pullFromCache<Amity.Poll>(['poll', 'get', post?.data?.pollId])?.data;
+      if (!cache) return;
+      return cache;
+    },
   };
 };

package/src/utils/linkedObject/streamLinkedObject.ts

@@ -1,4 +1,5 @@
 import { pullFromCache } from '~/cache/api';
+import { getLiveChat as _getLiveChat } from '~/streamRepository/internalApi/getLiveChat';
 
 export const streamLinkedObject = (stream: Amity.InternalStream): Amity.Stream => {
   return {
@@ -18,5 +19,6 @@ export const streamLinkedObject = (stream: Amity.InternalStream): Amity.Stream =
     get user() {
       return pullFromCache<Amity.User>(['user', 'get', stream.userId])?.data;
     },
+    getLiveChat: () => _getLiveChat(stream),
   };
 };

package/src/utils/postTypePredicate.ts

@@ -1,5 +1,6 @@
-export function isAmityImagePost(post: Amity.InternalPost): post is Amity.Post<'image'> {
+export function isAmityImagePost(post?: Amity.InternalPost): post is Amity.Post<'image'> {
   return !!(
+    post &&
     post.data &&
     typeof post.data !== 'string' &&
     'fileId' in post.data &&
@@ -7,8 +8,9 @@ export function isAmityImagePost(post: Amity.InternalPost): post is Amity.Post<'
   );
 }
 
-export function isAmityFilePost(post: Amity.InternalPost): post is Amity.Post<'file'> {
+export function isAmityFilePost(post?: Amity.InternalPost): post is Amity.Post<'file'> {
   return !!(
+    post &&
     post.data &&
     typeof post.data !== 'string' &&
     'fileId' in post.data &&
@@ -16,8 +18,9 @@ export function isAmityFilePost(post: Amity.InternalPost): post is Amity.Post<'f
   );
 }
 
-export function isAmityVideoPost(post: Amity.InternalPost): post is Amity.Post<'video'> {
+export function isAmityVideoPost(post?: Amity.InternalPost): post is Amity.Post<'video'> {
   return !!(
+    post &&
     post.data &&
     typeof post.data !== 'string' &&
     'videoFileId' in post.data &&
@@ -25,3 +28,23 @@ export function isAmityVideoPost(post: Amity.InternalPost): post is Amity.Post<'
     post.dataType === 'video'
   );
 }
+
+export function isAmityLivestreamPost(post?: Amity.InternalPost): post is Amity.Post<'liveStream'> {
+  return !!(
+    post &&
+    post.data &&
+    typeof post.data !== 'string' &&
+    'streamId' in post.data &&
+    post.dataType === 'liveStream'
+  );
+}
+
+export function isAmityPollPost(post?: Amity.InternalPost): post is Amity.Post<'poll'> {
+  return !!(
+    post &&
+    post.data &&
+    typeof post.data !== 'string' &&
+    'pollId' in post.data &&
+    post.dataType === 'poll'
+  );
+}