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

package/src/postRepository/api/createClipPost.ts

@@ -0,0 +1,62 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+import { LinkedObject } from '~/utils/linkedObject';
+
+/* begin_public_function
+  id: post.create.clip_post
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const created = await PostRepository.createClipPost({
+ *   targetType: 'user',
+ *   targetId: 'foobar',
+ *   dataType: 'clip',
+ *   data: { text: 'hello world' },
+ *   attachments: [{ type: 'clip', fileId: 'fileId123', displayMode: 'fill', isMuted: false }]
+ * }))
+ * ```
+ *
+ * Creates an {@link Amity.Post}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Post}
+ * @returns The newly created {@link Amity.Post}
+ *
+ * @category Post API
+ * @async
+ */
+export const createClipPost = async <T extends Amity.PostContentType | string>(
+  bundle: Pick<Amity.Post<T>, 'targetType' | 'targetId'> &
+    Partial<Pick<Amity.Post<T>, 'metadata' | 'mentionees' | 'tags'>> & {
+      data: { [k: string]: any };
+      attachments: {
+        type: T;
+        fileId: Amity.File['fileId'];
+        displayMode?: Amity.ClipDisplayMode;
+        isMuted?: boolean;
+      }[];
+    },
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('post/createPost', bundle);
+
+  const { data: payload } = await client.http.post<Amity.PostPayload>('/api/v4/posts', bundle);
+
+  fireEvent('post.created', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { posts } = data;
+
+  return {
+    data: LinkedObject.post(posts[0]),
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/postRepository/api/createPost.ts

@@ -2,8 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 import { LinkedObject } from '~/utils/linkedObject';
-import { preparePostPayload } from '../utils/payload';
 
 /* begin_public_function
   id: post.create.text_post, post.create.image_post, post.create.file_post, post.create.video_post, post.create.poll_post, post.create.livestream_post, post.create.custom_post
@@ -46,8 +46,7 @@ export const createPost = async <T extends Amity.PostContentType | string>(
 
   fireEvent('post.created', payload);
 
-  const data = preparePostPayload(payload);
-
+  const data = prepareMembershipPayload(payload, 'communityUsers');
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/postRepository/api/index.ts

@@ -13,3 +13,5 @@ export * from './declinePost';
 export * from './flagPost';
 export * from './unflagPost';
 export * from './isPostFlaggedByMe';
+
+export * from './createClipPost';

package/src/postRepository/api/queryPosts.ts

@@ -43,7 +43,7 @@ export const queryPosts = async (
   // API-FIX: parameters should be querystring. (1)
   // API-FIX: backend should answer Amity.Response (2)
   // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<Amity.PostPayload>>>(
-  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(`/api/v4/posts`, {
+  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(`/api/v5/posts`, {
     params: {
       ...params,
       isDeleted: inferIsDeleted(includeDeleted),

package/src/postRepository/observers/getPosts/PostPaginationController.ts

@@ -23,7 +23,7 @@ export class PostPaginationController extends PaginationController<
     const options = token ? { ...baseOptions, token } : { ...baseOptions, limit };
 
     const { data: queryResponse } = await this.http.get<Amity.PostPayload & Amity.Pagination>(
-      `/api/v4/posts`,
+      `/api/v5/posts`,
       {
         params: {
           ...params,

package/src/postRepository/utils/payload.ts

@@ -1,28 +1,8 @@
 import { addPostSetting } from '~/communityRepository/utils';
 import { updateMembershipStatus } from '~/communityRepository/utils/communityWithMembership';
-import { isAmityLivestreamPost } from '~/utils/postTypePredicate';
-
-const updateStreamReferences = (
-  streams: Amity.RawStream[],
-  streamId: string | undefined,
-  postId: string,
-) => {
-  if (!streamId) return streams;
-
-  return streams.map(stream =>
-    stream.streamId === streamId
-      ? {
-          ...stream,
-          referenceType: 'post',
-          referenceId: postId,
-          postId,
-        }
-      : stream,
-  );
-};
 
 export const preparePostPayload = (payload: Amity.PostPayload): Amity.ProcessedPostPayload => {
-  const { posts: postsData, postChildren, videoStreamings, ...postPayload } = payload;
+  const { posts: postsData, ...postPayload } = payload;
 
   // Unpack community payload by mapping payload field to postSetting value.
   const communitiesWithPostSetting = addPostSetting({ communities: postPayload.communities });
@@ -44,34 +24,18 @@ export const preparePostPayload = (payload: Amity.PostPayload): Amity.ProcessedP
     mappedCommunityUsers,
   );
 
-  let mappedNewStream: Amity.RawStream[] = [];
-
   // feed type
   const posts = postsData.map(post => {
     const feedType = postPayload.feeds.find(feed => feed.feedId === post.feedId)?.feedType;
-    const childPosts = payload.postChildren.filter(
-      children => children.parentPostId === post.postId,
-    );
-
-    if (childPosts.length > 0 && isAmityLivestreamPost(childPosts[0])) {
-      mappedNewStream = updateStreamReferences(
-        videoStreamings,
-        childPosts[0].data?.streamId,
-        post.postId,
-      );
-    }
 
     return {
       ...post,
-      childPosts,
       feedType,
     };
   });
 
   return {
     ...postPayload,
-    postChildren,
-    videoStreamings: mappedNewStream,
     posts,
     communities: communityWithMembershipStatus,
     communityUsers: mappedCommunityUsers,

package/src/streamRepository/api/createStream.ts

@@ -21,10 +21,7 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @async
  */
 export const createStream = async (
-  bundle: Pick<
-    Amity.InternalStream,
-    'title' | 'thumbnailFileId' | 'description' | 'channelEnabled'
-  > & {
+  bundle: Pick<Amity.InternalStream, 'title' | 'thumbnailFileId' | 'description'> & {
     isSecure?: boolean;
   },
 ): Promise<Amity.Cached<Amity.Stream>> => {

package/src/streamRepository/api/index.ts

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

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,16 @@ 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 '..';
 
 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();
@@ -76,23 +70,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;
-};