@amityco/ts-sdk 0.0.1-beta.1 → 0.0.1-beta.13

package/rollup.config.js

@@ -0,0 +1,84 @@
+import chalk from 'chalk'
+import commonjs from '@rollup/plugin-commonjs'
+import resolve from '@rollup/plugin-node-resolve'
+import typescript from 'rollup-plugin-typescript2'
+import replace from '@rollup/plugin-replace'
+import { terser } from 'rollup-plugin-terser'
+
+import pkg from './package.json'
+
+const config = {
+  input: 'src/index.ts',
+  plugins: [
+    resolve({
+      jsnext: true,
+      main: true,
+      builtins: false,
+      browser: true,
+    }),
+    commonjs(),
+    typescript({
+      useTsconfigDeclarationDir: true,
+    }),
+  ],
+  onwarn: warning => {
+    // we don't allow circular dependencies other than those that we can not fix such as node_modules
+    if (warning.code === 'CIRCULAR_DEPENDENCY' && !warning.importer.includes('node_modules')) {
+      console.log(chalk.red('error'), warning.message)
+      process.exit(1)
+    }
+  },
+}
+
+export default [
+  {
+    ...config,
+    output: [
+      {
+        format: 'es',
+        file: pkg.module,
+      },
+    ],
+    external: Object.keys(pkg.dependencies),
+    plugins: [
+      ...config.plugins,
+      replace({
+        'process.env.NODE_ENV': `'${process.env.NODE_ENV}'`,
+        'process.env.VERSION': `'v${pkg.version}-esm'`,
+      }),
+    ],
+  },
+  {
+    ...config,
+    output: [
+      {
+        format: 'cjs',
+        file: pkg.main,
+      },
+    ],
+    external: Object.keys(pkg.dependencies),
+    plugins: [
+      ...config.plugins,
+      replace({
+        'process.env.NODE_ENV': `'${process.env.NODE_ENV}'`,
+        'process.env.VERSION': `'v${pkg.version}-cjs'`,
+      }),
+    ],
+  },
+  {
+    ...config,
+    output: {
+      format: 'iife',
+      name: 'Amity',
+      file: pkg.unpkg,
+    },
+    plugins: [
+      ...config.plugins,
+      replace({
+        'process.env.NODE_ENV': `'${process.env.NODE_ENV}'`,
+        'process.env.VERSION': `'v${pkg.version}-umd'`,
+      }),
+      terser(),
+    ],
+  },
+]

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

@@ -0,0 +1,69 @@
+export {}
+
+declare global {
+  namespace Amity {
+    /**
+     * Union of acceptable types for a chunk of cache key.
+     * Recursive type which allow 3 primitives + array or object of them.
+     *
+     * @hidden
+     */
+    type Serializable = (
+      string | number | boolean | undefined | Serializable[] | { [key: string]: Serializable }
+    )
+
+    /**
+     * Cache key description. Similarly to react-query,
+     * the key is an array of serializable values.
+     */
+    type CacheKey = Serializable[]
+
+    /**
+     * Cache entry wrapper. It contains the cached content
+     * itself (data: T) and also several other properties
+     * through CacheOptions to allow fine tuned control.
+     */
+    type CacheEntry<T extends unknown = unknown> = {
+      key: CacheKey
+      data: T
+    } & CacheOptions
+
+    /**
+     * Cache options are separated from CacheEntry for further type
+     * manipulations and passing of options in functions.
+     *
+     * The cache options are:
+     *   - cachedAt(number): used to check is the cached content is still
+     *     considered fresh or not.
+     *
+     *   - offline(boolean): used to determine if the entry must be
+     *     saved in persistent storage on top of the regular caching.
+     */
+    type CacheOptions = {
+      cachedAt: number | undefined
+      offline?: boolean
+    }
+
+
+    /**
+     * Minimal CacheEntry alias, used mostly
+     */
+     type Cached<T extends unknown = unknown> = (
+      T extends (Amity.PagedRaw<any> | Amity.Paged<any>)
+        ? T
+        : { data: T }
+     ) & {
+      cachedAt?: CacheOptions['cachedAt']
+    }
+
+    /**
+     * Main interface for the cache data structure. There's no direct
+     * methods there as we want to keep the object easily serializable
+     * (over JSON.stringify/parse) for simple backup/hydration.
+     */
+    type Cache = {
+      data: Record<string, CacheEntry>
+      persistIf?: (key: CacheKey, data?: any) => boolean
+    }
+  }
+}

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

