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

package/src/@types/core/live.ts

@@ -0,0 +1,34 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type LiveObject<T extends any> = {
+      data: T;
+      error?: any;
+      loading: boolean;
+      origin?: 'local' | 'server' | 'event';
+    };
+
+    type LiveObjectCallback<T extends any> = Amity.Listener<LiveObject<T>>;
+
+    type LiveCollection<T extends any> = LiveObject<T[]> & {
+      onNextPage: () => void;
+      hasNextPage: boolean;
+    };
+
+    type LiveCollectionCallback<T extends any> = Amity.Listener<LiveCollection<T>>;
+
+    type LiveCollectionConfig = {
+      policy?: Exclude<Amity.QueryPolicy, 'no_fetch'>;
+    };
+
+    type LiveCollectionParams<T extends any> = T & {
+      limit?: number;
+    };
+
+    type LiveCollectionCache<T extends any, U extends any> = Pick<
+      LiveCollection<T>,
+      'data' | 'error' | 'loading'
+    > & { params: U };
+  }
+}

package/src/@types/core/model.ts

@@ -6,12 +6,13 @@ declare global {
      * type map of "domain name -> ASC model"
      * @hidden
      */
-    type Model = {
+    type Models = {
       user: Amity.User;
       file: Amity.File;
       role: Amity.Role;
 
       channel: Amity.Channel;
+      subChannel: Amity.SubChannel;
       channelUsers: Amity.Membership<'channel'>;
       message: Amity.Message;
 
@@ -21,14 +22,19 @@ declare global {
       post: Amity.Post;
       comment: Amity.Comment;
       poll: Amity.Poll;
+      reaction: Amity.Reaction;
 
       stream: Amity.Stream;
 
       follow: Amity.FollowStatus;
+      followInfo: Amity.FollowInfo;
       followCount: Amity.FollowCount;
+
+      feed: Amity.Feed;
     };
 
-    type Domain = keyof Model;
+    type Model = ValueOf<Models>;
+    type Domain = keyof Models;
 
     /**
      * Definition of the minimal set of properties necessary to identify
@@ -41,6 +47,7 @@ declare global {
       role: Pick<Amity.Role, 'roleId'>;
 
       channel: Pick<Amity.Channel, 'channelId'>;
+      subChannel: Pick<Amity.SubChannel, 'subChannelId'>;
       channelUsers: Pick<Amity.Membership<'channel'>, 'channelId' | 'userId'>;
       message: Pick<Amity.Message, 'messageId'>;
 
@@ -50,11 +57,15 @@ declare global {
       post: Pick<Amity.Post, 'postId'>;
       comment: Pick<Amity.Comment, 'commentId'>;
       poll: Pick<Amity.Poll, 'pollId'>;
+      reaction: Pick<Amity.Reaction, 'reactionId'>;
 
       stream: Pick<Amity.Stream, 'streamId'>;
 
       follow: Pick<Amity.FollowStatus, 'from' | 'to'>;
-      followCount: Pick<Amity.FollowCount, 'userId'>;
+      followInfo: Pick<Amity.FollowInfo, 'userId' | 'status'>;
+      followCount: Pick<Amity.FollowInfo, 'userId' | 'followerCount'>;
+
+      feed: Pick<Amity.Feed, 'targetId' | 'feedId'>;
     };
   }
 }

package/src/@types/core/paging.ts

@@ -18,7 +18,7 @@ declare global {
       before?: never;
     };
 
-    type Page = PrevPage<number> | NextPage<number>;
+    type Page<T extends number | string = number> = PrevPage<T> | NextPage<T>;
 
     /*
       updatedAt is here because if you need sort by updatedAt you

package/src/@types/core/payload.ts

@@ -7,6 +7,7 @@ declare global {
       file: Amity.FilePayload;
       role: Amity.RolePayload;
       channel: Amity.ChannelPayload;
+      subChannel: Amity.SubChannelPayload;
       channelUser: Amity.ChannelMembershipPayload;
       message: Amity.MessagePayload;
       community: Amity.CommunityPayload;
@@ -16,6 +17,7 @@ declare global {
       comment: Amity.CommentPayload;
       poll: Amity.PollPayload;
       stream: Amity.StreamPayload;
+      reaction: Amity.ReactionPayload;
     };
 
     type UserPayload = {
@@ -23,6 +25,13 @@ declare global {
       files: Amity.File<'image'>[];
     };
 
+    type FeedSettingPayload = {
+      feedSettings: {
+        contentSettings: Amity.ContentSetting[];
+        feedType: Amity.ContentFeedType;
+      }[];
+    };
+
     // API-FIX: backend should return a payload like { files: Amity.File<T>[] }
     type CreateFilePayload<T extends Amity.FileType = any> = Amity.File<T>[];
     type FilePayload<T extends Amity.FileType = any> = Amity.File<T>;
@@ -32,38 +41,93 @@ declare global {
     };
 
     type ChannelPayload<T extends Amity.ChannelType = any> = {
+      channels: Amity.RawChannel<T>[];
+      channelUsers: Amity.RawMembership<'channel'>[];
+    } & Amity.UserPayload;
+
+    /**
+     * Items that extend from `Amity.Channel`
+     * - channels: `Amity.RawChannel` -> `Amity.Channel` (Added Marker Service related props)
+     * - channelUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedChannelPayload<T extends Amity.ChannelType = any> = Omit<
+      ChannelPayload,
+      'channels' | 'channelUsers'
+    > & {
       channels: Amity.Channel<T>[];
-      channelUsers?: Amity.Membership<'channel'>[];
-      users?: Amity.User[];
-      files?: Amity.File[];
+      channelUsers: Amity.Membership<'channel'>[];
+    };
+
+    type SubChannelPayload = {
+      messageFeeds: Amity.RawSubChannel[];
+    };
+
+    /**
+     * Items that extend from `Amity.SubChannelPayload`
+     * - messageFeeds: `Amity.RawSubChannel` -> `Amity.SubChannel` (Model Restructuring)
+     */
+    type ProcessedSubChannelPayload = {
+      messageFeeds: Amity.SubChannel[];
     };
 
     type ChannelMembershipPayload = {
-      channels?: Amity.Channel[];
+      channels: Amity.RawChannel[];
+      channelUsers: Amity.RawMembership<'channel'>[];
+    } & Amity.UserPayload;
+
+    /**
+     * Items that extend from `Amity.ChannelMembershipPayload`
+     * - channels: `Amity.RawChannel` -> `Amity.Channel` (Added Marker Service related props)
+     * - channelUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedChannelMembershipPayload = Omit<
+      ChannelMembershipPayload,
+      'channels' | 'channelUsers'
+    > & {
+      channels: Amity.Channel[];
       channelUsers: Amity.Membership<'channel'>[];
-      users?: Amity.User[];
-      files?: Amity.File[];
     };
 
-    type MessagePayload<T extends Amity.MessageContentType = any> = {
+    /**
+     * Items that extend from `Amity.MessagePayload`
+     * - messages: `Amity.RawMessage` -> `Amity.Message` (Model Restructuring)
+     */
+    type ProcessedMessagePayload<T extends Amity.MessageContentType = any> = {
       messages: Amity.Message<T>[];
-      users?: Amity.User[];
-      files?: Amity.File[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    type MessagePayload<T extends Amity.MessageContentType = any> = Omit<
+      ProcessedMessagePayload<T>,
+      'messages'
+    > & {
+      messages: Amity.RawMessage<T>[];
     };
 
     type StreamPayload = {
       videoStreamings: Amity.Stream[];
-      users?: Amity.User[];
-      files?: Amity.File<'image'>[];
+      users: Amity.User[];
+      files: Amity.File<'image'>[];
     };
 
     type CommunityPayload = {
+      communities: Amity.RawCommunity[];
+      communityUsers: Amity.RawMembership<'community'>[];
+      categories: Amity.Category[];
+      feeds: Amity.Feed[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    /**
+     * Items that extend from `Amity.CommunityPayload`
+     * - communities: `Amity.RawCommunity` -> `Amity.Community` (Added Marker Service related props)
+     * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedCommunityPayload = Omit<CommunityPayload, 'communities' | 'communityUsers'> & {
       communities: Amity.Community[];
-      communityUsers?: Amity.Membership<'community'>[];
-      categories?: Amity.Category[];
-      feeds?: Amity.Feed[];
-      users?: Amity.User[];
-      files?: Amity.File[];
+      communityUsers: Amity.Membership<'community'>[];
     };
 
     type CategoryPayload = {
@@ -72,31 +136,54 @@ declare global {
     };
 
     type CommunityMembershipPayload = {
+      communities: Amity.RawCommunity[];
+      communityUsers: Amity.RawMembership<'community'>[];
+      categories: Amity.Category[];
+      feeds: Amity.Feed[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    /**
+     * Items that extend from `Amity.CommunityMembershipPayload`
+     * - communities: `Amity.RawCommunity` -> `Amity.Community` (Added Marker Service related props)
+     * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedCommunityMembershipPayload = Omit<
+      CommunityMembershipPayload,
+      'communities' | 'communityUsers'
+    > & {
       communities: Amity.Community[];
       communityUsers: Amity.Membership<'community'>[];
-      categories?: Amity.Category[];
-      feeds?: Amity.Feed[];
-      users: Amity.User[];
-      files?: Amity.File[];
     };
 
     type PostPayload<T extends Amity.PostContentType = any> = {
       posts: Amity.Post<T>[];
-      postChildren?: Amity.Post[];
-      communities?: Amity.Community[];
-      communityUsers?: Amity.Membership<'community'>[];
-      categories?: Amity.Category[];
-      comments?: Amity.Comment[];
-      feeds?: Amity.Feed[];
-      users?: Amity.User[];
-      files?: Amity.File[];
+      postChildren: Amity.Post[];
+      communities: Amity.RawCommunity[];
+      communityUsers: Amity.RawMembership<'community'>[];
+      categories: Amity.Category[];
+      comments: Amity.Comment[];
+      feeds: Amity.Feed[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    /**
+     * Items that extend from `Amity.PostPayload`
+     * - communities: `Amity.RawCommunity` -> `Amity.Community` (Added Marker Service related props)
+     * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedPostPayload = Omit<PostPayload, 'communities' | 'communityUsers'> & {
+      communities: Amity.Community[];
+      communityUsers: Amity.Membership<'community'>[];
     };
 
     type CommentPayload<T extends Amity.CommentContentType = any> = {
       comments: Amity.Comment<T>[];
-      commentChildren?: Amity.Comment[];
-      users?: Amity.User[];
-      files?: Amity.File[];
+      commentChildren: Amity.Comment[];
+      users: Amity.User[];
+      files: Amity.File[];
     };
 
     type PollPayload = {
@@ -104,19 +191,23 @@ declare global {
       polls: Amity.Poll[];
     };
 
-    type GlobalFeedPayload = Amity.PostPayload;
+    type ReactionPayload = {
+      reactions: Amity.ReactionQuery[];
+      users: Amity.User[];
+    };
 
-    type FollowersPayload = {
-      follows: Amity.FollowStatus[];
-    } & UserPayload;
+    type GlobalFeedPayload = Amity.PostPayload;
 
     type FollowStatusPayload = {
       follows: Amity.FollowStatus[];
     };
 
-    type FollowInfoPayload = {
-      follows: Amity.FollowStatus[];
+    type FollowInfoMePayload = {
       followCounts: Amity.FollowCount[];
     };
+
+    type FollowersPayload = Amity.FollowStatusPayload & UserPayload;
+
+    type FollowInfoPayload = FollowInfoMePayload & Amity.FollowStatusPayload;
   }
 }

package/src/@types/core/query.ts

@@ -33,7 +33,7 @@ declare global {
       args: Args;
     };
 
-    type QueryPolicy = 'server_only' | 'cache_only' | 'cache_then_server' | 'no_fetch';
+    type QueryPolicy = 'cache_only' | 'cache_then_server' | 'no_fetch';
 
     type QueryOptions = {
       lifeSpan: number;

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

@@ -9,5 +9,18 @@ declare global {
     } & Amity.Metadata &
       Amity.Timestamps &
       Amity.SoftDelete;
+
+    type QueryCategories = {
+      includeDeleted?: boolean;
+      sortBy?: 'name' | 'firstCreated' | 'lastCreated';
+      page?: Amity.Page;
+    };
+
+    type CategoryLiveCollection = Amity.LiveCollectionParams<Omit<QueryCategories, 'page'>>;
+
+    type CategoryLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Category['categoryId'],
+      Pick<QueryCategories, 'page'>
+    >;
   }
 }

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

@@ -2,13 +2,33 @@ export {};
 
 declare global {
   namespace Amity {
-    type ChannelType = 'standard' | 'live' | 'conversation' | 'broadcast';
+    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 Channel<T extends ChannelType = any> = {
       channelId: string;
+      defaultSubChannelId: string;
       displayName?: string;
-      avatarFileId?: File<'image'>['fileId'];
-      description?: string;
+      avatarFileId?: Amity.File<'image'>['fileId'];
       type: T;
 
       isDistinct?: boolean;
@@ -25,12 +45,66 @@ declare global {
       autoDeleteMessageByFlagLimit?: number;
 
       memberCount?: number;
-      messageCount?: number;
+      messageCount: number; // TODO remove from public interface
+      moderatorMemberCount?: number;
+
+      lastActivity: Amity.timestamp;
 
-      lastActivity?: Amity.timestamp;
+      defaultSubChannelUnreadCount: number;
+      defaultSubChannelHasUnreadMention: boolean;
+      localReadToSegment: number;
+      localLastMentionSegment: number;
     } & Amity.Metadata &
       Amity.Taggable &
       Amity.Timestamps &
-      Amity.SoftDelete;
+      Amity.SoftDelete &
+      Amity.Subscribable;
+
+    type RawChannel<T extends ChannelType = any> = Omit<
+      Channel<T>,
+      | 'defaultSubChannelId'
+      | 'defaultSubChannelUnreadCount'
+      | 'defaultSubChannelHasUnreadMention'
+      | 'localReadToSegment'
+      | 'localLastMentionSegment'
+    > & {
+      _id: string;
+    };
+
+    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

@@ -5,6 +5,27 @@ declare global {
   namespace Amity {
     type Logger = (topic: string, ...args: any[]) => void;
 
+    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;
 
@@ -14,27 +35,88 @@ declare global {
       ws: SocketIOClient.Socket;
       emitter: Emitter<Amity.Events>;
 
+      sessionState: Amity.SessionStates;
+      sessionHandler?: Amity.SessionHandler;
+
       cache?: Amity.Cache;
 
       apiKey?: string;
       userId?: string;
-      accessToken?: 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;
       deviceInfo: {
-        version: string;
         kind: 'node' | 'web';
         model?: string;
+        sdkVersion: string;
       };
     };
 
     type Tokens = {
       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;
     };
   }
 }

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

@@ -5,6 +5,16 @@ declare global {
     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;
@@ -14,6 +24,7 @@ declare global {
       children: Comment['commentId'][];
       segmentNumber: number;
       editedAt: Amity.timestamp;
+      attachments?: Amity.Attachment[];
     } & Amity.Relationship<CommentReferenceType> &
       Amity.Content<T> &
       Amity.Metadata &
@@ -23,5 +34,32 @@ declare global {
       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'>
+    >;
   }
 }