@amityco/ts-sdk 7.5.3 → 7.5.4-2d34fd5f.0

package/src/messagePreview/utils/getChannelMessagePreviewWithUser.ts

@@ -1,6 +1,6 @@
-import { pullFromCache } from '~/cache/api';
+import { pullFromCache } from '~/cache/api/pullFromCache';
 import { getChannelMessagePreview } from './getChannelMessagePreview';
-import { LinkedObject } from '~/utils/linkedObject';
+import { userLinkedObject } from '~/utils/linkedObject/userLinkedObject';
 
 export const getChannelMessagePreviewWithUser = (
   channel: Amity.StaticInternalChannel,
@@ -20,7 +20,7 @@ export const getChannelMessagePreviewWithUser = (
   const messagePreviewWithUser = messagePreview
     ? {
         ...messagePreview,
-        user: internalUser ? LinkedObject.user(internalUser) : undefined,
+        user: internalUser ? userLinkedObject(internalUser) : undefined,
       }
     : null;
 

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/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/getGlobalPinnedPosts/GlobalPinnedPostQueryStreamController.ts

@@ -4,6 +4,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 import { getActiveClient } from '~/client';
 import { EnumPostActions } from '../enums';
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
 
 export class GlobalPinnedPostQueryStreamController extends QueryStreamController<
   Amity.PinnedPostPayload,
@@ -30,7 +31,12 @@ export class GlobalPinnedPostQueryStreamController extends QueryStreamController
     const cachedAt = client.cache && Date.now();
 
     if (client.cache) {
-      ingestInCache(response, { cachedAt });
+      const processedPayload = {
+        ...response,
+        users: response.users.map(convertRawUserToInternalUser),
+      };
+
+      ingestInCache(processedPayload, { cachedAt });
     }
   }
 

package/src/postRepository/observers/getPinnedPosts/PinnedPostQueryStreamController.ts

@@ -3,6 +3,7 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 import { getActiveClient } from '~/client';
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
 
 export class PinnedPostQueryStreamController extends QueryStreamController<
   Amity.PinnedPostPayload,
@@ -29,7 +30,12 @@ export class PinnedPostQueryStreamController extends QueryStreamController<
     const cachedAt = client.cache && Date.now();
 
     if (client.cache) {
-      ingestInCache(response, { cachedAt });
+      const processedPayload = {
+        ...response,
+        users: response.users ? response.users.map(convertRawUserToInternalUser) : [],
+      };
+
+      ingestInCache(processedPayload, { cachedAt });
     }
   }
 

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/subChannelRepository/utils/prepareSubChannelPayload.ts

@@ -4,6 +4,7 @@ import { convertFromRaw as convertMessageFromRaw } from '~/messageRepository/uti
 import { convertFromRaw as convertSubChannelFromRaw } from './convertSubChannelFromRaw';
 
 import { updateSubChannelMessagePreviewCache } from '../../messagePreview/utils/updateSubChannelMessagePreviewCache';
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
 
 export const MARKER_INCLUDED_SUB_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 
@@ -44,10 +45,13 @@ export const prepareSubChannelPayload = async (
 
   const messages = rawPayload.messages.map(m => convertMessageFromRaw(m));
 
+  const user = rawPayload.users.map(convertRawUserToInternalUser);
+
   return {
     ...rawPayload,
     messageFeeds,
     messages,
+    users: user,
   };
 };
 

package/src/utils/linkedObject/communityLinkedObject.ts

@@ -0,0 +1,57 @@
+import { InvitationTypeEnum } from '~/@types';
+import { getMyJoinRequest } from '~/communityRepository/internalAPI/getMyJoinRequest';
+import { joinRequest } from '~/communityRepository/internalAPI/joinCommunity';
+import { getJoinRequests } from '~/communityRepository/observers/getJoinRequests';
+import { createInvitations } from '~/invitationRepository/internalApi';
+import { getInvitation } from '~/invitationRepository/internalApi/getInvitation';
+import { getInvitations } from '~/invitationRepository/observers/getInvitations';
+
+export const communityLinkedObject = (community: Amity.InternalCommunity): Amity.Community => {
+  return {
+    ...community,
+    createInvitations: async (userIds: string[]): Promise<void> => {
+      await createInvitations({
+        type: InvitationTypeEnum.CommunityMemberInvite,
+        targetType: 'community',
+        targetId: community.communityId,
+        userIds,
+      });
+    },
+    getMemberInvitations: (
+      params: Pick<Amity.InvitationLiveCollection, 'limit' | 'sortBy' | 'statuses'>,
+      callback: Amity.LiveCollectionCallback<Amity.Invitation>,
+    ): Amity.Unsubscriber => {
+      return getInvitations(
+        {
+          ...params,
+          targetId: community.communityId,
+          targetType: 'community',
+          type: InvitationTypeEnum.CommunityMemberInvite,
+        },
+        callback,
+      );
+    },
+    getInvitation: async () => {
+      const { data } = await getInvitation('community', community.communityId);
+      return data;
+    },
+    join: async () => joinRequest(community.communityId),
+
+    getJoinRequests: (
+      params: Omit<Amity.QueryJoinRequest, 'communityId'>,
+      callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,
+    ): Amity.Unsubscriber => {
+      return getJoinRequests(
+        {
+          ...params,
+          communityId: community.communityId,
+        },
+        callback,
+      );
+    },
+    getMyJoinRequest: async () => {
+      const { data } = await getMyJoinRequest(community.communityId);
+      return data;
+    },
+  };
+};

