@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

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

@@ -1,8 +1,44 @@
-export {};
+export const CommunityPostSettings = Object.freeze({
+  ONLY_ADMIN_CAN_POST: 'ONLY_ADMIN_CAN_POST',
+  ADMIN_REVIEW_POST_REQUIRED: 'ADMIN_REVIEW_POST_REQUIRED',
+  ANYONE_CAN_POST: 'ANYONE_CAN_POST',
+});
+
+export const CommunityPostSettingMaps = Object.freeze({
+  ONLY_ADMIN_CAN_POST: {
+    needApprovalOnPostCreation: false,
+    onlyAdminCanPost: true,
+  },
+  ADMIN_REVIEW_POST_REQUIRED: {
+    needApprovalOnPostCreation: true,
+    onlyAdminCanPost: false,
+  },
+  ANYONE_CAN_POST: {
+    needApprovalOnPostCreation: false,
+    onlyAdminCanPost: false,
+  },
+});
+
+export const DefaultCommunityPostSetting = 'ONLY_ADMIN_CAN_POST';
 
 declare global {
   namespace Amity {
-    type Community = {
+    type CommunityActionType =
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onJoin'
+      | 'onLeft'
+      | 'onMemberCountChanged';
+
+    type CommunityMemberActionType =
+      | 'onJoin'
+      | 'onLeft'
+      | 'onBan'
+      | 'onUnban'
+      | 'onMemberCountChanged';
+
+    type RawCommunity = {
       communityId: string;
 
       displayName: string;
@@ -30,5 +66,44 @@ declare global {
       Amity.Timestamps &
       Amity.SoftDelete &
       Amity.Subscribable;
+
+    type Community = Omit<Amity.RawCommunity, 'onlyAdminCanPost' | 'needApprovalOnPostCreation'> & {
+      postSetting?: ValueOf<typeof CommunityPostSettings>;
+    };
+
+    type QueryCommunities = {
+      displayName?: string;
+      membership?: 'all' | 'member' | 'notMember';
+      categoryId?: Amity.Category['categoryId'];
+      includeDeleted?: boolean;
+      tags?: Amity.Taggable['tags'];
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      page?: Amity.Page;
+    };
+
+    type CommunityLiveCollection = Amity.LiveCollectionParams<Omit<QueryCommunities, 'page'>>;
+
+    type CommunityLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Community['communityId'],
+      Pick<QueryCommunities, 'page'>
+    >;
+
+    type QueryCommunityMembers = {
+      communityId: string;
+      membership?: ('banned' | 'member')[];
+      roles?: string[];
+      sortBy?: 'firstCreated' | 'lastCreated';
+      search?: Amity.User['displayName'] | Amity.User['userId'];
+      page?: Amity.Page;
+    };
+
+    type CommunityMemberLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryCommunityMembers, 'page'>
+    >;
+
+    type CommunityMemberLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Membership<'community'>['userId'],
+      Pick<QueryCommunityMembers, 'page'>
+    >;
   }
 }

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

@@ -1,8 +1,16 @@
-export {};
+export const ContentFeedType = Object.freeze({
+  STORY: 'story',
+  CLIP: 'clip',
+  CHAT: 'chat',
+  POST: 'post',
+  MESSAGE: 'message',
+});
 
 declare global {
   namespace Amity {
-    type ContentType = 'text' | 'image' | 'file' | 'video' | 'json' | string;
+    type ContentType = 'text' | 'image' | 'file' | 'video' | 'poll' | 'json' | string;
+
+    type ContentFeedType = ValueOf<typeof ContentFeedType>;
 
     type ContentDataText = {
       text: string;
@@ -13,11 +21,24 @@ declare global {
     };
 
     type ContentDataImage = {
-      imageId: Amity.File<'image'>['fileId'];
+      fileId: Amity.File<'image'>['fileId'];
+    };
+
+    type Attachment = {
+      type: 'image' | 'link';
+      url?: string;
+      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 = {
+      pollId: Amity.Poll['pollId'];
     };
 
     type ContentData<T extends ContentType> = T extends 'text'
@@ -28,14 +49,40 @@ declare global {
       ? ContentDataImage
       : T extends 'video'
       ? ContentDataVideo
+      : T extends 'poll'
+      ? ContentDataPoll
       : T extends 'json'
       ? Record<string, unknown>
       : T extends string
       ? string | Record<string, unknown> // custom type
       : never;
 
-    type Content<T extends ContentType, K extends 'type' | 'dataType' = 'dataType'> = {
-      [S in K]?: T;
-    } & { data: ContentData<T> };
+    type Content<T extends ContentType> = {
+      // dataType still retained to maintain backward compatibility
+      dataType?: T;
+      dataTypes?: 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/feed.ts

@@ -2,12 +2,10 @@ export {};
 
 declare global {
   namespace Amity {
-    type FeedType = 'community' | 'user';
-
     type Feed = {
       feedId: string;
       feedType: 'reviewing' | 'published';
-      targetType: FeedType;
+      targetType: Extract<Amity.Domain, 'community' | 'user'>;
       targetId: string;
       postCount: number;
     } & Amity.Timestamps;

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'
       ? {
@@ -24,12 +25,16 @@ declare global {
       : never) &
       Amity.Timestamps;
 
-    type Membership<T extends GroupType> = {
+    type MemberWithUser<T extends GroupType> = Member<T> & { user: Amity.User | undefined };
+
+    type RawMembership<T extends GroupType, WithUser = false> = {
       isBanned: boolean;
       isMuted: boolean;
       muteTimeout: string;
       lastActivity: Amity.timestamp;
-    } & Member<T> &
+    } & (WithUser extends true ? MemberWithUser<T> : Member<T>) &
       Amity.Accredited;
+
+    type Membership<T extends Amity.GroupType> = Amity.RawMembership<T, true>;
   }
 }

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

@@ -1,26 +1,95 @@
-export {};
+export const MessageContentType = Object.freeze({
+  TEXT: 'text',
+  IMAGE: 'image',
+  FILE: 'file',
+  VIDEO: 'video',
+  AUDIO: 'audio',
+  CUSTOM: 'custom',
+});
 
 declare global {
   namespace Amity {
-    type MessageContentType = 'text' | 'file' | 'image';
+    type MessageContentType = ValueOf<typeof MessageContentType>;
 
-    type Message<T extends Amity.MessageContentType = any> = {
+    type MessageActionType =
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onFetch'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onFlagCleared'
+      | 'onReactionAdded'
+      | 'onReactionRemoved';
+
+    type RawMessage<T extends Amity.MessageContentType = any> = {
+      channelId: string;
+      channelPublicId: string;
+      channelType: Amity.Channel['type'];
+      childCount: number;
+      creatorId: string;
+      creatorPublicId: string;
+      // TODO: check if editedAt appears on edit
+      editedAt?: Amity.timestamp;
+      mentionedUsers?: Array<
+        Amity.ChannelMention | (Amity.UserMention & { userPublicIds: string[] })
+      >;
+      messageFeedId: Amity.RawSubChannel['messageFeedId'];
       messageId: string;
+      myReactions?: string[];
+      parentId?: string;
+      reactionCount: number;
+      reactions?: Record<string, number>;
+      referenceId?: string; // https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2085716114/SDK+V5+message+migration#Handling-%E2%80%98ReferenceId%E2%80%99-in-message-creation
+      segment: number;
+    } & Amity.Content<T> &
+      Amity.Flaggable &
+      Amity.Metadata &
+      // Amity.Reactable &
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Taggable &
+      Amity.Timestamps;
 
+    type Message<T extends Amity.MessageContentType = any> = {
       channelId: Amity.Channel['channelId'];
-      userId: Amity.User['userId'];
-
-      parentId?: Message['messageId'];
-      childrenNumber: number;
-
       channelSegment: number;
-
-      editedAt: Amity.timestamp;
-    } & Amity.Content<T, 'type'> &
+      childrenNumber: number;
+      creatorId: string;
+      editedAt?: Amity.timestamp;
+      parentId?: string;
+      messageId: string;
+      subChannelId: Amity.SubChannel['subChannelId'];
+      uniqueId: string;
+    } & Amity.Content<T> &
+      Amity.Mentionable<'user' | 'channel'> &
       Amity.Metadata &
-      Amity.Timestamps &
-      Amity.SoftDelete &
       Amity.Reactable &
-      Amity.Mentionable<'user' | 'channel'>;
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Timestamps &
+      Amity.Taggable;
+
+    type QueryMessages = {
+      subChannelId: Amity.SubChannel['subChannelId'];
+      dataType?: Amity.MessageContentType;
+      excludeTags?: Amity.Taggable['tags'];
+      hasFlags?: boolean;
+      includeDeleted?: boolean;
+      /*
+       * For messages the after and before values are messageId
+       */
+      page?: Amity.Page<string>;
+      parentId?: Amity.Message['parentId'];
+      sortBy?: 'segmentAsc' | 'segmentDesc';
+      tags?: Amity.Taggable['tags'];
+    };
+
+    type MessagesLiveCollection = Amity.LiveCollectionParams<Omit<QueryMessages, 'page'>>;
+
+    type MessageLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Message['subChannelId'],
+      Pick<QueryMessages, 'page'>
+    >;
   }
 }

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

@@ -1,11 +1,30 @@
-export {};
+export const PostContentType = Object.freeze({
+  TEXT: 'text',
+  IMAGE: 'image',
+  FILE: 'file',
+  VIDEO: 'video',
+  LIVESTREAM: 'liveStream',
+  POLL: 'poll',
+});
 
 declare global {
   namespace Amity {
     // bad hack until we get proper feed objects in backend
-    type PostTargetType = Amity.FeedType | 'content';
+    type PostTargetType = Amity.Feed['targetType'] | 'content';
 
-    type PostContentType = 'text' | 'image' | 'file' | 'video' | 'liveStream' | 'poll';
+    type PostContentType = ValueOf<typeof PostContentType>;
+
+    type PostActionType =
+      | 'onFetch'
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onApproved'
+      | 'onDeclined'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onReactionAdded'
+      | 'onReactionRemoved';
 
     type Post<T extends PostContentType = any> = {
       postId: string;
@@ -20,7 +39,7 @@ declare global {
       hasFlaggedChildren: false;
       hasFlaggedComment: false;
       editedAt: Amity.timestamp;
-    } & Amity.Content<T, 'dataType'> &
+    } & Amity.Content<T> &
       Amity.Metadata &
       Amity.Flaggable &
       Amity.Reactable &
@@ -29,5 +48,30 @@ declare global {
       Amity.SoftDelete &
       Amity.Subscribable &
       Amity.Mentionable<'user'>;
+
+    type QueryPosts = {
+      targetId: string;
+      targetType: Amity.Post['targetType'];
+      sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
+      dataTypes?: Exclude<Amity.PostContentType, 'text'>[];
+      includeDeleted?: boolean;
+      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,17 +4,15 @@ declare global {
   namespace Amity {
     type ReactableType = 'message' | 'post' | 'comment';
 
-    type Reaction = {
+    type ReactionActionType = 'onAdded' | 'onRemoved';
+
+    type Reactor = {
       reactionId: string;
-      userId: string;
       reactionName: string;
-    } & Amity.CreatedAt &
-      Amity.Relationship<ReactableType>;
+      userId: Amity.User['userId'];
+    } & Amity.CreatedAt;
 
-    type Reactions = {
-      reactions: Record<string, number>;
-      count: number;
-    };
+    type Reaction = Amity.Reactor & Amity.Relationship<ReactableType>;
 
     type Reactable = {
       reactionsCount: number;
@@ -22,8 +20,27 @@ declare global {
       myReactions?: string[];
 
       latestReaction?: Amity.Reaction & {
-        eventName: 'added' | 'removed';
+        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/domains/subChannel.ts

@@ -0,0 +1,48 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type RawSubChannel = {
+      channelId: string;
+      channelPublicId: string;
+      channelType: Amity.ChannelType;
+      childCount: number;
+      creatorId: string;
+      creatorPublicId: string;
+      editedAt?: Amity.timestamp;
+      isDeleted: boolean;
+      messageFeedId: string;
+      lastMessageId: string;
+      lastMessageTimestamp: Amity.timestamp;
+      name: string;
+    } & Amity.Timestamps &
+      Amity.Subscribable;
+
+    type SubChannel = {
+      channelId: string;
+      creatorId: string;
+      displayName: string;
+      editedAt?: Amity.timestamp;
+      isDeleted: boolean;
+      messageCount: number;
+      lastActivity: Amity.timestamp;
+      latestMessageId: string;
+      subChannelId: string;
+    } & Amity.Timestamps &
+      Amity.Subscribable;
+
+    type QuerySubChannels = {
+      channelId: Amity.Channel['channelId'];
+      excludeDefaultSubChannel?: boolean;
+      includeDeleted?: boolean;
+      page?: Amity.Page;
+    };
+
+    type SubChannelLiveCollection = Amity.LiveCollectionParams<Omit<QuerySubChannels, 'page'>>;
+
+    type SubChannelLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.SubChannel,
+      Pick<QuerySubChannels, 'page'>
+    >;
+  }
+}

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

@@ -2,6 +2,14 @@ export {};
 
 declare global {
   namespace Amity {
+    type UserActionType =
+      | 'onFetch'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onFlagCleared';
+
     type User = {
       _id: string;
       userId: string;
@@ -14,6 +22,21 @@ declare global {
       Amity.Flaggable &
       Amity.Accredited &
       Amity.Timestamps &
+      Amity.SoftDelete &
       Amity.Subscribable;
+
+    type QueryUsers = {
+      displayName?: Amity.User['displayName'];
+      filter?: 'all' | 'flagged';
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      page?: Amity.Page;
+    };
+
+    type UserLiveCollection = Amity.LiveCollectionParams<Omit<QueryUsers, 'page'>>;
+
+    type UserLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.User['userId'],
+      Pick<QueryUsers, 'page'>
+    >;
   }
 }

package/src/@types/global.ts

@@ -25,4 +25,35 @@ declare global {
   interface ObjectConstructor {
     keys<T>(o: T): ObjectKeys<T>;
   }
+
+  type ValueOf<T extends Record<any, any>> = T[keyof T];
+
+  /**
+   *  Make properties required otherwise optional
+   */
+  type MakeRequired<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>;
+
+  /**
+   *  Make properties optional otherwise required
+   */
+  type MakeOptional<T, K extends keyof T> = Partial<Pick<T, K>> & Required<T>;
+}
+
+/*
+ * Extented to pass token expiry into request config, for internal use only.
+ * Since it's in the request config, it does not get sent for the server, and
+ * allows us to intercept the tokenExpiry value to check if the token has not
+ * expired & cancel the request if yes.
+ *
+ */
+declare module 'axios' {
+  export interface AxiosDefaults {
+    // expires at iso string for access token
+    metadata?: { tokenExpiry: string };
+  }
+
+  export interface AxiosRequestConfig {
+    // expires at iso string for access token
+    metadata?: { tokenExpiry: string };
+  }
 }