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

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

@@ -0,0 +1,180 @@
+import { AxiosInstance } from 'axios';
+import { Emitter } from 'mitt';
+
+export const enum MembershipAcceptanceTypeEnum {
+  AUTOMATIC = 'automatic',
+  INVITATION = 'invitation',
+}
+
+declare global {
+  namespace Amity {
+    type Logger = (topic: string, ...args: any[]) => void;
+
+    type MembershipAcceptanceType = MembershipAcceptanceTypeEnum;
+
+    const enum TokenTerminationReason {
+      GLOBAL_BAN = 'globalBan',
+      USER_DELETED = 'userDeleted',
+      UNAUTHORIZED = 'unauthorized',
+    }
+
+    const enum SessionStates {
+      NOT_LOGGED_IN = 'notLoggedIn',
+
+      ESTABLISHING = 'establishing',
+      ESTABLISHED = 'established',
+
+      TOKEN_EXPIRED = 'tokenExpired',
+      /*
+       * Terminated is slightly different from NOT_LOGGED_IN:
+       *
+       * After established, upon receiving the termination code, the SDK will move to terminated.
+       * Unlike tokenExpired that users can regain SDK usability by giving an auth token.
+       * This state represents unrecoverable failures. The app must manually re-login with a valid user.
+       *
+       * For more details, please check tech spec:
+       * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#terminated
+       */
+      TERMINATED = 'terminated',
+    }
+
+    type Client = {
+      version: string;
+
+      log: Logger;
+      http: AxiosInstance;
+      upload: AxiosInstance;
+      mqtt?: Amity.MqttClient;
+      emitter: Emitter<Amity.Events>;
+
+      hasPermission: (permission: string) => Amity.PermissionChecker;
+      validateUrls: (urls: string[]) => Promise<boolean>;
+      validateTexts: (texts: string[]) => Promise<boolean>;
+
+      sessionState: Amity.SessionStates;
+      sessionHandler?: Amity.SessionHandler;
+
+      cache?: Amity.Cache;
+
+      apiKey?: string;
+      userId?: string;
+
+      token?: Amity.Tokens;
+
+      isUnreadCountEnabled: boolean;
+
+      useLegacyUnreadCount: boolean;
+
+      use: () => void;
+
+      accessTokenExpiryWatcher: (sessionHandler: Amity.SessionHandler) => Amity.Unsubscriber;
+
+      getFeedSettings: () => Promise<Amity.FeedSettings>;
+      getSocialSettings: () => Promise<Amity.SocialSettings>;
+      getMessagePreviewSetting: (refresh?: boolean) => Promise<Amity.MessagePreviewSetting>;
+
+      getMarkerSyncConsistentMode: () => boolean;
+
+      prefixDeviceIdKey?: string;
+
+      getVisitorDeviceId: () => Promise<string>;
+    };
+
+    type Device = {
+      deviceId: string;
+      deviceInfo: {
+        kind: 'node' | 'web';
+        model?: string;
+        sdkVersion: string;
+      };
+    };
+
+    type Tokens = {
+      accessToken: string;
+      // issuedAt, expiresAt is in iso Date format
+      issuedAt: string;
+      expiresAt: string;
+    };
+
+    type SessionResponse = Tokens & {
+      users: Amity.RawUser[];
+      userType: Amity.UserType;
+    };
+
+    type AccessTokenRenewal = {
+      renew: () => void;
+      renewWithAuthToken: (authToken: string) => void;
+      unableToRetrieveAuthToken: () => void;
+      renewWithAuthSignature: ({
+        authSignature,
+        authSignatureExpiresAt,
+      }: Amity.ConnectClientAsVisitorParams) => void;
+      unableToRetrieveAuthSignature: () => void;
+    };
+
+    interface SessionHandler {
+      sessionWillRenewAccessToken(renewal: AccessTokenRenewal): void;
+    }
+
+    type ChatSettings = {
+      enabled: boolean;
+      mention: {
+        isAllowMentionedChannelEnabled: boolean;
+      };
+      messagePreview: {
+        enabled: boolean;
+        isIncludeDeleted: boolean;
+      };
+    };
+
+    type ShareableLinkConfiguration = {
+      domain: string;
+      patterns: Record<string, string>;
+    };
+
+    type FeedSettings = {
+      [name in Amity.ContentFeedType]?: Amity.ContentSetting[];
+    };
+
+    type SocialSettings = {
+      enabled: boolean;
+      isAllowEditPostWhenReviewingEnabled: boolean;
+      isFollowWithRequestEnabled: boolean;
+      globalFeed: {
+        showCommunityPost: boolean;
+        showEveryonePost: boolean;
+        showFollowingPost: boolean;
+        showMyPost: boolean;
+        showOnlyMyFeed: boolean;
+      };
+      story: {
+        allowAllUserToCreateStory: boolean;
+        expiryTimeMinutes: number;
+      };
+      userPrivacySetting: 'public' | 'private';
+      membershipAcceptance: Amity.MembershipAcceptanceType;
+    };
+
+    type ConnectClientParams = {
+      userId: Amity.InternalUser['userId'];
+      displayName?: Amity.InternalUser['displayName'];
+      authToken?: string;
+      deviceId?: Amity.Device['deviceId'];
+    };
+
+    type ConnectClientAsVisitorParams = {
+      authSignature?: string;
+      authSignatureExpiresAt?: string;
+    };
+
+    type ConnectClientConfig = {
+      disableRTE: boolean;
+    };
+
+    type ActiveUser = Pick<Amity.InternalUser, '_id' | 'userId' | 'path' | 'displayName'>;
+
+    type UserUnread = Pick<Amity.UserMarker, 'unreadCount'> & {
+      isMentioned: boolean;
+    };
+  }
+}

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

