@amityco/ts-sdk 0.0.1 → 6.0.0

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

@@ -1,38 +1,99 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type ChannelType = 'standard' | 'live' | 'conversation' | 'broadcast'
-
-    type Channel<T extends ChannelType = any> = {
-      channelId: string
-      displayName?: string
-      avatarFileId?: File<'image'>['fileId'],
-      description?: string,
-      type: T
-
-      isDistinct?: boolean
-
-      isMuted?: boolean
-      muteTimeout?: string
-
-      isRateLimited?: boolean
-      rateLimit?: number
-      rateLimitWindow?: number
-      rateLimitTimeout?: number
-
-      messageAutoDeleteEnabled?: boolean
-      autoDeleteMessageByFlagLimit?: number
-
-      memberCount?: number
-      messageCount?: number
-
-      lastActivity?: timestamp
-    }
-    & Amity.Metadata
-    & Amity.Taggable
-    & Amity.Timestamps
-    & Amity.SoftDelete
-    & Amity.Syncable
+    type ChannelType = 'broadcast' | 'conversation' | 'community' | 'live';
+
+    type ChannelMemberActionType =
+      | 'onJoin'
+      | 'onLeft'
+      | 'onMemberRead'
+      | 'onMemberAdded'
+      | 'onMemberRemoved'
+      | 'onChannelMemberBanned'
+      | 'onChannelMemberUnbanned';
+
+    type ChannelActionType =
+      | 'onFetch'
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onJoin'
+      | 'onLeft'
+      | 'onMute'
+      | 'onMemberAdded'
+      | 'onMemberRemoved';
+
+    type RawChannel<T extends ChannelType = any> = {
+      _id: string;
+      channelId: string;
+      displayName?: string;
+      avatarFileId?: Amity.File<'image'>['fileId'];
+      type: T;
+
+      isDistinct?: boolean;
+
+      isMuted?: boolean;
+      muteTimeout?: string;
+
+      isRateLimited?: boolean;
+      rateLimit?: number;
+      rateLimitWindow?: number;
+      rateLimitTimeout?: number;
+
+      messageAutoDeleteEnabled?: boolean;
+      autoDeleteMessageByFlagLimit?: number;
+
+      memberCount?: number;
+      messageCount: number; // TODO remove from public interface
+      moderatorMemberCount?: number;
+
+      lastActivity: Amity.timestamp;
+    } & Amity.Metadata &
+      Amity.Taggable &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable;
+
+    type Channel<T extends ChannelType = any> = RawChannel<T> & {
+      isUnreadCountSupport: boolean;
+      unreadCount: number;
+    };
+
+    type QueryChannels = {
+      displayName?: string;
+      membership?: 'all' | 'member' | 'notMember';
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated' | 'lastActivity';
+      types?: Amity.ChannelType[];
+      isDeleted?: Amity.Channel['isDeleted'];
+      tags?: Amity.Taggable['tags'];
+      excludeTags?: Amity.Taggable['tags'];
+      page?: Amity.Page;
+    };
+
+    type ChannelLiveCollection = Amity.LiveCollectionParams<Omit<QueryChannels, 'page'>>;
+
+    type ChannelLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Channel['channelId'],
+      Pick<QueryChannels, 'page'>
+    >;
+
+    type QueryChannelMembers = {
+      channelId: Amity.Channel['channelId'];
+      memberships?: Array<Exclude<Amity.Membership<'channel'>['membership'], 'none'> | 'muted'>;
+      roles?: string[];
+      sortBy?: 'firstCreated' | 'lastCreated';
+      search?: string;
+      page?: Amity.Page;
+    };
+
+    type ChannelMembersLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryChannelMembers, 'page'>
+    >;
+
+    type ChannelMembersLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Membership<'channel'>['userId'],
+      Pick<QueryChannelMembers, 'page'>
+    >;
   }
 }

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

