@amityco/ts-sdk 0.0.1-beta.3 → 0.0.1-beta.30

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

@@ -1,95 +1,63 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type Syncable = {
-      localId: string
-      syncedAt: number
-    }
+    type Cachable = {
+      cachedAt: number;
+    };
 
     type Local = {
-      localId: string
-      syncedAt: -1
-    }
+      cachedAt: -1;
+    };
 
     type AsyncFunc<Args extends any[], Returned extends any> = {
-      (...args: Args): Promise<Returned>
-    }
+      (...args: Args): Promise<Returned>;
+    };
 
     type FetcherFunc<Args extends any[], Returned extends any> = {
-      (...args: Args): Promise<Returned>
-      locally: (...args: Args) => Returned
-    }
+      (...args: Args): Promise<Returned>;
+      locally: (...args: Args) => Returned | undefined;
+    };
 
     type MutatorFunc<Args extends any[], Returned extends any> = {
-      (...args: Args): Promise<Returned>
-      optimistically: (...args: Args) => Returned
-    }
+      (...args: Args): Promise<Returned>;
+      optimistically: (...args: Args) => Returned | undefined;
+    };
 
-    type OfflineFunc<Args extends any[], Returned extends any> = (
-      FetcherFunc<Args, Returned> | MutatorFunc<Args, Returned>
-    )
+    type OfflineFunc<Args extends any[], Returned extends any> =
+      | FetcherFunc<Args, Returned>
+      | MutatorFunc<Args, Returned>;
 
     type Query<Args extends any[], Returned extends any> = {
-      func: AsyncFunc<Args, Returned> | OfflineFunc<Args, Returned>
-      args: Args
-    }
+      func: AsyncFunc<Args, Returned> | OfflineFunc<Args, Returned>;
+      args: Args;
+    };
 
-    type QueryPolicy = 'server_only' | 'cache_only' | 'cache_then_server' | 'no_fetch'
+    type QueryPolicy = 'server_only' | 'cache_only' | 'cache_then_server' | 'no_fetch';
 
     type QueryOptions = {
-      lifeSpan: number
-    }
-
-    type QueryMetadata = {
-      origin?: 'local' | 'server',
-      loading?: boolean,
-      error?: Error,
-    }
-
-    type QueryResult<T> = T extends Amity.Paged<infer U>
-      ? { data?: U } & Amity.Pages & QueryMetadata
-      : { data?: T } & QueryMetadata
-
-    type SkipLimitPagination = {
-      skip?: number
-      limit?: number
-    }
-
-    /*
-      WARNING:
-      in traditional "before/after" pagination, 'before' and 'after'
-      normally should be strings representing the unique id of the
-      resource. for some reason, our backend uses a number instead,
-      bound to "channelSegment" (for message) and "segmentNumber" (
-      for comments). so we have to cast this as number.
-    */
-    type AfterBeforePagination = {
-      before?: number
-      after?: number
-      first?: number
-      last?: number
-    }
-
-    type PrevPage = {
-      after?: never
-      before?: number
-      limit: number
-    }
-
-    type NextPage = {
-      after?: number
-      before?: never
-      limit: number
-    }
-
-    type Page = (PrevPage | NextPage)
-
-    type Pages = {
-      nextPage: Page | null
-      prevPage: Page | null
-    }
-
-    type Paged<T> = { data: T } & Pages
+      lifeSpan: number;
+    };
+
+    type SnapshotOptions = {
+      origin: 'local' | 'server' | 'event';
+      loading: boolean;
+      error?: any;
+    };
+
+    type Snapshot<T> = (T extends Amity.Cached<infer T2>
+      ? T2 extends Amity.Paged<infer T3, infer T4>
+        ? { data: T3[] | undefined } & Amity.Pages<T4> & {
+              cachedAt?: Amity.CacheOptions['cachedAt'];
+            }
+        : { data: T2 } & { cachedAt?: Amity.CacheOptions['cachedAt'] }
+      : T extends Amity.Paged<infer T3, infer T4>
+      ? { data: T3[] | undefined } & Amity.Pages<T4>
+      : { data: T | undefined }) &
+      SnapshotOptions;
+
+    type RunQueryOptions<T> = T extends Amity.AsyncFunc<infer Args, infer Returned>
+      ? Omit<Amity.Snapshot<Returned>, 'data'>
+      : never;
   }
 }

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