@@ -0,0 +1,83 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type CommentContentType = 'text';
+    type CommentReferenceType = 'content' | 'post' | 'story';
+
+    type CommentActionType =
+      | 'onFetch'
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onReactionAdded'
+      | 'onReactionRemoved';
+
+    type RawComment<T extends CommentContentType = any> = {
+      commentId: string;
+      userId: string;
+      parentId?: RawComment['commentId'];
+      rootId: RawComment['commentId'];
+      childrenNumber: number;
+      children: RawComment['commentId'][];
+      segmentNumber: number;
+      editedAt: Amity.timestamp;
+      attachments?: Amity.Attachment[];
+      targetId: string;
+      targetType: 'community' | 'user' | 'content';
+    } & Amity.Relationship<CommentReferenceType> &
+      Amity.Content<T> &
+      Amity.Metadata &
+      Amity.Flaggable &
+      Amity.Reactable &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Mentionable<'user'>;
+
+    type InternalComment<T extends CommentContentType = any> = RawComment<T>;
+
+    type CommentTarget = {
+      type: InternalComment['targetType'] | 'unknown';
+      communityId?: Amity.Community['communityId'];
+      userId?: Amity.InternalUser['userId'];
+      contentId?: string;
+      creatorMember?: Amity.Membership<'community'>;
+    };
+
+    type Comment<T extends CommentContentType = any> = Amity.InternalComment<T> & {
+      target: Amity.CommentTarget;
+      creator?: Amity.User;
+    };
+
+    type QueryComments = {
+      referenceType: Amity.InternalComment['referenceType'];
+      referenceId: Amity.InternalComment['referenceId'];
+      sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
+      parentId?: Amity.InternalComment['commentId'] | null;
+      hasFlag?: boolean;
+      includeDeleted?: boolean;
+      limit?: number;
+      page?: Amity.Token;
+      dataTypes?: {
+        values: ('image' | 'text')[];
+        // matchType is a query format that you can set to any to query any type of comment
+        // or exact to get a comment with exactly type that defined in dataTypes
+        matchType: 'any' | 'exact';
+      };
+    };
+
+    type CommentLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryComments, 'sortBy' | 'page'> & {
+        sortBy?: 'lastCreated' | 'firstCreated';
+      }
+    >;
+
+    type CommentLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalComment['commentId'],
+      { page?: Amity.Token | undefined; limit?: number }
+    >;
+  }
+}

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

