@amityco/ts-sdk 7.6.1-c97e594b.0 → 7.6.1-ce05a481.0

package/src/streamRepository/api/updateStream.ts

@@ -7,9 +7,6 @@ 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' })
@@ -24,13 +21,9 @@ 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' | 'channelEnabled'
-  >,
+  patch: Patch<Amity.Stream, 'title' | 'thumbnailFileId' | 'description' | 'metadata'>,
 ): Promise<Amity.Cached<Amity.Stream>> => {
   const client = getActiveClient();
   client.log('stream/updateStream', streamId, patch);

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.InternalStream>> => {
+): Promise<Amity.Cached<Amity.Stream>> => {
   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.InternalStream> | undefined => {
+): Amity.Cached<Amity.Stream> | undefined => {
   const client = getActiveClient();
   client.log('stream/getStream', streamId);
 
   if (!client.cache) return;
 
-  const cached = pullFromCache<Amity.InternalStream>(['stream', 'get', streamId]);
+  const cached = pullFromCache<Amity.Stream>(['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.Stream[]): Amity.Stream[] => {
+  private applyFilter = (data: Amity.InternalStream[]): Amity.InternalStream[] => {
     let streams = filterByPropEquality(data, 'isDeleted', this.query.isDeleted);
 
     streams = streams.sort(

package/src/utils/linkedObject/postLinkedObject.ts

@@ -3,22 +3,15 @@ import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
 import AnalyticsEngine from '../../analytic/service/analytic/AnalyticsEngine';
 import { userLinkedObject } from './userLinkedObject';
 import {
+  isAmityClipPost,
   isAmityFilePost,
   isAmityImagePost,
-  isAmityLivestreamPost,
-  isAmityPollPost,
   isAmityVideoPost,
 } from '../postTypePredicate';
-import { streamLinkedObject } from './streamLinkedObject';
-import { isNonNullable } from '..';
+import { shallowClone } from '../shallowClone';
 
 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),
+  return shallowClone(post, {
     analytics: {
       markAsViewed: () => {
         const analyticsEngineInstance = AnalyticsEngine.getInstance();
@@ -76,23 +69,10 @@ export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
         : 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;
+    getClipInfo(): Amity.File<'clip'> | undefined {
+      return isAmityClipPost(post)
+        ? pullFromCache<Amity.File<'clip'>>(['file', 'get', post?.data?.fileId])?.data
+        : undefined;
     },
-  };
+  });
 };

package/src/utils/linkedObject/streamLinkedObject.ts

@@ -1,5 +1,4 @@
 import { pullFromCache } from '~/cache/api';
-import { getLiveChat as _getLiveChat } from '~/streamRepository/internalApi/getLiveChat';
 
 export const streamLinkedObject = (stream: Amity.InternalStream): Amity.Stream => {
   return {
@@ -19,6 +18,5 @@ 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,6 +1,5 @@
-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 &&
@@ -8,9 +7,8 @@ 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 &&
@@ -18,9 +16,8 @@ export function isAmityFilePost(post?: Amity.InternalPost): post is Amity.Post<'
   );
 }
 
-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 &&
@@ -29,22 +26,11 @@ export function isAmityVideoPost(post?: Amity.InternalPost): post is Amity.Post<
   );
 }
 
-export function isAmityLivestreamPost(post?: Amity.InternalPost): post is Amity.Post<'liveStream'> {
+export function isAmityClipPost(post: Amity.InternalPost): post is Amity.Post<'clip'> {
   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'
+    'fileId' in post.data &&
+    post.dataType === 'clip'
   );
 }

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

@@ -1,18 +0,0 @@
-/**
- *
- * ```js
- * import { StreamRepository } from '@amityco/ts-sdk'
- * const updated = await StreamRepository.editStream(streamId, { title: 'foobar' })
- * ```
- *
- * Updates an {@link Amity.Stream}
- *
- * @param streamId The ID of the {@link Amity.Stream} to edit
- * @param patch The patch data to apply
- * @returns the updated {@link Amity.Stream} object
- *
- * @category Stream API
- * @async
- */
-export declare const editStream: (streamId: Amity.Stream['streamId'], patch: Patch<Amity.Stream, 'title' | 'thumbnailFileId' | 'description' | 'metadata' | 'channelEnabled'>) => Promise<Amity.Cached<Amity.Stream>>;
-//# sourceMappingURL=editStream.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"editStream.d.ts","sourceRoot":"","sources":["../../../src/streamRepository/api/editStream.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,UAAU,aACX,MAAM,MAAM,CAAC,UAAU,CAAC,SAC3B,MACL,MAAM,MAAM,EACZ,OAAO,GAAG,iBAAiB,GAAG,aAAa,GAAG,UAAU,GAAG,gBAAgB,CAC5E,KACA,QAAQ,MAAM,MAAM,CAAC,MAAM,MAAM,CAAC,CAkBpC,CAAC"}

package/dist/streamRepository/internalApi/getLiveChat.d.ts

@@ -1,16 +0,0 @@
-/**
- * ```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 declare const getLiveChat: (stream: Amity.InternalStream) => Promise<Amity.Channel<'live'> | undefined>;
-//# sourceMappingURL=getLiveChat.d.ts.map

package/dist/streamRepository/internalApi/getLiveChat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getLiveChat.d.ts","sourceRoot":"","sources":["../../../src/streamRepository/internalApi/getLiveChat.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,WAAW,WACd,MAAM,cAAc,KAC3B,QAAQ,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,CAkC3C,CAAC"}

package/src/streamRepository/api/editStream.ts

@@ -1,51 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: stream.update
-*/
-/**
- *
- * ```js
- * import { StreamRepository } from '@amityco/ts-sdk'
- * const updated = await StreamRepository.editStream(streamId, { title: 'foobar' })
- * ```
- *
- * Updates an {@link Amity.Stream}
- *
- * @param streamId The ID of the {@link Amity.Stream} to edit
- * @param patch The patch data to apply
- * @returns the updated {@link Amity.Stream} object
- *
- * @category Stream API
- * @async
- */
-
-export const editStream = async (
-  streamId: Amity.Stream['streamId'],
-  patch: Patch<
-    Amity.Stream,
-    'title' | 'thumbnailFileId' | 'description' | 'metadata' | 'channelEnabled'
-  >,
-): Promise<Amity.Cached<Amity.Stream>> => {
-  const client = getActiveClient();
-  client.log('stream/updateStream', streamId, patch);
-
-  const { data } = await client.http.put<Amity.StreamPayload>(
-    `/api/v3/video-streaming/${streamId}`,
-    patch,
-  );
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  const { videoStreamings } = data;
-
-  return {
-    data: LinkedObject.stream(videoStreamings.find(stream => stream.streamId === streamId)!),
-    cachedAt,
-  };
-};
-/* end_public_function */

package/src/streamRepository/internalApi/getLiveChat.ts

@@ -1,59 +0,0 @@
-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;
-};