@amityco/ts-sdk 0.0.1-beta.14 → 0.0.1-beta.17

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

@@ -1,37 +1,37 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type PaginationStyles = 'skiplimit' | 'afterbefore' | 'afterbeforeraw'
+    type PaginationStyles = 'skiplimit' | 'afterbefore' | 'afterbeforeraw';
 
-    type Paging = {
-      limit: number
-    }
+    type PageLimit = {
+      limit: number;
+    };
 
-    type PrevPage<T extends number | string = number> = Paging & {
-      after?: never
-      before?: T
-    }
+    type PrevPage<T extends number | string> = PageLimit & {
+      after?: never;
+      before?: T;
+    };
 
-    type NextPage<T extends number | string = number> = Paging & {
-      after?: T
-      before?: never
-    }
+    type NextPage<T extends number | string> = PageLimit & {
+      after?: T;
+      before?: never;
+    };
 
-    type Page<T extends number | string = number> = (PrevPage<T> | NextPage<T>)
+    type Page = PrevPage<number> | NextPage<number>;
 
     /*
       updatedAt is here because if you need sort by updatedAt you
       need to include this data in query also
     */
-    type PageRaw = Page<string> & {
-      updatedAt?: string
-    }
+    type PageRaw = (PrevPage<string> | NextPage<string>) & {
+      updatedAt?: string;
+    };
 
     type SkipLimitPagination = {
-      skip?: number
-      limit?: number
-    }
+      skip?: number;
+      limit?: number;
+    };
 
     /*
       WARNING:
@@ -42,19 +42,19 @@ declare global {
       for comments). so we have to cast this as number.
     */
     type AfterBeforePagination = {
-      before?: number
-      after?: number
-      first?: number
-      last?: number
-    }
+      before?: number;
+      after?: number;
+      first?: number;
+      last?: number;
+    };
 
-    type AfterBeforeRawPagination = PageRaw
+    type AfterBeforeRawPagination = PageRaw;
 
-    type Pages = {
-      nextPage?: (Page | PageRaw) | null
-      prevPage?: (Page | PageRaw) | null
-    }
+    type Pages<T extends Page | PageRaw> = {
+      nextPage?: T;
+      prevPage?: T;
+    };
 
-    type Paged<T> = { data: T[] } & Pages
+    type Paged<T, K extends Page | PageRaw = Page> = { data: T[] } & Pages<K>;
   }
 }

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

@@ -1,102 +1,116 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
     type Payloads = {
-      user: Amity.UserPayload
-      file: Amity.FilePayload
-      role: Amity.RolePayload
-      channel: Amity.ChannelPayload
-      channelUser: Amity.ChannelMembershipPayload
-      message: Amity.MessagePayload
-      community: Amity.CommunityPayload
-      communityUser: Amity.CommunityMembershipPayload
-      post: Amity.PostPayload
-      comment: Amity.CommentPayload
-      stream: Amity.StreamPayload
-    }
+      user: Amity.UserPayload;
+      file: Amity.FilePayload;
+      role: Amity.RolePayload;
+      channel: Amity.ChannelPayload;
+      channelUser: Amity.ChannelMembershipPayload;
+      message: Amity.MessagePayload;
+      community: Amity.CommunityPayload;
+      category: Amity.CategoryPayload;
+      communityUser: Amity.CommunityMembershipPayload;
+      post: Amity.PostPayload;
+      comment: Amity.CommentPayload;
+      stream: Amity.StreamPayload;
+    };
 
     type UserPayload = {
-      users: Amity.User[]
-      files: Amity.File<'image'>[]
-    }
+      users: Amity.User[];
+      files: Amity.File<'image'>[];
+    };
 
     // 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>