@@ -0,0 +1,294 @@
+import { AmityCommunityMemberStatusFilter } from '~/communityRepository/constants';
+
+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 {
+    const enum CommunitySortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      DisplayName = 'displayName',
+    }
+
+    type CommunitySortBy = `${Amity.CommunitySortByEnum}`;
+
+    const enum SearchCommunitySortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      DisplayName = 'displayName',
+    }
+
+    type SearchCommunitySortBy = `${Amity.SearchCommunitySortByEnum}`;
+
+    const enum CommunityMemberSortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+    }
+
+    type CommunityMemberSortBy = `${Amity.CommunityMemberSortByEnum}`;
+
+    const enum SearchCommunityMemberSortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      DisplayName = 'displayName',
+    }
+
+    type SearchCommunityMemberSortBy = `${Amity.SearchCommunityMemberSortByEnum}`;
+
+    type CommunityActionType =
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onJoin'
+      | 'onLeft'
+      | 'onMemberCountChanged';
+
+    type CommunityMemberActionType =
+      | 'onJoin'
+      | 'onLeft'
+      | 'onBan'
+      | 'onUnban'
+      | 'onMemberCountChanged';
+
+    type RawCommunity = {
+      communityId: string;
+
+      displayName: string;
+      avatarFileId?: File<'image'>['fileId'];
+      description?: string;
+
+      channelId: Amity.Channel['channelId'];
+      userId: Amity.InternalUser['userId'];
+
+      isOfficial?: boolean;
+      isPublic?: boolean;
+      isJoined?: boolean;
+      onlyAdminCanPost?: boolean;
+      needApprovalOnPostCreation?: boolean;
+
+      postsCount: number;
+      membersCount: number;
+
+      categoryIds: Amity.InternalCategory['categoryId'][];
+
+      hasFlaggedComment: boolean;
+      hasFlaggedPost: boolean;
+
+      allowCommentInStory?: boolean;
+
+      isDiscoverable?: boolean;
+      requiresJoinApproval?: boolean;
+    } & Amity.Taggable &
+      Amity.Metadata &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable;
+
+    type InternalCommunity = Omit<
+      Amity.RawCommunity,
+      'onlyAdminCanPost' | 'needApprovalOnPostCreation'
+    > &
+      Amity.CommunityStorySettings & {
+        postSetting?: ValueOf<typeof CommunityPostSettings>;
+      };
+
+    type Community = Amity.InternalCommunity & Amity.CommunityLinkedObject;
+
+    type QueryCommunities = {
+      membership?: 'all' | 'member' | 'notMember';
+      categoryId?: Amity.InternalCategory['categoryId'];
+      includeDeleted?: boolean;
+      tags?: Amity.Taggable['tags'];
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
+      page?: string;
+      limit?: number;
+      includeDiscoverablePrivateCommunity?: boolean;
+    };
+
+    type QueryJoinCommunity = {
+      communityId: string;
+      status: Amity.JoinRequestStatus;
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
+    };
+
+    type SearchQueryCommunities = {
+      displayName?: string;
+      membership?: 'all' | 'member' | 'notMember';
+      categoryId?: Amity.InternalCategory['categoryId'];
+      includeDeleted?: boolean;
+      tags?: Amity.Taggable['tags'];
+      sortBy?: Amity.SearchCommunitySortBy | Amity.SearchCommunitySortByEnum;
+      page?: string;
+      limit?: number;
+      includeDiscoverablePrivateCommunity?: boolean;
+    };
+
+    type QueryJoinRequest = {
+      communityId: string;
+      status: Amity.JoinRequestStatus;
+      targetType: 'community';
+      type: Amity.JoinRequestType;
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
+      page?: string;
+    };
+
+    type QueryJoinRequestList = {
+      communityIds: string[];
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
+      page?: string;
+    };
+
+    type CommunityLiveCollection = Amity.LiveCollectionParams<Omit<QueryCommunities, 'page'>>;
+
+    type RecommendedCommunityLiveCollection = Amity.LiveCollectionParams<{
+      limit?: number;
+      includeDiscoverablePrivateCommunity?: boolean;
+    }>;
+    type TrendingCommunityLiveCollection = Amity.LiveCollectionParams<{
+      limit?: number;
+      includeDiscoverablePrivateCommunity?: boolean;
+    }>;
+
+    type JoinRequestLiveCollection = Amity.LiveCollectionParams<QueryJoinRequest>;
+
+    type JoinRequestListLiveCollection = Amity.LiveCollectionParams<QueryJoinRequestList>;
+
+    type SearchCommunityLiveCollection = Amity.LiveCollectionParams<
+      Omit<SearchQueryCommunities, 'page'>
+    >;
+
+    type CommunityLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Community['communityId'],
+      Pick<QueryCommunities, 'page'>
+    >;
+
+    type RecommendedCommunityLiveCollectionCache = Amity.CommunityLiveCollectionCache;
+    type TrendingCommunityLiveCollectionCache = Amity.CommunityLiveCollectionCache;
+
+    type SearchCommunityLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Community['communityId'],
+      Pick<SearchQueryCommunities, 'page'>
+    >;
+
+    type JoinRequestLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.JoinRequest['joinRequestId'],
+      Pick<QueryJoinRequest, 'page'>
+    >;
+
+    type JoinRequestListLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.JoinRequest['joinRequestId'],
+      Pick<QueryJoinRequestList, 'page'>
+    >;
+
+    type QueryCommunityMembers = {
+      communityId: string;
+      memberships?: ('banned' | 'member')[];
+      roles?: string[];
+      sortBy?: Amity.CommunityMemberSortByEnum | Amity.CommunityMemberSortBy;
+      page?: string;
+      limit?: number;
+      includeDeleted?: boolean;
+    };
+
+    type QuerySearchCommunityMembers = {
+      communityId: string;
+      memberships?: ('banned' | 'member')[];
+      roles?: string[];
+      sortBy?: Amity.SearchCommunityMemberSortByEnum | Amity.SearchCommunityMemberSortBy;
+      search?: Amity.InternalUser['displayName'] | Amity.InternalUser['userId'];
+      page?: string;
+      limit?: number;
+      includeDeleted?: boolean;
+    };
+
+    type CommunityMemberLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryCommunityMembers, 'page'>
+    >;
+
+    type SearchCommunityMemberLiveCollection = Amity.LiveCollectionParams<
+      Omit<QuerySearchCommunityMembers, 'page'>
+    >;
+
+    type CommunityMemberLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Membership<'community'>['userId'],
+      Pick<QueryCommunityMembers, 'page'>
+    >;
+
+    type SearchCommunityMemberLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Community['communityId'],
+      Pick<QuerySearchCommunityMembers, 'page'>
+    >;
+
+    type QuerySemanticSearchCommunity = {
+      query: string;
+      categoryIds?: string[];
+      filter?: AmityCommunityMemberStatusFilter;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
+      tags?: string[];
+      includeDiscoverablePrivateCommunity?: boolean;
+    };
+
+    type SemanticSearchCommunityLiveCollection = Amity.LiveCollectionParams<
+      Omit<QuerySemanticSearchCommunity, 'page' | 'filter' | 'options'>
+    > & {
+      communityMembershipStatus?: AmityCommunityMemberStatusFilter;
+    };
+
+    type SemanticSearchCommunityLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Community['communityId'], // communityId:score
+      QuerySemanticSearchCommunity
+    >;
+
+    type CommunityLinkedObject = {
+      categories: Amity.Category[];
+      createInvitations: (userIds: string[]) => Promise<void>;
+      getMemberInvitations: (
+        params: Pick<Amity.InvitationLiveCollection, 'limit' | 'sortBy' | 'statuses'>,
+        callback: Amity.LiveCollectionCallback<Amity.Invitation>,
+      ) => Amity.Unsubscriber;
+      getInvitation: () => Promise<Amity.Invitation | undefined>;
+      join: () => Promise<Amity.JoinResult>;
+      getJoinRequests: (
+        params: QueryJoinRequest,
+        callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,
+      ) => Amity.Unsubscriber;
+      getMyJoinRequest: () => Promise<Amity.JoinRequest | undefined>;
+    };
+  }
+}

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

@@ -0,0 +1,130 @@
+export const ContentFeedType = Object.freeze({
+  STORY: 'story',
+  CLIP: 'clip',
+  CHAT: 'chat',
+  POST: 'post',
+  MESSAGE: 'message',
+});
+
+export enum ContentFlagReasonEnum {
+  CommunityGuidelines = 'Against community guidelines',
+  HarassmentOrBullying = 'Harassment or bullying',
+  SelfHarmOrSuicide = 'Self-harm or suicide',
+  ViolenceOrThreateningContent = 'Violence or threatening content',
+  SellingRestrictedItems = 'Selling and promoting restricted items',
+  SexualContentOrNudity = 'Sexual message or nudity',
+  SpamOrScams = 'Spam or scams',
+  FalseInformation = 'False information or misinformation',
+  Others = 'Others',
+}
+
+declare global {
+  namespace Amity {
+    type ContentFlagReason =
+      | Exclude<`${ContentFlagReasonEnum}`, `${ContentFlagReasonEnum.Others}`>
+      | (string & {});
+
+    type ContentType =
+      | 'text'
+      | 'image'
+      | 'file'
+      | 'video'
+      | 'poll'
+      | 'json'
+      | 'liveStream'
+      | 'clip'
+      | string;
+
+    type ContentFeedType = ValueOf<typeof ContentFeedType>;
+
+    type ContentDataText = {
+      title?: string | null;
+      text: string;
+    };
+
+    type ContentDataFile = {
+      fileId: Amity.File<'file'>['fileId'];
+    };
+
+    type ContentDataImage = {
+      fileId: Amity.File<'image'>['fileId'];
+      caption?: string;
+    };
+
+    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 ContentDataClip = {
+      thumbnailFileId: Amity.File<'image'>['fileId'];
+      fileId: Amity.File<'clip'>['fileId'];
+      isMuted?: boolean;
+      displayMode?: Amity.ClipDisplayMode;
+    };
+
+    type ContentDataPoll = {
+      pollId: Amity.Poll['pollId'];
+    };
+
+    type ContentDataStream = {
+      streamId: Amity.Stream['streamId'];
+    };
+
+    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 'liveStream'
+      ? ContentDataStream
+      : T extends 'clip'
+      ? ContentDataClip
+      : 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;
+  }
+}