package/src/utils/linkedObject/index.ts

@@ -11,6 +11,9 @@ import { channelLinkedObject } from './channelLinkedObject';
 import { adLinkedObject } from './adLinkedObject';
 import { pinnedPostLinkedObject } from './pinnedPostLinkedObject';
 import { notificationTrayLinkedObject } from './notificationTrayLinkedObject';
+import { communityLinkedObject } from './communityLinkedObject';
+import { invitationLinkedObject } from './invitationLinkedObject';
+import { joinRequestLinkedObject } from './joinRequestLinkedObject';
 
 export const LinkedObject = {
   ad: adLinkedObject,
@@ -26,4 +29,7 @@ export const LinkedObject = {
   channel: channelLinkedObject,
   pinnedPost: pinnedPostLinkedObject,
   notificationTray: notificationTrayLinkedObject,
+  community: communityLinkedObject,
+  invitation: invitationLinkedObject,
+  joinRequest: joinRequestLinkedObject,
 };

package/src/utils/linkedObject/invitationLinkedObject.ts

@@ -0,0 +1,37 @@
+import { pullFromCache } from '~/cache/api';
+import { userLinkedObject } from './userLinkedObject';
+import { acceptInvitation, rejectInvitation } from '~/invitationRepository/internalApi';
+
+export const invitationLinkedObject = (invitation: Amity.InternalInvitation): Amity.Invitation => {
+  return {
+    ...invitation,
+    get user(): Amity.User | undefined {
+      const cacheData = pullFromCache<Amity.User>(['user', 'get', invitation.invitedUserPublicId]);
+      if (cacheData?.data) return userLinkedObject(cacheData.data);
+      return undefined;
+    },
+    get createdBy(): Amity.User | undefined {
+      const cacheData = pullFromCache<Amity.User>(['user', 'get', invitation.inviterUserPublicId]);
+      if (cacheData?.data) return userLinkedObject(cacheData.data);
+      return undefined;
+    },
+    get target(): Amity.InvitationTarget<Amity.InvitationTargetType> | undefined {
+      if (invitation.targetType === 'community') {
+        const cacheData = pullFromCache<Amity.InternalCommunity>([
+          'community',
+          'get',
+          invitation.targetId,
+        ]);
+        if (cacheData?.data) return cacheData.data;
+        return undefined;
+      }
+      return undefined;
+    },
+    accept: async () => {
+      await acceptInvitation(invitation._id);
+    },
+    reject: async () => {
+      await rejectInvitation(invitation._id);
+    },
+  };
+};

package/src/utils/linkedObject/joinRequestLinkedObject.ts

@@ -0,0 +1,31 @@
+import { pullFromCache } from '~/cache/api';
+import { userLinkedObject } from './userLinkedObject';
+import { approveJoinRequest } from '~/communityRepository/joinRequest/internalAPI/approveJoinRequest';
+import { cancelJoinRequest } from '~/communityRepository/joinRequest/internalAPI/cancelJoinRequest';
+import { rejectJoinRequest } from '~/communityRepository/joinRequest/internalAPI/rejectJoinRequest';
+
+export const joinRequestLinkedObject = (
+  joinRequest: Amity.InternalJoinRequest,
+): Amity.JoinRequest => {
+  return {
+    ...joinRequest,
+    get user(): Amity.User | undefined {
+      const user = pullFromCache<Amity.InternalUser>([
+        'user',
+        'get',
+        joinRequest.requestorPublicId,
+      ])?.data;
+      if (!user) return undefined;
+      return userLinkedObject(user);
+    },
+    cancel: async () => {
+      await cancelJoinRequest(joinRequest);
+    },
+    approve: async () => {
+      await approveJoinRequest(joinRequest);
+    },
+    reject: async () => {
+      await rejectJoinRequest(joinRequest);
+    },
+  };
+};

package/src/utils/linkedObject/postLinkedObject.ts

@@ -2,7 +2,12 @@ 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 {
+  isAmityClipPost,
+  isAmityFilePost,
+  isAmityImagePost,
+  isAmityVideoPost,
+} from '../postTypePredicate';
 
 export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
   return {
@@ -64,5 +69,11 @@ export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
         ? pullFromCache<Amity.File<'file'>>(['file', 'get', post?.data?.fileId])?.data
         : undefined;
     },
+
+    getClipInfo(): Amity.File<'clip'> | undefined {
+      return isAmityClipPost(post)
+        ? pullFromCache<Amity.File<'clip'>>(['file', 'get', post?.data?.fileId])?.data
+        : undefined;
+    },
   };
 };

package/src/utils/postTypePredicate.ts

@@ -25,3 +25,13 @@ export function isAmityVideoPost(post: Amity.InternalPost): post is Amity.Post<'
     post.dataType === 'video'
   );
 }
+
+export function isAmityClipPost(post: Amity.InternalPost): post is Amity.Post<'clip'> {
+  return !!(
+    post.data &&
+    typeof post.data !== 'string' &&
+    'fileId' in post.data &&
+    'thumbnailFileId' in post.data &&
+    post.dataType === 'clip'
+  );
+}