+    type CreateFilePayload<T extends Amity.FileType = any> = Amity.File<T>[];
+    type FilePayload<T extends Amity.FileType = any> = Amity.File<T>;
 
     type RolePayload = {
-      roles: Amity.Role[]
-    }
+      roles: Amity.Role[];
+    };
 
     type ChannelPayload<T extends Amity.ChannelType = any> = {
-      channels: Amity.Channel<T>[]
-      channelUsers?: Amity.Membership<'channel'>[]
-      users?: Amity.User[]
-      files?: Amity.File[]
-    }
+      channels: Amity.Channel<T>[];
+      channelUsers?: Amity.Membership<'channel'>[];
+      users?: Amity.User[];
+      files?: Amity.File[];
+    };
 
     type ChannelMembershipPayload = {
-      channels?: Amity.Channel[]
-      channelUsers: Amity.Membership<'channel'>[]
-      users?: Amity.User[]
-      files?: Amity.File[]
-    }
+      channels?: Amity.Channel[];
+      channelUsers: Amity.Membership<'channel'>[];
+      users?: Amity.User[];
+      files?: Amity.File[];
+    };
 
     type MessagePayload<T extends Amity.MessageContentType = any> = {
-      messages: Amity.Message<T>[]
-      users?: Amity.User[]
-      files?: Amity.File[]
-    }
+      messages: Amity.Message<T>[];
+      users?: Amity.User[];
+      files?: Amity.File[];
+    };
 
     type StreamPayload = {
-      videoStreamings: Amity.Stream[]
-      users?: Amity.User[]
-      files?: Amity.File<'image'>[]
-    }
+      videoStreamings: Amity.Stream[];
+      users?: Amity.User[];
+      files?: Amity.File<'image'>[];
+    };
 
     type CommunityPayload = {
-      communities: Amity.Community[]
-      communityUsers?: Amity.Membership<'community'>[]
-      categories?: Amity.Category[]
-      feeds?: Amity.Feed[]
-      users?: Amity.User[]
-      files?: Amity.File[]
-    }
+      communities: Amity.Community[];
+      communityUsers?: Amity.Membership<'community'>[];
+      categories?: Amity.Category[];
+      feeds?: Amity.Feed[];
+      users?: Amity.User[];
+      files?: Amity.File[];
+    };
 
     type CategoryPayload = {
-      categories: Amity.Category[]
-      files: Amity.File[]
-    }
+      categories: Amity.Category[];
+      files: Amity.File[];
+    };
 
     type CommunityMembershipPayload = {
-      communities: Amity.Community[]
-      communityUsers: Amity.Membership<'community'>[]
-      categories?: Amity.Category[]
-      feeds?: Amity.Feed[]
-      users: Amity.User[]
-      files?: Amity.File[]
-    }
+      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[]
-    }
+      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[];
+    };
 
     type CommentPayload<T extends Amity.CommentContentType = any> = {
-      comments: Amity.Comment<T>[]
-      commentChildren?: Amity.Comment[]
-      users?: Amity.User[]
-      files?: Amity.File[]
-    }
+      comments: Amity.Comment<T>[];
+      commentChildren?: Amity.Comment[];
+      users?: Amity.User[];
+      files?: Amity.File[];
+    };
 
-    type GlobalFeedPayload = Amity.PostPayload
+    type GlobalFeedPayload = Amity.PostPayload;
+
+    type FollowersPayload = {
+      follows: Amity.FollowStatus[];
+    } & UserPayload;
+
+    type FollowStatusPayload = {
+      follows: Amity.FollowStatus[];
+    };
+
+    type FollowInfoPayload = {
+      follows: Amity.FollowStatus[];
+      followCounts: Amity.FollowCount[];
+    };
   }
 }

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

@@ -1,4 +1,4 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
@@ -65,11 +65,10 @@ declare global {
     }
 
     type Role = {
-      roleId: string
-      displayName: string
-      permissions: Permission[]
-    }
-    & Amity.Timestamps
-    & Amity.SoftDelete
+      roleId: string;
+      displayName: string;
+      permissions: Permission[];
+    } & Amity.Timestamps &
+      Amity.SoftDelete;
   }
 }

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

@@ -1,58 +1,63 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
     type Cachable = {
-      cachedAt: number
-    }
+      cachedAt: number;
+    };
 
     type Local = {
-      cachedAt: -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 | undefined
-    }
+      (...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 | undefined
-    }
+      (...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
-    }
+      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>
-          ? { data: T3[] | undefined } & Pages & { cachedAt?: CacheOptions['cachedAt'] }
-          : { data: T2 }  & { cachedAt?: CacheOptions['cachedAt'] }
-        : T extends Amity.Paged<infer T3>
-          ? { data: T3[] | undefined } & Pages
-          : { data: T | undefined }
-    ) & 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,46 +1,55 @@
-import { ASCError } from '~/core/errors'
+import { ASCError } from '~/core/errors';
 
-export {}
+export {};
 
 declare global {
   namespace Amity {
     type SuccessResponse<T> = {
-      status: 'success'
-      data: T
-    }
+      status: 'success';
+      data: T;
+    };
 
     type FailResponse = {
-      status: 'fail'
-      code: Amity.ServerError
-    }
+      status: 'fail';
+      code: Amity.ServerError;
+    };
 
     type ErrorResponse = {
-      status: 'error'
-      message: string
-      code: Amity.ServerError
-    }
+      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
-    }
+      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,14 +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
+      categoryId: string;
+      name: string;
+      avatarFileId?: Amity.File<'image'>['fileId'];
+    } & Amity.Metadata &
+      Amity.Timestamps &
+      Amity.SoftDelete;
   }
 }

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

@@ -1,37 +1,36 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type ChannelType = 'standard' | 'live' | 'conversation' | 'broadcast'
+    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
+      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?: Amity.timestamp;
+    } & Amity.Metadata &
+      Amity.Taggable &
+      Amity.Timestamps &
+      Amity.SoftDelete;
   }
 }

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

@@ -1,41 +1,40 @@
-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 = {
-      version: string
+      version: string;
 
-      log: Logger
-      http: AxiosInstance
-      mqtt: Amity.MqttClient
-      ws: SocketIOClient.Socket
-      emitter: Emitter<Amity.Events>
+      log: Logger;
+      http: AxiosInstance;
+      mqtt: Amity.MqttClient;
+      ws: SocketIOClient.Socket;
+      emitter: Emitter<Amity.Events>;
 
-      cache?: Amity.Cache
+      cache?: Amity.Cache;
 
-      apiKey?: string
-      userId?: string
-      _internalUserId?: string
-      accessToken?: string
+      apiKey?: string;
+      userId?: string;
+      accessToken?: string;
 
-      use: () => void
-    }
+      use: () => void;
+    };
 
     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;
+    };
   }
 }