@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

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

@@ -1,35 +1,88 @@
-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 ContentDataText = { text: string }
-    type ContentDataFile = { fileId: Amity.File<'file'>['fileId'] }
-    type ContentDataImage = { imageId: Amity.File<'image'>['fileId'] }
-    type ContentDataVideo = { videoId: Amity.File<'file'>['fileId'] }
-
-    type ContentData<T extends ContentType> = (
-      T extends 'text'  ? ContentDataText :
-      T extends 'file'  ? ContentDataFile :
-      T extends 'image' ? ContentDataImage :
-      T extends 'video' ? ContentDataVideo :
-      T extends 'json'  ? object :
-      T extends string  ? any : // custom type
-      never
-    )
-
-    type ContentTypeFor<T> = (
-      T extends ContentDataText ? 'text' :
-      T extends ContentDataFile ? 'file' :
-      T extends ContentDataImage ? 'image' :
-      T extends ContentDataVideo ? 'video' :
-      T extends object ? 'json' :
-      'custom'
-    )
-
-    type Content<T extends ContentType, K extends 'type' | 'dataType' = 'dataType'> = (
-      { [S in K]?: T } & { data: ContentData<T> }
-    )
+    type ContentType = 'text' | 'image' | 'file' | 'video' | 'poll' | 'json' | string;
+
+    type ContentFeedType = ValueOf<typeof ContentFeedType>;
+
+    type ContentDataText = {
+      text: string;
+    };
+
+    type ContentDataFile = {
+      fileId: Amity.File<'file'>['fileId'];
+    };
+
+    type ContentDataImage = {
+      fileId: Amity.File<'image'>['fileId'];
+    };
+
+    type Attachment = {
+      type: 'image' | 'link';
+      url?: string;
+      fileId?: Amity.File<'image'>['fileId'];
+    };
+
+    type ContentDataVideo = {
+      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'
+      ? ContentDataText
+      : T extends 'file'
+      ? ContentDataFile
+      : T extends 'image'
+      ? 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> = {
+      // 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

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

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

@@ -1,41 +1,80 @@
-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'
+    type FileType = ValueOf<typeof FileType>;
+
+    type VideoResolution = ValueOf<typeof VideoResolution>;
 
-    type FileMetadata = {}
+    type VideoTranscodingStatus = ValueOf<typeof VideoTranscodingStatus>;
+
+    type VideoSize = ValueOf<typeof VideoSize>;
+
+    type FileMetadata = Record<string, never>;
 
     type ImageMetadata = {
-      exif: Object
-      gps: Object
-      width: number
-      height: number
-      isFull:	boolean
-    }
+      exif: Record<string, unknown>;
+      gps: Record<string, unknown>;
+      width: number;
+      height: number;
+      isFull: boolean;
+    };
+
+    type VideoMetadata = Record<string, never>;
 
-    type VideoMetadata = {}
+    type MetadataFor<T extends FileType> = T extends 'file'
+      ? FileMetadata
+      : T extends 'image'
+      ? ImageMetadata
+      : T extends 'video'
+      ? VideoMetadata
+      : never;
 
-    type MetadataFor<T extends FileType> = (
-      T extends 'file' ? FileMetadata :
-      T extends 'image' ? ImageMetadata :
-      never
-    )
+    type VideoFileExtraPayload = {
+      feedType: Amity.ContentFeedType;
+      status: VideoTranscodingStatus;
+      videoUrl?: { [name in VideoResolution]?: string } | null;
+    };
 
     type File<T extends FileType = any> = {
-      fileId:	string
-      type: T
-      fileUrl: string
+      fileId: string;
+      type: T;
+      fileUrl: string;
       attributes: {
-        name: string
-        extension: string
-        size: string
-        mimeType: string
-        metadata: MetadataFor<T>
-      }
-    }
-    & Amity.Timestamps
-    & Amity.SoftDelete
-    & Amity.Syncable
+        name: string;
+        extension: string;
+        size: string;
+        mimeType: string;
+        metadata: MetadataFor<T>;
+      };
+    } & (T extends 'video' ? VideoFileExtraPayload : unknown) &
+      Amity.Timestamps &
+      Amity.SoftDelete;
   }
 }

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

@@ -0,0 +1,53 @@
+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: Exclude<FollowStatusType, 'all'>;
+    } & Amity.CreatedAt &
+      Amity.UpdatedAt;
+
+    type FollowCount = {
+      userId: Amity.User['userId'];
+      followerCount: number;
+      followingCount: number;
+      pendingCount: number;
+    };
+
+    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

@@ -1,38 +1,40 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type GroupType = ('channel' | 'community')
+    type GroupType = 'channel' | 'community';
 
     type Group = {
-      membersCount: number
-    }
+      membersCount: number;
+    };
 
     type Member<T extends GroupType> = {
-      userId: User['userId']
-    } & (
-      T extends 'channel' ? {
-        channelId: Amity.Channel['channelId']
-        membership: 'member' | 'notMember' | 'banned'
-        readToSegment: number
-      } :
-      T extends 'community' ? {
-        communityId: Amity.Community['communityId']
-        communityMembership: 'member' | 'notMember' | 'banned'
-      } :
-      never
-    )
-    & Timestamps
+      userId: Amity.User['userId'];
+    } & (T extends 'channel'
+      ? {
+          channelId: Amity.Channel['channelId'];
+          membership: 'member' | 'none' | 'banned';
+          readToSegment: number;
+          lastMentionedSegment: number;
+        }
+      : T extends 'community'
+      ? {
+          communityId: Amity.Community['communityId'];
+          communityMembership: 'member' | 'none' | 'banned';
+        }
+      : never) &
+      Amity.Timestamps;
 
+    type MemberWithUser<T extends GroupType> = Member<T> & { user: Amity.User | undefined };
 
-    type Membership<T extends GroupType> = {
-      isBanned: boolean
-      isMuted: boolean
-      muteTimeout: string
-      lastActivity: timestamp
-    }
-    & Member<T>
-    & Amity.Accredited
-    & Amity.Syncable
+    type RawMembership<T extends GroupType, WithUser = false> = {
+      isBanned: boolean;
+      isMuted: boolean;
+      muteTimeout: string;
+      lastActivity: Amity.timestamp;
+    } & (WithUser extends true ? MemberWithUser<T> : Member<T>) &
+      Amity.Accredited;
+
+    type Membership<T extends Amity.GroupType> = Amity.RawMembership<T, true>;
   }
 }

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

@@ -0,0 +1,27 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type Mention = {
+      type: 'user' | 'channel';
+    };
+
+    type ChannelMention = Mention & {
+      type: 'channel';
+    };
+
+    type UserMention = Mention & {
+      type: 'user';
+      userIds: string[];
+    };
+
+    type MentionType = {
+      channel: ChannelMention;
+      user: UserMention;
+    };
+
+    type Mentionable<T extends keyof MentionType = 'channel' | 'user'> = {
+      mentionees?: MentionType[T][];
+    };
+  }
+}

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

@@ -1,27 +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> = {
-      messageId: string
+    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;
 
-      channelId: Amity.Channel['channelId']
-      userId: Amity.User['userId']
+    type Message<T extends Amity.MessageContentType = any> = {
+      channelId: Amity.Channel['channelId'];
+      channelSegment: number;
+      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.Reactable &
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Timestamps &
+      Amity.Taggable;
 
-      parentId?: Message['messageId']
-      childrenNumber: number
+    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'];
+    };
 
-      channelSegment: number
+    type MessagesLiveCollection = Amity.LiveCollectionParams<Omit<QueryMessages, 'page'>>;
 
-      editedAt: timestamp
-    }
-    & Amity.Content<T, 'type'>
-    & Amity.Metadata
-    & Amity.Timestamps
-    & Amity.SoftDelete
-    & Amity.Syncable
-    & Amity.Reactable
+    type MessageLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Message['subChannelId'],
+      Pick<QueryMessages, 'page'>
+    >;
   }
 }

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

@@ -1,52 +1,56 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type timestamp = string
+    type timestamp = string;
 
     type CreatedAt = {
-      createdAt: timestamp
-    }
+      createdAt: timestamp;
+    };
 
     type UpdatedAt = {
-      updatedAt?: timestamp
-    }
+      updatedAt?: timestamp;
+    };
 
     type DeletedAt = {
-      deletedAt?: timestamp
-    }
+      deletedAt?: timestamp;
+    };
 
-    type Timestamps = CreatedAt & UpdatedAt
+    type Timestamps = CreatedAt & UpdatedAt;
 
     type SoftDelete = DeletedAt & {
-      isDeleted?: boolean
-    }
+      isDeleted?: boolean;
+    };
 
     type Metadata = {
-      metadata?: Record<string, any>
-    }
+      metadata?: Record<string, any>;
+    };
 
     type Relationship<T extends string> = {
-      referenceId: string
-      referenceType: T
-    }
+      referenceId: string;
+      referenceType: T;
+    };
 
     type Flaggable = {
-      flagCount: number
+      flagCount: number;
       hashFlag: {
-        bits: number
-        hashes: number
-        hash: string
-      } | null
-    }
+        bits: number;
+        hashes: number;
+        hash: string;
+      } | null;
+    };
 
     type Taggable = {
-      tags?: string[]
-    }
+      tags?: string[];
+    };
 
     type Accredited = {
-        roles: Amity.Role['displayName'][]
-        permissions: Amity.Permission[]
-    }
+      roles: Amity.Role['displayName'][];
+      permissions: Amity.Permission[];
+    };
+
+    type Subscribable = {
+      path: string;
+    };
   }
 }

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

@@ -0,0 +1,32 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type PollDataType = 'text';
+
+    type PollAnswerType = 'single' | 'multiple';
+
+    type PollAnswer = {
+      id: string;
+      dataType: PollDataType;
+      data: string;
+      voteCount: number;
+      isVotedByUser: boolean;
+    };
+
+    type PollStatus = 'closed' | 'open';
+
+    type Poll = {
+      pollId: string;
+      question: string;
+      answers: PollAnswer[];
+      answerType: PollAnswerType;
+      closedAt?: Amity.timestamp;
+      closedIn?: number;
+      isVoted?: boolean;
+      status: PollStatus;
+      userId: Amity.User['userId'];
+    } & Amity.Timestamps &
+      Amity.SoftDelete;
+  }
+}