@@ -1,36 +1,124 @@
-import { AxiosInstance } from 'axios'
-import { Emitter } from 'mitt'
+import { AxiosInstance } from 'axios';
+import { Emitter } from 'mitt';
 
 declare global {
   namespace Amity {
-    type Logger = (topic: string, ...args: any[]) => void
+    type Logger = (topic: string, ...args: any[]) => void;
 
-    type Client = {
-      log: Logger
-      http: AxiosInstance
-      ws: SocketIOClient.Socket
-      emitter: Emitter<Amity.Events>
+    const enum SessionStates {
+      NOT_LOGGED_IN = 'notLoggedIn',
 
-      cache?: Amity.Cache
+      ESTABLISHING = 'establishing',
+      ESTABLISHED = 'established',
 
-      apiKey?: string
-      userId?: string
+      TOKEN_EXPIRED = 'tokenExpired',
 
-      use: () => void
+      /*
+       * 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;
+      mqtt: Amity.MqttClient;
+      ws: SocketIOClient.Socket;
+      emitter: Emitter<Amity.Events>;
+
+      sessionState: Amity.SessionStates;
+      sessionHandler?: Amity.SessionHandler;
+
+      cache?: Amity.Cache;
+
+      apiKey?: string;
+      userId?: string;
+
+      token?: Omit<Amity.Tokens, 'refreshToken'>;
+
+      use: () => void;
+
+      accessTokenExpiryWatcher: (
+        expiresAt: Amity.Tokens['expiresAt'],
+        issuedAt: Amity.Tokens['issuedAt'],
+        sessionHandler: Amity.SessionHandler,
+      ) => Amity.Unsubscriber;
+
+      getFeedSettings: () => Promise<Amity.FeedSettings>;
+    };
+
     type Device = {
-      deviceId: string
+      deviceId: string;
       deviceInfo: {
-        version: string
-        kind: 'node' | 'web'
-        model?: string
-      }
-    }
+        kind: 'node' | 'web';
+        model?: string;
+        sdkVersion: string;
+      };
+    };
 
     type Tokens = {
-      accessToken: string
-      refreshToken: string
+      accessToken: string;
+      refreshToken: string;
+      // issuedAt, expiresAt is in iso Date format
+      issuedAt: string;
+      expiresAt: string;
+    };
+
+    type AccessTokenRenewal = {
+      renew: () => void;
+      renewWithAuthToken: (authToken: string) => void;
+      unableToRetrieveAuthToken: () => void;
+    };
+
+    interface SessionHandler {
+      sessionWillRenewAccessToken(renewal: AccessTokenRenewal): void;
     }
+
+    type ChatSettings = {
+      enabled: boolean;
+      mention: {
+        isAllowMentionedChannelEnabled: boolean;
+      };
+    };
+
+    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;
+      };
+      userPrivacySetting: 'public' | 'private ';
+    };
+
+    type ConnectClientParams = {
+      userId: Amity.User['userId'];
+      displayName?: Amity.User['displayName'];
+      authToken?: string;
+      deviceId?: Amity.Device['deviceId'];
+    };
+
+    type ConnectClientConfig = {
+      disableRTE: boolean;
+    };
+
+    type ActiveUser = Pick<Amity.User, '_id' | 'userId' | 'path' | 'displayName'>;
   }
 }

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

@@ -1,26 +1,65 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type CommentContentType = ('text')
-    type CommentReferenceType = ('content' | 'post')
+    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
-      parentId?: Comment['commentId']
-      rootId: Comment['commentId']
-      childrenNumber: number
-      children: Comment['commentId'][]
-      segmentNumber: number
-    }
-    & Amity.Relationship<CommentReferenceType>
-    & Amity.Content<T>
-    & Amity.Metadata
-    & Amity.Flaggable
-    & Amity.Reactable
-    & Amity.Timestamps
-    & Amity.SoftDelete
-    & Amity.Syncable
+      commentId: string;
+      userId: string;
+      parentId?: Comment['commentId'];
+      rootId: Comment['commentId'];
+      childrenNumber: number;
+      children: Comment['commentId'][];
+      segmentNumber: number;
+      editedAt: Amity.timestamp;
+      attachments?: Amity.Attachment[];
+    } & Amity.Relationship<CommentReferenceType> &
+      Amity.Content<T> &
+      Amity.Metadata &
+      Amity.Flaggable &
+      Amity.Reactable &
+      Amity.Timestamps &
+      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;
+      includeDeleted?: boolean;
+      page?: Amity.Page;
+      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.Comment['commentId'],
+      Pick<QueryComments, 'page'>
+    >;
   }
 }

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

@@ -1,35 +1,109 @@
-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 = {
-      communityId: string
-
-      displayName: string
-      avatarFileId?: File<'image'>['fileId']
-      description?: string
-
-      channelId: Amity.Channel['channelId']
-      userId: Amity.User['userId']
-
-      isOfficial?: boolean
-      isPublic?: boolean
-      isJoined?: boolean
-      onlyAdminCanPost?: boolean
-      needApprovalOnPostCreation?: boolean
-
-      postsCount: number
-      membersCount: number
-
-      categoryIds: Amity.Category['categoryId'][]
-
-      hasFlaggedComment: boolean
-      hasFlaggedPost: boolean
-    }
-    & Amity.Taggable
-    & Amity.Metadata
-    & Amity.Timestamps
-    & Amity.SoftDelete
-    & Amity.Syncable
+    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.User['userId'];
+
+      isOfficial?: boolean;
+      isPublic?: boolean;
+      isJoined?: boolean;
+      onlyAdminCanPost?: boolean;
+      needApprovalOnPostCreation?: boolean;
+
+      postsCount: number;
+      membersCount: number;
+
+      categoryIds: Amity.Category['categoryId'][];
+
+      hasFlaggedComment: boolean;
+      hasFlaggedPost: boolean;
+    } & Amity.Taggable &
+      Amity.Metadata &
+      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,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;
   }
 }