@@ -0,0 +1,38 @@
+export {}
+
+declare global {
+  namespace Amity {
+    const enum ErrorLevel {
+      ERROR = 'error',
+      FATAL = 'fatal',
+    }
+
+    type ErrorCode = ServerError | ClientError
+
+    const enum ServerError {
+      BAD_REQUEST = 400000,
+      UNAUTHORIZED = 400100,
+      PERMISSION_DENIED = 400301,
+      ITEM_NOT_FOUND = 400400,
+      CONFLICT = 400900,
+      FORBIDDEN = 400300,
+      USER_IS_MUTED = 400302,
+      CHANNEL_IS_MUTED = 400303,
+      CHANNEL_BAN = 400304,
+      GLOBAL_BAN = 400312,
+      NUMBER_OF_MEMBERS_EXCEEDED = 400305,
+      MAX_REPETITION_EXCEEDED = 400307,
+      BAN_WORD_FOUND = 400308,
+      LINK_NOT_ALLOWED = 400309,
+      BUSINESS_ERROR = 500000,
+    }
+
+    const enum ClientError {
+      UNKNOWN_ERROR = 800000,
+      INVALID_PARAMETERS = 800110,
+      QUERY_IN_PROGRESS = 800170,
+      CONNECTION_ERROR = 800210,
+      DISCONNECTED = 800211,
+    }
+  }
+}

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

@@ -0,0 +1,106 @@
+import { IConnectPacket, IDisconnectPacket, IPublishPacket } from 'mqtt/dist/mqtt'
+
+export {}
+
+declare global {
+  namespace Amity {
+    type Listener<T = any> = (params: T) => void
+
+    type ObjectListener<T, K extends string[]> = {
+      onEvent?: (event: K[number], params: T) => void
+    } & {
+      [P in K[number]]?: Listener<T>
+    }
+
+    type Unsubscriber = () => void
+
+    type Subscriber<T = any> = (fn: Amity.Listener<T>) => Unsubscriber
+
+    type WsEvents = {
+      disconnected: Amity.ErrorResponse | undefined
+      error: Amity.ErrorResponse | undefined,
+      connect_error: Amity.ErrorResponse | undefined,
+      reconnect_error: Amity.ErrorResponse | undefined,
+      reconnect_failed: Amity.ErrorResponse | undefined,
+
+      'v3.channel.didCreate': Amity.ChannelPayload
+      'v3.channel.didUpdate': Amity.ChannelPayload
+      'v3.channel.didDelete': Amity.ChannelPayload
+      'v3.channel.didJoin': Amity.ChannelPayload
+      'v3.channel.didLeave': Amity.ChannelPayload
+      'v3.channel.didAddUsers': Amity.ChannelPayload
+      'v3.channel.didRemoveUsers': Amity.ChannelPayload
+      'v3.channel.didBan': Amity.ChannelPayload
+      'v3.channel.didUnban': Amity.ChannelPayload
+
+      'v3.message.didCreate': Amity.MessagePayload
+      'v3.message.didUpdate': Amity.MessagePayload
+      'v3.message.didDelete': Amity.MessagePayload
+
+      'video-streaming.didRecord': Amity.StreamPayload
+      'video-streaming.didStart': Amity.StreamPayload
+      'video-streaming.didStop': Amity.StreamPayload
+    }
+
+    type MqttEvents = {
+      connect: IConnectPacket,
+      message: [topic: string, payload: Buffer, packet: IPublishPacket]
+      disconnect: IDisconnectPacket,
+      error: Error,
+      close: Error,
+      end: undefined,
+      reconnect: undefined,
+    }
+
+    type MqttCommunityUserMessageEvents = {
+      'community.joined': Amity.CommunityMembershipPayload
+      'community.left': Amity.CommunityMembershipPayload
+      'community.userAdded': Amity.CommunityMembershipPayload
+      'community.userRemoved': Amity.CommunityMembershipPayload
+      'community.userBanned': Amity.CommunityMembershipPayload
+      'community.userUnbanned': Amity.CommunityMembershipPayload
+    }
+
+    type MqttCommunityMessageEvents = {
+      'community.created': Amity.CommunityPayload,
+      'community.updated': Amity.CommunityPayload
+      'community.deleted': Amity.CommunityPayload
+    } & MqttCommunityUserMessageEvents
+
+    type MqttPostMessageEvents = {
+      'post.created': Amity.PostPayload
+      'post.updated': Amity.PostPayload
+      'post.deleted': Amity.PostPayload
+      'post.approved': Amity.PostPayload
+      'post.declined': Amity.PostPayload
+      'post.flagged': Amity.PostPayload
+      'post.unflagged': Amity.PostPayload
+      'post.addReaction': Amity.PostPayload & { reactor: Amity.Reaction }
+      'post.removeReaction': Amity.PostPayload & { reactor: Amity.Reaction }
+    }
+
+    type MqttCommentMessageEvents = {
+      'comment.created': Amity.CommentPayload
+      'comment.updated': Amity.CommentPayload
+      'comment.deleted': Amity.CommentPayload
+      'comment.flagged': Amity.CommentPayload
+      'comment.unflagged': Amity.CommentPayload
+      'comment.addReaction': Amity.CommentPayload & { reactor: Amity.Reaction }
+      'comment.removeReaction': Amity.CommentPayload & { reactor: Amity.Reaction }
+    }
+
+    type MqttUserMessageEvents = {
+      'user.updated': Amity.UserPayload
+      'user.flagged': Amity.UserPayload
+      'user.unflagged': Amity.UserPayload
+      'user.flagCleared': Amity.UserPayload
+    }
+
+    type MqttMessageEvents = MqttCommunityMessageEvents
+      & MqttPostMessageEvents
+      & MqttCommentMessageEvents
+      & MqttUserMessageEvents
+
+    type Events = WsEvents & MqttEvents & MqttMessageEvents
+  }
+}

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

@@ -0,0 +1,53 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type Domain = keyof Model
+
+    /**
+     * type map of "domain name -> ASC model"
+     * @hidden
+     */
+    type Model = {
+      'user': Amity.User
+      'file': Amity.File
+      'role': Amity.Role
+
+      'channel': Amity.Channel
+      'channelUsers': Amity.Membership<'channel'>
+      'message': Amity.Message
+
+      'community': Amity.Community
+      'communityUsers': Amity.Membership<'community'>
+      'post': Amity.Post
+      'comment': Amity.Comment
+
+      'stream': Amity.Stream
+    }
+
+    /**
+     * Definition of the minimal set of properties necessary to identify
+     * successfully a model.
+     * @hidden
+     */
+    type Minimal = {
+      'user': Pick<Amity.User, 'userId'>
+      'file': Pick<Amity.File, 'fileId'>
+      'role': Pick<Amity.Role, 'roleId'>
+
+      'channel': Pick<Amity.Channel, 'channelId'>
+      'channelUsers': Pick<Amity.Membership<'channel'>, 'channelId' | 'userId'>
+      'message': Pick<Amity.Message, 'messageId'>
+
+      'community': Pick<Amity.Community, 'communityId'>
+      'communityUsers': Pick<
+        Amity.Membership<'community'>,
+        'communityId' | 'userId'
+      >
+      'post': Pick<Amity.Post, 'postId'>
+      'comment': Pick<Amity.Comment, 'commentId'>
+
+      'stream': Pick<Amity.Stream, 'streamId'>
+    }
+  }
+}

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

@@ -0,0 +1,75 @@
+export {}
+
+declare global {
+  namespace Amity {
+    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
+
+    type AfterBeforeRawPagination = {
+      before?: string
+      after?: string
+      updatedAt?: string
+    }
+
+    type PrevPageRaw = {
+      after?: never
+      before?: string
+      limit: number
+      updatedAt?: string
+    }
+
+    type NextPageRaw = {
+      after?: string
+      before?: never
+      limit: number
+      updatedAt?: string
+    }
+
+    type PageRaw = (PrevPageRaw | NextPageRaw)
+
+    type PagesRaw = {
+      nextPage?: PageRaw | null
+      prevPage?: PageRaw | null
+    }
+
+    type PagedRaw<T> = { data: T[] } & PagesRaw
+  }
+}

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

@@ -0,0 +1,102 @@
+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
+    }
+
+    type UserPayload = {
+      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 RolePayload = {
+      roles: Amity.Role[]
+    }
+
+    type ChannelPayload<T extends Amity.ChannelType = any> = {
+      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[]
+    }
+
+    type MessagePayload<T extends Amity.MessageContentType = any> = {
+      messages: Amity.Message<T>[]
+      users?: Amity.User[]
+      files?: Amity.File[]
+    }
+
+    type StreamPayload = {
+      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[]
+    }
+
+    type CategoryPayload = {
+      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[]
+    }
+
+    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[]
+    }
+
+    type CommentPayload<T extends Amity.CommentContentType = any> = {
+      comments: Amity.Comment<T>[]
+      commentChildren?: Amity.Comment[]
+      users?: Amity.User[]
+      files?: Amity.File[]
+    }
+
+    type GlobalFeedPayload = Amity.PostPayload
+  }
+}

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

