@amityco/ts-sdk 0.0.1-beta.25 → 0.0.1-beta.28

package/src/@types/core/payload.ts

@@ -24,6 +24,13 @@ declare global {
       files: Amity.File<'image'>[];
     };
 
+    type FeedSettingPayload = {
+      feedSettings: {
+        contentSettings: Amity.ContentSetting[];
+        feedType: Amity.ContentFeedType;
+      }[];
+    };
+
     // API-FIX: backend should return a payload like { files: Amity.File<T>[] }
     type CreateFilePayload<T extends Amity.FileType = any> = Amity.File<T>[];
     type FilePayload<T extends Amity.FileType = any> = Amity.File<T>;
@@ -32,19 +39,18 @@ declare global {
       roles: Amity.Role[];
     };
 
-    type ChannelPayload<T extends Amity.ChannelType = any> = {
-      channels: Amity.Channel<T>[];
-      channelUsers?: Amity.Membership<'channel'>[];
-      users?: Amity.User[];
-      files?: Amity.File[];
-    };
+    type ChannelPayload<
+      T extends Amity.ChannelType = any,
+      U extends Amity.Channel<T> | Amity.ChannelRaw<T> = Amity.ChannelRaw<T>,
+    > = {
+      channels: U[];
+      channelUsers: Amity.Membership<'channel'>[];
+    } & Amity.UserPayload;
 
     type ChannelMembershipPayload = {
-      channels: Amity.Channel[];
+      channels: Amity.ChannelRaw[];
       channelUsers: Amity.Membership<'channel'>[];
-      users?: Amity.User[];
-      files?: Amity.File[];
-    };
+    } & Amity.UserPayload;
 
     type MessagePayload<T extends Amity.MessageContentType = any> = {
       messages: Amity.Message<T>[];
@@ -112,17 +118,16 @@ declare global {
 
     type GlobalFeedPayload = Amity.PostPayload;
 
-    type FollowersPayload = {
-      follows: Amity.FollowStatus[];
-    } & UserPayload;
-
     type FollowStatusPayload = {
       follows: Amity.FollowStatus[];
     };
 
-    type FollowInfoPayload = {
-      follows: Amity.FollowStatus[];
+    type FollowInfoMePayload = {
       followCounts: Amity.FollowCount[];
     };
+
+    type FollowersPayload = Amity.FollowStatusPayload & UserPayload;
+
+    type FollowInfoPayload = FollowInfoMePayload & Amity.FollowStatusPayload;
   }
 }

package/src/@types/domains/channel.ts

@@ -4,10 +4,20 @@ declare global {
   namespace Amity {
     type ChannelType = 'broadcast' | 'conversation' | 'community' | 'live';
 
+    type ChannelActionType =
+      | 'onFetch'
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onJoin'
+      | 'onLeft'
+      | 'onMemberAdded'
+      | 'onMemberRemoved';
+
     type Channel<T extends ChannelType = any> = {
       channelId: string;
       displayName?: string;
-      avatarFileId?: File<'image'>['fileId'];
+      avatarFileId?: Amity.File<'image'>['fileId'];
       type: T;
 
       isDistinct?: boolean;
@@ -27,9 +37,14 @@ declare global {
       messageCount?: number;
 
       lastActivity?: Amity.timestamp;
+
+      unreadCount: number;
+      hasMention: boolean;
     } & Amity.Metadata &
       Amity.Taggable &
       Amity.Timestamps &
       Amity.SoftDelete;
+
+    type ChannelRaw<T extends ChannelType = any> = Omit<Channel<T>, 'unreadCount' | 'hasMention'>;
   }
 }

package/src/@types/domains/client.ts

@@ -21,6 +21,8 @@ declare global {
       accessToken?: string;
 
       use: () => void;
+
+      getFeedSettings: () => Promise<Amity.FeedSettings>;
     };
 
     type Device = {
@@ -36,5 +38,20 @@ declare global {
       accessToken: string;
       refreshToken: string;
     };
+
+    type FeedSettings = {
+      [name in Amity.ContentFeedType]?: Amity.ContentSetting[];
+    };
+
+    type ConnectClientParams = {
+      userId: Amity.User['userId'];
+      displayName?: Amity.User['displayName'];
+      authToken?: string;
+      deviceId?: Amity.Device['deviceId'];
+    };
+
+    type ConnectClientConfig = {
+      disableRTE: boolean;
+    };
   }
 }

package/src/@types/domains/comment.ts

@@ -5,6 +5,16 @@ declare global {
     type CommentContentType = 'text';
     type CommentReferenceType = 'content' | 'post';
 
+    type CommentActionType =
+      | 'onFetch'
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onReactionAdded'
+      | 'onReactionRemoved';
+
     type Comment<T extends CommentContentType = any> = {
       commentId: string;
       userId: string;
@@ -23,5 +33,26 @@ declare global {
       Amity.SoftDelete &
       Amity.Subscribable &
       Amity.Mentionable<'user'>;
+
+    type QueryComments = {
+      referenceType: Amity.Comment['referenceType'];
+      referenceId: Amity.Comment['referenceId'];
+      sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
+      parentId?: Amity.Comment['commentId'] | null;
+      hasFlag?: boolean;
+      isDeleted?: Amity.Comment['isDeleted'];
+      page?: Amity.Page;
+    };
+
+    type CommentLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryComments, 'sortBy' | 'page'> & {
+        sortBy?: 'lastCreated' | 'firstCreated';
+      }
+    >;
+
+    type CommentLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Comment['commentId'],
+      Pick<QueryComments, 'page'>
+    >;
   }
 }

package/src/@types/domains/content.ts

@@ -1,9 +1,16 @@
-export {};
+export const ContentFeedType = Object.freeze({
+  STORY: 'story',
+  CHIP: 'clip',
+  CHAT: 'chat',
+  POST: 'post',
+});
 
 declare global {
   namespace Amity {
     type ContentType = 'text' | 'image' | 'file' | 'video' | 'poll' | 'json' | string;
 
+    type ContentFeedType = ValueOf<typeof ContentFeedType>;
+
     type ContentDataText = {
       text: string;
     };
@@ -13,11 +20,14 @@ declare global {
     };
 
     type ContentDataImage = {
-      imageId: Amity.File<'image'>['fileId'];
+      fileId: Amity.File<'image'>['fileId'];
     };
 
     type ContentDataVideo = {
-      videoId: Amity.File<'file'>['fileId'];
+      thumbnailFileId: Amity.File<'image'>['fileId'];
+      videoFileId: {
+        [K in Amity.VideoSize]?: Amity.File<'video'>['fileId'];
+      };
     };
 
     type ContentDataPoll = {
@@ -43,5 +53,26 @@ declare global {
     type Content<T extends ContentType, K extends 'type' | 'dataType' = 'dataType'> = {
       [S in K]?: T;
     } & { data: ContentData<T> };
+
+    type ContentSettingText = {
+      contentType: 'text';
+      allowed: boolean;
+    };
+
+    type ContentSettingVideo = {
+      contentType: 'video';
+      allowed: boolean;
+      maxDurationSeconds: number;
+      transcodeConfig: {
+        maxResolution: Amity.VideoResolution;
+        minResolution: Amity.VideoResolution;
+      };
+    };
+
+    type ContentSetting<T extends ContentType = 'text' | 'video'> = T extends 'text'
+      ? ContentSettingText
+      : T extends 'video'
+      ? ContentSettingVideo
+      : never;
   }
 }

package/src/@types/domains/file.ts

@@ -1,8 +1,40 @@
-export {};
+export const FileType = Object.freeze({
+  FILE: 'file',
+  IMAGE: 'image',
+  VIDEO: 'video',
+});
+
+export const VideoResolution = Object.freeze({
+  '1080P': '1080p',
+  '720P': '720p',
+  '480P': '480p',
+  '360P': '360p',
+  ORIGINAL: 'original',
+});
+
+export const VideoTranscodingStatus = Object.freeze({
+  UPLOADED: 'uploaded',
+  TRANSCODING: 'transcoding',
+  TRANSCODED: 'transcoded',
+  TRANSCODE_FAILED: 'transcodeFailed',
+});
+
+export const VideoSize = Object.freeze({
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high',
+  ORIGINAL: 'original',
+});
 
 declare global {
   namespace Amity {
-    type FileType = 'file' | 'image' | 'video';
+    type FileType = ValueOf<typeof FileType>;
+
+    type VideoResolution = ValueOf<typeof VideoResolution>;
+
+    type VideoTranscodingStatus = ValueOf<typeof VideoTranscodingStatus>;
+
+    type VideoSize = ValueOf<typeof VideoSize>;
 
     type FileMetadata = Record<string, never>;
 
@@ -24,6 +56,12 @@ declare global {
       ? VideoMetadata
       : never;
 
+    type VideoFileExtraPayload = {
+      feedType: Amity.ContentFeedType;
+      status: VideoTranscodingStatus;
+      videoUrl?: { [name in VideoResolution]?: string } | null;
+    };
+
     type File<T extends FileType = any> = {
       fileId: string;
       type: T;
@@ -35,7 +73,8 @@ declare global {
         mimeType: string;
         metadata: MetadataFor<T>;
       };
-    } & Amity.Timestamps &
+    } & (T extends 'video' ? VideoFileExtraPayload : unknown) &
+      Amity.Timestamps &
       Amity.SoftDelete;
   }
 }

package/src/@types/domains/follow.ts

@@ -2,10 +2,21 @@ export {};
 
 declare global {
   namespace Amity {
+    type FollowActionType =
+      | 'onRequested'
+      | 'onAccepted'
+      | 'onDeclined'
+      | 'onCanceled'
+      | 'onFollowed'
+      | 'onUnfollowed'
+      | 'onDeleted';
+
+    type FollowStatusType = 'all' | 'pending' | 'accepted' | 'none';
+
     type FollowStatus = {
       from: Amity.User['userId'];
       to: Amity.User['userId'];
-      status: 'pending' | 'accepted' | 'none';
+      status: Exclude<FollowStatusType, 'all'>;
     } & Amity.CreatedAt &
       Amity.UpdatedAt;
 
@@ -19,5 +30,24 @@ declare global {
     type FollowInfo = {
       status?: FollowStatus['status'];
     } & FollowCount;
+
+    type QueryFollowers = {
+      userId: Amity.User['userId'];
+      status?: Exclude<Amity.FollowStatusType, 'none'>;
+      page?: Amity.PageRaw;
+    };
+
+    type FollowerLiveCollection = Amity.LiveCollectionParams<Omit<QueryFollowers, 'page'>>;
+
+    type FollowerLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.FollowInfo['userId'],
+      Pick<QueryFollowers, 'page'>
+    >;
+
+    type QueryFollowings = QueryFollowers;
+
+    type FollowingLiveCollection = FollowerLiveCollection;
+
+    type FollowingLiveCollectionCache = FollowerLiveCollectionCache;
   }
 }

package/src/@types/domains/group.ts

@@ -15,6 +15,7 @@ declare global {
           channelId: Amity.Channel['channelId'];
           membership: 'member' | 'none' | 'banned';
           readToSegment: number;
+          lastMentionedSegment: number;
         }
       : T extends 'community'
       ? {

package/src/@types/domains/message.ts

@@ -12,6 +12,8 @@ declare global {
       ? { fileId: string }
       : unknown;
 
+    type MessageActionType = 'onCreate' | 'onUpdate' | 'onDelete';
+
     type Message<T extends Amity.MessageContentType = any> = {
       messageId: string;
 
@@ -32,5 +34,23 @@ declare global {
       Amity.Taggable &
       Amity.Reactable &
       Amity.Mentionable<'user' | 'channel'>;
+
+    type QueryMessages = {
+      channelId: Amity.Channel['channelId'];
+      type?: Amity.MessageContentType;
+      parentId?: Amity.Message['parentId'];
+      filterByParentId?: boolean;
+      isDeleted?: boolean;
+      tags?: Amity.Taggable['tags'];
+      excludeTags?: Amity.Taggable['tags'];
+      page?: Amity.Page;
+    };
+
+    type MessagesLiveCollection = Amity.LiveCollectionParams<Omit<QueryMessages, 'page'>>;
+
+    type MessageLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Message['channelId'],
+      Pick<QueryMessages, 'page'>
+    >;
   }
 }

package/src/@types/domains/post.ts

@@ -7,6 +7,18 @@ declare global {
 
     type PostContentType = 'text' | 'image' | 'file' | 'video' | 'liveStream' | 'poll';
 
+    type PostActionType =
+      | 'onFetch'
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onApproved'
+      | 'onDeclined'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onReactionAdded'
+      | 'onReactionRemoved';
+
     type Post<T extends PostContentType = any> = {
       postId: string;
       postedUserId: Amity.User['userId']; // API-FIX: it should be "userId"
@@ -29,5 +41,30 @@ declare global {
       Amity.SoftDelete &
       Amity.Subscribable &
       Amity.Mentionable<'user'>;
+
+    type QueryPosts = {
+      targetId: string;
+      targetType: Amity.Post['targetType'];
+      sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
+      dataType?: string;
+      isDeleted?: Amity.Post['isDeleted'];
+      hasFlag?: boolean;
+      feedType?: 'reviewing' | 'published';
+      tags?: Amity.Taggable['tags'];
+      matchingOnlyParentPost?: boolean;
+      page?: Amity.PageRaw;
+    };
+
+    // Omit sortBy explained in asc-3398
+    type PostLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryPosts, 'sortBy' | 'page'> & {
+        sortBy?: 'lastCreated' | 'firstCreated';
+      }
+    >;
+
+    type PostLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Post['postId'],
+      Pick<QueryPosts, 'page'>
+    >;
   }
 }

package/src/@types/domains/reaction.ts

@@ -4,6 +4,8 @@ declare global {
   namespace Amity {
     type ReactableType = 'message' | 'post' | 'comment';
 
+    type ReactionActionType = 'onAdded' | 'onRemoved';
+
     type Reactor = {
       reactionId: string;
       reactionName: string;
@@ -19,11 +21,26 @@ declare global {
 
       latestReaction?: Amity.Reaction & {
         eventName: 'add' | 'remove';
+        userDisplayName: string;
       };
     };
 
     type ReactionQuery = {
       reactors: Reactor[];
     } & Amity.Relationship<ReactableType>;
+
+    type QueryReactions = {
+      referenceId: Amity.Reaction['referenceId'];
+      referenceType: Amity.Reaction['referenceType'];
+      reactionName?: Amity.Reaction['reactionName'];
+      page?: Amity.Page<string>;
+    };
+
+    type ReactionLiveCollection = Amity.LiveCollectionParams<Omit<QueryReactions, 'page'>>;
+
+    type ReactionLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Reactor['reactionId'],
+      Pick<QueryReactions, 'page'>
+    >;
   }
 }

package/src/@types/global.ts

@@ -25,4 +25,6 @@ declare global {
   interface ObjectConstructor {
     keys<T>(o: T): ObjectKeys<T>;
   }
+
+  type ValueOf<T extends Record<any, any>> = T[keyof T];
 }

package/src/@types/index.ts

@@ -8,16 +8,15 @@ import './core/events'; // sdk events definitions
 import './core/paging'; // createQuery, runQuery
 import './core/query'; // createQuery, runQuery
 import './core/cache'; // cache.pull('user', ...)
+import './core/live';
 
 // domains
 import './domains/client'; // client definition
 
 import './domains/user';
 import './domains/follow';
-import './domains/file';
 
 import './domains/partials'; // small model partials (CreatedAt, etc...)
-import './domains/content'; // content partial
 import './domains/reaction';
 
 import './domains/group';
@@ -34,3 +33,6 @@ import './domains/stream';
 import './domains/mention';
 
 import './domains/poll';
+
+export * from './domains/content';
+export * from './domains/file';

package/src/channel/api/addChannelMembers.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { addChannelMembers } from '@amityco/ts-sdk'
@@ -25,17 +27,16 @@ export const addChannelMembers = async (
   const client = getActiveClient();
   client.log('channel/addChannelMembers', channelId, userIds);
 
-  const { data } = await client.http.post<Amity.ChannelMembershipPayload>(
+  const { data: payload } = await client.http.post<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
     { channelId, userIds },
   );
 
+  const data = prepareChannelPayload(payload);
+
   if (client.cache) ingestInCache(data);
 
-  fireEvent('v3.channel.didAddUsers', {
-    channels: data.channels,
-    channelUsers: data.channelUsers,
-  });
+  fireEvent('v3.channel.didAddUsers', data);
 
   const { channelUsers } = data;
   return !!channelUsers.find(

package/src/channel/api/addChannelMembersRole.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { addChannelMembersRole } from '@amityco/ts-sdk'
@@ -26,11 +28,13 @@ export const addChannelMembersRole = async (
   const client = getActiveClient();
   client.log('channel/addChannelMembersRole', channelId, roleId, userIds);
 
-  const { data } = await client.http.post<Amity.ChannelMembershipPayload>(
+  const { data: payload } = await client.http.post<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`,
     { channelId, role: roleId, userIds },
   );
 
+  const data = prepareChannelPayload(payload);
+
   if (client.cache) ingestInCache(data);
 
   const { channelUsers } = data;

package/src/channel/api/banChannelMembers.ts

@@ -0,0 +1,45 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { banChannelMembers } from '@amityco/ts-sdk'
+ *
+ * await banChannelMembers('channel-id-1', ['userId1', 'userId2'])
+ * ```
+ *
+ * @param channelId of {@link Amity.Channel} from which the users should be banned
+ * @param userIds of the {@link Amity.User}'s to be banned
+ * @returns the updated {@link Amity.Membership}'s object
+ *
+ * @category Channel API
+ * @async
+ * */
+export const banChannelMembers = async (
+  channelId: Amity.Channel['channelId'],
+  userIds: Amity.User['userId'][],
+): Promise<Amity.Cached<Amity.Membership<'channel'>[]>> => {
+  const client = getActiveClient();
+  client.log('channel/banChannelMembers', { userIds, channelId });
+
+  const { data: payload } = await client.http.put<Amity.ChannelPayload>(
+    `/api/v3/channels/${channelId}/users/ban`,
+    {
+      userIds,
+    },
+  );
+
+  const data = prepareChannelPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { channelUsers } = data;
+  return {
+    data: channelUsers?.filter(user => user.membership === 'banned')!,
+    cachedAt,
+  };
+};

package/src/channel/api/createChannel.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { createChannel } from '@amityco/ts-sdk'
@@ -36,10 +38,12 @@ export const createChannel = async <T extends Amity.ChannelType>(
     payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels', bundle);
   }
 
+  const data = prepareChannelPayload(payload.data);
+
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(payload.data, { cachedAt });
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { channels } = payload.data;
+  const { channels } = data;
   return {
     data: channels[0],
     cachedAt,

package/src/channel/api/getChannel.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { getChannel } from '@amityco/ts-sdk'
@@ -24,10 +26,12 @@ export const getChannel = async (
   client.log('channel/getChannel', channelId);
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.ChannelPayload>(
+  const { data: payload } = await client.http.get<Amity.ChannelPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}`,
   );
 
+  const data = prepareChannelPayload(payload);
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });