@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

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

@@ -0,0 +1,130 @@
+export const MessageContentType = Object.freeze({
+  TEXT: 'text',
+  IMAGE: 'image',
+  FILE: 'file',
+  VIDEO: 'video',
+  AUDIO: 'audio',
+  CUSTOM: 'custom',
+});
+
+declare global {
+  namespace Amity {
+    type MessageContentType = ValueOf<typeof MessageContentType>;
+
+    type MessageActionType =
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onFetch'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onFlagCleared'
+      | 'onReactionAdded'
+      | 'onReactionRemoved';
+
+    type MessageOptimistic = {
+      syncState?: Amity.SyncState;
+    };
+
+    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'];
+      publicId: string;
+      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'];
+      channelSegment: number;
+      childrenNumber: number;
+      creatorId: string;
+      creator?: Amity.User;
+      editedAt?: Amity.timestamp;
+      parentId?: string;
+      messageId: string;
+      publicId: string;
+      subChannelId: Amity.SubChannel['subChannelId'];
+      channelType: Amity.Channel['type'];
+      uniqueId: string;
+      readCount: number;
+      deliveredCount: number;
+      referenceId?: string;
+      markRead: () => void;
+      addReaction: (reactionName: string) => Promise<boolean>;
+      removeReaction: (reactionName: string) => Promise<boolean>;
+    } & Amity.Content<T> &
+      Amity.Flaggable &
+      Amity.Mentionable<'user' | 'channel'> &
+      Amity.Metadata &
+      Amity.Reactable &
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Timestamps &
+      Amity.Taggable &
+      Amity.MessageOptimistic;
+
+    type InternalMessage<T extends Amity.MessageContentType = any> = Omit<
+      Amity.Message<T>,
+      'readCount' | 'deliveredCount' | 'markRead'
+    > & { creatorPrivateId: string };
+
+    type QueryMessages = {
+      subChannelId: Amity.SubChannel['subChannelId'];
+      type?: Amity.MessageContentType;
+      excludingTags?: 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';
+      includingTags?: Amity.Taggable['tags'];
+      pageToken?: string;
+      aroundMessageId?: Amity.Message['messageId'];
+    };
+
+    type QueryReadUsers = {
+      messageId: Amity.Message['messageId'];
+      memberships?: ('member' | 'banned' | 'muted' | 'non-member' | 'deleted')[];
+      page?: Amity.Page;
+    };
+
+    type QueryDeliveredUsers = {
+      messageId: Amity.Message['messageId'];
+      memberships?: ('member' | 'banned' | 'muted' | 'non-member' | 'deleted')[];
+      page?: Amity.Page;
+    };
+
+    type MessagesLiveCollection = Amity.LiveCollectionParams<Omit<QueryMessages, 'page'>>;
+
+    type MessageLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Message['subChannelId'],
+      Pick<QueryMessages, 'page'> & { paging?: Amity.Pagination['paging'] }
+    >;
+  }
+}

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

@@ -0,0 +1,26 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type InternalMessagePreview<T extends Amity.MessageContentType = any> = {
+      messagePreviewId: string;
+      subChannelName: string;
+      data?: Amity.ContentData<T>;
+      dataType?: T;
+      channelId: Amity.Channel['channelId'];
+      subChannelId: Amity.SubChannel['subChannelId'];
+      isDeleted?: boolean;
+      segment: number;
+      subChannelUpdatedAt: Amity.timestamp;
+      creatorId: Amity.InternalUser['userId'];
+    } & Amity.Timestamps;
+
+    type MessagePreview = Omit<InternalMessagePreview, 'creatorId'> & { user?: Amity.User };
+
+    const enum MessagePreviewSetting {
+      NO_MESSAGE_PREVIEW = 'no-message-preview',
+      MESSAGE_PREVIEW_NOT_INCLUDE_DELETED = 'message-preview-not-include-deleted',
+      MESSAGE_PREVIEW_INCLUDE_DELETED = 'message-preview-include-deleted',
+    }
+  }
+}

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

@@ -0,0 +1,97 @@
+export {};
+
+declare global {
+  namespace Amity {
+    const enum TrayItemCategoryType {
+      POST_MENTION = 'mention_in_post',
+      COMMENT_MENTION = 'mention_in_comment',
+      REPLY_MENTION = 'mention_in_reply',
+      POLL_MENTION = 'mention_in_poll',
+      POST_REACT = 'reaction_on_post',
+      COMMENT_REACT = 'reaction_on_comment',
+      REPLY_REACT = 'reaction_on_reply',
+      RESPONSE_JOIN_REQUEST = 'respond_on_join_request',
+      FOLLOW_USER = 'follow',
+    }
+
+    const enum TrayAction {
+      POST = 'post',
+      POLL = 'poll',
+      COMMENT = 'comment',
+      REACTION = 'reaction',
+      MENTION = 'mention',
+      REPLY = 'reply',
+      JOIN_REQUEST = 'join_request',
+    }
+
+    type RawNotificationTrayItem = {
+      _id: string;
+      lastSeenAt: Amity.timestamp;
+      lastOccurredAt: Amity.timestamp;
+      actors: {
+        _id: string;
+        publicId: string;
+        lastActedAt: Amity.timestamp;
+      }[];
+      actorsCount: number;
+      trayItemCategory?: TrayItemCategoryType;
+      targetId: string;
+      targetType: string;
+      referenceId?: string;
+      referenceType?: string;
+      actionType: TrayAction;
+      actionReferenceId?: string;
+      parentId?: string;
+      text: string;
+      templatedText: string;
+      daySegment: Amity.timestamp;
+    };
+
+    type InternalNotificationTrayItem = RawNotificationTrayItem;
+
+    type QueryNotificationTrayItem = {
+      token?: Amity.Token;
+      limit?: Amity.PageLimit['limit'];
+    };
+
+    type NotificationTrayItemLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryNotificationTrayItem, 'limit'>
+    >;
+
+    type NotificationTrayItemLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalNotificationTrayItem['_id'],
+      Pick<QueryNotificationTrayItem, 'limit'>
+    >;
+
+    type NotificationTrayItem = Amity.InternalNotificationTrayItem & {
+      isSeen: boolean;
+      isRecent: boolean;
+      users: Amity.User[];
+    };
+
+    type RawNotificationTraySeen = {
+      lastTraySeenAt: Amity.timestamp;
+      lastTrayOccurredAt: Amity.timestamp;
+    };
+
+    type RawNotificationTraySeenUpdated = {
+      lastTraySeenAt: Amity.timestamp;
+    };
+
+    type InternalNotificationTraySeen = RawNotificationTraySeen & {
+      userId: string;
+      isSeen: boolean;
+    };
+
+    type NotificationTraySeen = RawNotificationTraySeen & { isSeen: boolean };
+
+    type RawNotificationItemSeen = {
+      lastSeenAt: Amity.timestamp;
+    };
+
+    type QueryNotificationItemSeen = {
+      id: string;
+      lastSeenAt: Amity.timestamp;
+    };
+  }
+}

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

@@ -0,0 +1,76 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type timestamp = string;
+
+    const enum SyncState {
+      Synced = 'synced',
+      Syncing = 'syncing',
+      Error = 'error',
+    }
+
+    type ImageDisplayMode = 'fit' | 'fill';
+
+    type CreatedAt = {
+      createdAt: timestamp;
+    };
+
+    type UpdatedAt = {
+      updatedAt?: timestamp;
+    };
+
+    type DeletedAt = {
+      deletedAt?: timestamp;
+    };
+
+    type ExpiresAt = {
+      expiresAt?: timestamp;
+    };
+
+    type SyncAt = {
+      lastSyncAt: timestamp;
+    };
+
+    type Timestamps = CreatedAt & UpdatedAt;
+
+    type SoftDelete = DeletedAt & {
+      isDeleted?: boolean;
+    };
+
+    type Metadata = {
+      metadata?: Record<string, any>;
+    };
+
+    type Relationship<T extends string> = {
+      referenceId: string;
+      referenceType: T;
+    };
+
+    type Flaggable = {
+      flagCount: number;
+      hashFlag: {
+        bits: number;
+        hashes: number;
+        hash: string;
+      } | null;
+    };
+
+    type Taggable = {
+      tags?: string[];
+    };
+
+    type Accredited = {
+      roles: Amity.Role['displayName'][];
+      permissions: Amity.Permission[];
+    };
+
+    type Subscribable = {
+      path: string;
+    };
+
+    type IsMentioned = {
+      isMentioned: boolean;
+    };
+  }
+}

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

@@ -0,0 +1,27 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type RawPin = {
+      referenceId: string; // postId
+      referenceType: string; // post
+      placement: string; // 'default' | 'announcement' | 'global'
+      pinnedBy: string; // userId
+      pinnedAt: Date;
+    };
+
+    type RawPinTarget = {
+      targetId: string; // communityId | messageFeedId
+      targetType: string; // community | messageFeed
+      lastPinsUpdatedAt: Date;
+    };
+
+    type InternalPin = RawPin;
+
+    type InternalPinTarget = RawPinTarget;
+
+    type Pin = InternalPin;
+
+    type PinTarget = InternalPinTarget;
+  }
+}

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

@@ -0,0 +1,34 @@
+export {};
+
+declare global {
+  namespace Amity {
+    // Raw response from BE, not contain all linked objects
+    type PinnedPostPayload<T extends Amity.PostContentType = any> = {
+      pinTargets: Amity.RawPinTarget[];
+      pins: Amity.RawPin[];
+      posts: Amity.RawPost<T>[];
+      postChildren: Amity.RawPost<T>[];
+      comments: Amity.RawComment[];
+      videoStreamings: Amity.RawStream[];
+      polls: Amity.RawPoll[];
+    } & Amity.CommunityPayload;
+
+    type PinnedPostLiveCollection = Amity.LiveCollectionParams<{
+      communityId: Amity.Community['communityId'];
+      placement?: string | null;
+      sortBy: 'lastPinned' | 'lastCreated';
+    }>;
+
+    type PinnedPostLiveCollectionCache = Omit<
+      Amity.LiveCollectionCache<Amity.InternalPin['referenceId'], Amity.Page>,
+      'params'
+    >;
+
+    type PinnedPost = Amity.RawPin & {
+      post: Amity.Post | undefined;
+      target: Amity.PinTarget | undefined;
+    };
+
+    type GlobalPinnedPostLiveCollection = Amity.LiveCollectionParams<{}>;
+  }
+}

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

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

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

@@ -0,0 +1,156 @@
+export const PostContentType = Object.freeze({
+  TEXT: 'text',
+  IMAGE: 'image',
+  FILE: 'file',
+  VIDEO: 'video',
+  LIVESTREAM: 'liveStream',
+  POLL: 'poll',
+  CLIP: 'clip',
+});
+
+declare global {
+  namespace Amity {
+    // bad hack until we get proper feed objects in backend
+    type PostTargetType = Amity.Feed['targetType'] | 'content' | 'all';
+
+    type PostContentType = ValueOf<typeof PostContentType> | string;
+
+    type PostActionType =
+      | 'onFetch'
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onApproved'
+      | 'onDeclined'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onReactionAdded'
+      | 'onReactionRemoved';
+
+    type RawPost<T extends PostContentType = any> = {
+      postId: string;
+      postedUserId: Amity.RawUser['userId'];
+      parentId: Amity.RawPost['postId'];
+      parentPostId: Amity.RawPost['postId'];
+      targetType: PostTargetType;
+      targetId: string;
+      feedId: Amity.Feed['feedId'];
+      children: Amity.RawPost['postId'][];
+      comments: Amity.InternalComment['commentId'][];
+      commentsCount: number; // API-FIX: backend doesn't follow its own convention
+      hasFlaggedChildren: false;
+      hasFlaggedComment: false;
+      editedAt: Amity.timestamp;
+      // Amity.Metadata
+      metadata?: Record<string, any>;
+      // Amity.Flaggable
+      flagCount: number;
+      hashFlag: {
+        bits: number;
+        hashes: number;
+        hash: string;
+      } | null;
+      // Amity.Taggable
+      tags?: string[];
+      // Amity.Timestamps
+      createdAt: Amity.timestamp;
+      updatedAt?: Amity.timestamp;
+      // Amity.SoftDelete
+      isDeleted?: boolean;
+      // Amity.Subscribable
+      path: string;
+      // Amity.AnalyticPostData
+      impression: number;
+      reach: number;
+      // Amity.Reactable
+      reactionsCount: number;
+      reactions: Record<string, number>;
+      myReactions?: string[];
+      hashtags?: string[];
+    } & Amity.Content<T> &
+      Amity.Mentionable<'user'>;
+
+    type InternalPost<T extends PostContentType = any> = RawPost<T> & {
+      feedType?: 'reviewing' | 'published';
+    };
+
+    type PostLinkObject = {
+      childrenPosts: Amity.Post[];
+      latestComments: (Amity.Comment | null)[];
+      creator: Amity.User | undefined;
+      analytics: {
+        markAsViewed: () => void;
+      };
+      getImageInfo: () => Amity.File<'image'> | undefined;
+      getVideoInfo: () => Amity.File<'video'> | undefined;
+      getVideoThumbnailInfo: () => Amity.File<'image'> | undefined;
+      getFileInfo: () => Amity.File<'file'> | undefined;
+      getPollInfo: () => Amity.Poll | undefined;
+      getLivestreamInfo: () => Amity.Stream | undefined;
+      getClipInfo: () => Amity.File<'clip'> | undefined;
+    };
+
+    type Post<T extends PostContentType = any> = Amity.InternalPost<T> & Amity.PostLinkObject;
+
+    type ClipDisplayMode = 'fill' | 'fit';
+
+    type QueryPosts = {
+      targetId: string;
+      targetType: Amity.InternalPost['targetType'];
+      sortBy?: 'lastCreated' | 'firstCreated';
+      dataTypes?: Exclude<Amity.PostContentType, 'text'>[];
+      includeDeleted?: boolean;
+      hasFlag?: boolean;
+      feedType?: 'reviewing' | 'published';
+      tags?: Amity.Taggable['tags'];
+      matchingOnlyParentPost?: boolean;
+      page?: string;
+      limit?: number;
+    };
+
+    type QueryPostsWithHashtags = {
+      dataTypes?: Exclude<Amity.PostContentType, 'text'>[];
+      targetType: Amity.InternalPost['targetType'];
+      hashtags: string[];
+      matchingOnlyParentPost?: boolean;
+      page?: string;
+      limit?: number;
+    };
+
+    // Omit sortBy explained in asc-3398
+    type PostLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryPosts, 'sortBy' | 'page'> & {
+        sortBy?: 'lastCreated' | 'firstCreated';
+      }
+    >;
+
+    type SearchPostWithHashtagLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryPostsWithHashtags, 'page'> & {
+        sortBy?: 'lastCreated' | 'firstCreated';
+      }
+    >;
+
+    type PostLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalPost['postId'],
+      Pick<QueryPosts, 'page'>
+    >;
+
+    type QuerySemanticSearchPosts = {
+      query: string;
+      targetId?: string;
+      targetType?: Amity.InternalPost['targetType'];
+      dataTypes?: string[];
+      matchingOnlyParentPost?: boolean;
+      limit?: number;
+    };
+
+    type SemanticSearchPostLiveCollection = Amity.LiveCollectionParams<
+      Omit<QuerySemanticSearchPosts, 'page'>
+    >;
+
+    type SemanticSearchPostLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalPost['postId'], // postId:score
+      QuerySemanticSearchPosts
+    >;
+  }
+}

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

@@ -0,0 +1,51 @@
+export {};
+
+declare global {
+  namespace Amity {
+    const enum ReactionActionTypeEnum {
+      OnAdded = 'onAdded',
+      OnRemoved = 'onRemoved',
+    }
+
+    type ReactableType = 'message' | 'post' | 'comment' | 'story';
+
+    type InternalReactor = {
+      reactionId: string;
+      reactionName: string;
+      userId: Amity.InternalUser['userId'];
+    } & {
+      createdAt?: string;
+      updatedAt?: string;
+    };
+
+    type ReactorLinkedObject = {
+      user?: Amity.User;
+    };
+
+    type Reactor = Amity.InternalReactor & Amity.ReactorLinkedObject;
+
+    type Reactable = {
+      reactionsCount: number;
+      reactions: Record<string, number>;
+      myReactions?: string[];
+    };
+
+    type Reaction = {
+      reactors: InternalReactor[];
+    } & Amity.Relationship<ReactableType>;
+
+    type QueryReactions = {
+      referenceId: Amity.Reaction['referenceId'];
+      referenceType: Amity.Reaction['referenceType'];
+      reactionName?: Amity.InternalReactor['reactionName'];
+      page?: Amity.Page<string>;
+    };
+
+    type ReactionLiveCollection = Amity.LiveCollectionParams<Omit<QueryReactions, 'page'>>;
+
+    type ReactionLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalReactor['reactionId'],
+      Pick<QueryReactions, 'page'>
+    >;
+  }
+}