@@ -1,32 +1,55 @@
-export {}
+import { ASCError } from '~/core/errors';
+
+export {};
 
 declare global {
   namespace Amity {
     type SuccessResponse<T> = {
-      status: 'success'
-      data: T
-    }
+      status: 'success';
+      data: T;
+    };
 
     type FailResponse = {
-      status: 'fail'
-      code: Amity.ClientError
-    }
+      status: 'fail';
+      code: Amity.ServerError;
+    };
 
     type ErrorResponse = {
-      status: 'error'
-      message: string
-      code: Amity.ClientError
-    }
+      status: 'error';
+      message: string;
+      code: Amity.ServerError;
+    };
 
-    type Response<T> = (SuccessResponse<T> | FailResponse | ErrorResponse)
+    type Response<T> = SuccessResponse<T> | FailResponse | ErrorResponse;
 
-    type Token = string
+    type Token = string;
 
     type Pagination = {
       paging: {
-        previous?: Token
-        next?: Token
-      }
-    }
+        previous?: Token;
+        next?: Token;
+      };
+    };
+
+    type MqttClient = {
+      connect: (params: { accessToken: string; userId: string }) => Promise<void>;
+      disconnect: () => Promise<void>;
+      get connected(): boolean;
+      on: <T extends keyof Amity.MqttEvents>(
+        event: T,
+        handler: (payload: Amity.MqttEvents[T]) => void,
+      ) => void;
+      once: <T extends keyof Amity.MqttEvents>(
+        event: T,
+        handler: (payload: Amity.MqttEvents[T]) => void,
+      ) => void;
+      off: <T extends keyof Amity.MqttEvents>(
+        event: T,
+        handler?: (payload: Amity.MqttEvents[T]) => void,
+      ) => void;
+      removeAllListeners: () => void;
+      subscribe: (topic: string, callback?: Amity.Listener<ASCError | void>) => Amity.Unsubscriber;
+      unsubscribe: (topic: string) => void;
+    };
   }
 }

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

@@ -1,15 +1,13 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
     type Category = {
-      categoryId: string
-      name: string
-      avatarFileId?: Amity.File<'image'>['fileId']
-    }
-    & Amity.Metadata
-    & Amity.Timestamps
-    & Amity.SoftDelete
-    & Amity.Syncable
+      categoryId: string;
+      name: string;
+      avatarFileId?: Amity.File<'image'>['fileId'];
+    } & Amity.Metadata &
+      Amity.Timestamps &
+      Amity.SoftDelete;
   }
 }

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

@@ -1,38 +1,87 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type ChannelType = 'standard' | 'live' | 'conversation' | 'broadcast'
+    type ChannelType = 'broadcast' | 'conversation' | 'community' | 'live';
+
+    type ChannelActionType =
+      | 'onFetch'
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onJoin'
+      | 'onLeft'
+      | 'onMemberAdded'
+      | 'onMemberRemoved';
 
     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
+      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;
+      moderatorMemberCount?: number;
+
+      lastActivity?: Amity.timestamp;
+
+      unreadCount: number;
+      hasMention: boolean;
+    } & Amity.Metadata &
+      Amity.Taggable &
+      Amity.Timestamps &
+      Amity.SoftDelete;
+
+    type ChannelRaw<T extends ChannelType = any> = Omit<Channel<T>, 'unreadCount' | 'hasMention'>;
+
+    type QueryChannels = {
+      displayName?: string;
+      membership?: 'all' | 'member' | 'notMember';
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      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,57 @@
-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>
+      version: string;
 
-      cache?: Amity.Cache
+      log: Logger;
+      http: AxiosInstance;
+      mqtt: Amity.MqttClient;
+      ws: SocketIOClient.Socket;
+      emitter: Emitter<Amity.Events>;
 
-      apiKey?: string
-      userId?: string
+      cache?: Amity.Cache;
 
-      use: () => void
-    }
+      apiKey?: string;
+      userId?: string;
+      accessToken?: string;
+
+      use: () => void;
+
+      getFeedSettings: () => Promise<Amity.FeedSettings>;
+    };
 
     type Device = {
-      deviceId: string
+      deviceId: string;
       deviceInfo: {
-        version: string
-        kind: 'node' | 'web'
-        model?: string
-      }
-    }
+        version: string;
+        kind: 'node' | 'web';
+        model?: string;
+      };
+    };
 
     type Tokens = {
-      accessToken: string
-      refreshToken: string
-    }
+      accessToken: string;
+      refreshToken: string;
+    };
+
+    type FeedSettings = {
+      [name in Amity.ContentFeedType]?: Amity.ContentSetting[];
+    };
+
+    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

@@ -1,26 +1,58 @@
-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;
+    } & 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;
+      isDeleted?: Amity.Comment['isDeleted'];
+      page?: Amity.Page;
+    };
+
+    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,59 @@
-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 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>;
+    };
   }
 }