@@ -0,0 +1,75 @@
+export {}
+
+declare global {
+  namespace Amity {
+    const enum Permission {
+      EditUserPermission = 'EDIT_USER',
+      BanUserPermission = 'BAN_USER',
+      CreateRolePermission = 'CREATE_ROLE',
+      EditRolePermission = 'EDIT_ROLE',
+      DeleteRolePermission = 'DELETE_ROLE',
+      AssignRolePermission = 'ASSIGN_USER_ROLE',
+      EditChannelPermission = 'EDIT_CHANNEL',
+      EditChannelRatelimitPermission = 'EDIT_CHANNEL_RATELIMIT',
+      MuteChannelPermission = 'MUTE_CHANNEL',
+      CloseChannelPermission = 'CLOSE_CHANNEL',
+      AddChannelUserPermission = 'ADD_CHANNEL_USER',
+      EditChannelUserPermission = 'EDIT_CHANNEL_USER',
+      RemoveChannelUserPermission = 'REMOVE_CHANNEL_USER',
+      MuteChannelUserPermission = 'MUTE_CHANNEL_USER',
+      BanChannelUserPermission = 'BAN_CHANNEL_USER',
+      EditMessagePermission = 'EDIT_MESSAGE',
+      DeleteMessagePermission = 'DELETE_MESSAGE',
+      EditCommunityPermission = 'EDIT_COMMUNITY',
+      DeleteCommunityPermission = 'DELETE_COMMUNITY',
+      AddChannelCommunityPermission = 'ADD_COMMUNITY_USER',
+      EditChannelCommunityPermission = 'EDIT_COMMUNITY_USER',
+      RemoveChannelCommunityPermission = 'REMOVE_COMMUNITY_USER',
+      MuteChannelCommunityPermission = 'MUTE_COMMUNITY_USER',
+      BanChannelCommunityPermission = 'BAN_COMMUNITY_USER',
+      EditUserFeedPostPermission = 'EDIT_USER_FEED_POST',
+      DeleteUserFeedPostPermission = 'DELETE_USER_FEED_POST',
+      EditUserFeedCommentPermission = 'EDIT_USER_FEED_COMMENT',
+      DeleteUserFeedCommentPermission = 'DELETE_USER_FEED_COMMENT',
+      EditCommunityFeedPostPermission = 'EDIT_COMMUNITY_FEED_POST',
+      DeleteCommunityFeedPostPermission = 'DELETE_COMMUNITY_FEED_POST',
+      EditCommunityFeedCommentPermission = 'EDIT_COMMUNITY_FEED_COMMENT',
+      DeleteCommunityFeedCommentPermission = 'DELETE_COMMUNITY_FEED_COMMENT',
+      CreateCommunityCategoryPermission = 'CREATE_COMMUNITY_CATEGORY',
+      EditCommunityCategoryPermission = 'EDIT_COMMUNITY_CATEGORY',
+      DeleteCommunityCategoryPermission = 'DELETE_COMMUNITY_CATEGORY',
+    }
+
+    const enum PermissionLegacy {
+      ModeratorRoleLegacy = 'moderator',
+      SuperModeratorRoleLegacy = 'super-moderator',
+      GlobalAdminRoleLegacy = 'global-admin',
+      BanUserPermissionLegacy = 'Channel/BanUser',
+      MuteUserPermissionLegacy = 'Channel/MuteUser',
+      MuteChannelPermissionLegacy = 'Channel/MuteChannel',
+      RateLimitUserPermissionLegacy = 'Channel/RateLimitUser',
+      RateLimitChannelPermissionLegacy = 'Channel/RateLimitChannel',
+      ManageMessagesPermissionLegacy = 'Channel/ManageMessages',
+      ManageUsersPermissionLegacy = 'Channel/ManageUsers',
+      GlobalAccessPermissionLegacy = 'Channel/GlobalAccess',
+      ExemptFromFiltersPermissionLegacy = 'User/ExemptFromFilters',
+      ExemptFromRateLimitsPermissionLegacy = 'User/ExemptFromRateLimits',
+      ExemptFromMutePermissionLegacy = 'User/ExemptFromMute',
+      ExemptFromBanPermissionLegacy = 'User/ExempFromBan',
+      ExemptFromWhitelistPermissionLegacy = 'User/ExempFromWhitelist',
+      ExemptFromBlacklistPermissionLegacy = 'User/ExempFromBlacklist',
+      ExemptFromRepetitionCheckPermissionLegacy = 'User/ExempFromRepetitionCheck',
+      ManagePostsPermissionLegacy = 'Post/ManagePosts',
+      ManageCommentsPermissionLegacy = 'Post/ManageComments',
+      ManageCommunitiesPermissionLegacy = 'Community/ManageCommunities',
+    }
+
+    type Role = {
+      roleId: string
+      displayName: string
+      permissions: Permission[]
+    }
+    & Amity.Timestamps
+    & Amity.SoftDelete
+  }
+}

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

@@ -0,0 +1,54 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type Cachable = {
+      cachedAt: number
+    }
+
+    type Local = {
+      cachedAt: -1
+    }
+
+    type AsyncFunc<Args extends any[], Returned extends any> = {
+      (...args: Args): Promise<Returned>
+    }
+
+    type FetcherFunc<Args extends any[], Returned extends any> = {
+      (...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
+    }
+
+    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
+    }
+
+    type QueryPolicy = 'server_only' | 'cache_only' | 'cache_then_server' | 'no_fetch'
+
+    type QueryOptions = {
+      lifeSpan: number
+    }
+
+    type SnapshotOptions = {
+      origin: 'local' | 'server' | 'event'
+      loading: boolean
+      error?: any
+    }
+
+    type Snapshot<T> = (
+      T extends Amity.Cached<infer K> ? { data: K } :
+      T extends (Amity.PagedRaw<any> | Amity.Paged<any>) ? T :
+      { data: T }
+    ) & SnapshotOptions
+  }
+}