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

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

@@ -0,0 +1,46 @@
+import { ASCError } from '~/core/errors'
+
+export {}
+
+declare global {
+  namespace Amity {
+    type SuccessResponse<T> = {
+      status: 'success'
+      data: T
+    }
+
+    type FailResponse = {
+      status: 'fail'
+      code: Amity.ServerError
+    }
+
+    type ErrorResponse = {
+      status: 'error'
+      message: string
+      code: Amity.ServerError
+    }
+
+    type Response<T> = (SuccessResponse<T> | FailResponse | ErrorResponse)
+
+    type Token = string
+
+    type Pagination = {
+      paging: {
+        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

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

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

@@ -0,0 +1,37 @@
+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
+  }
+}

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

@@ -0,0 +1,41 @@
+import { AxiosInstance } from 'axios'
+import { Emitter } from 'mitt'
+
+declare global {
+  namespace Amity {
+    type Logger = (topic: string, ...args: any[]) => void
+
+    type Client = {
+      version: string
+
+      log: Logger
+      http: AxiosInstance
+      mqtt: Amity.MqttClient
+      ws: SocketIOClient.Socket
+      emitter: Emitter<Amity.Events>
+
+      cache?: Amity.Cache
+
+      apiKey?: string
+      userId?: string
+      _internalUserId?: string
+      accessToken?: string
+
+      use: () => void
+    }
+
+    type Device = {
+      deviceId: string
+      deviceInfo: {
+        version: string
+        kind: 'node' | 'web'
+        model?: string
+      }
+    }
+
+    type Tokens = {
+      accessToken: string
+      refreshToken: string
+    }
+  }
+}

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

@@ -0,0 +1,29 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type CommentContentType = ('text')
+    type CommentReferenceType = ('content' | 'post')
+
+    type CommentMentionType = keyof MentionTypes
+
+    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.Subscribable
+    & Amity.Mentionable<CommentMentionType>
+  }
+}

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

@@ -0,0 +1,35 @@
+export {}
+
+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.Subscribable
+  }
+}

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

@@ -0,0 +1,37 @@
+export {}
+
+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'  ? Record<string, unknown> :
+      T extends string  ? string | Record<string, unknown> : // custom type
+      never
+    )
+
+    type Content<T extends ContentType, K extends 'type' | 'dataType' = 'dataType'> = (
+      { [S in K]?: T } & { data: ContentData<T> }
+    )
+  }
+}

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

@@ -0,0 +1,16 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type FeedType = ('community' | 'user')
+
+    type Feed = {
+      feedId: string
+      feedType: 'reviewing' | 'published'
+      targetType: FeedType
+      targetId: string
+      postCount: number
+    }
+    & Amity.Timestamps
+  }
+}

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

@@ -0,0 +1,41 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type FileType = 'file' | 'image' | 'video'
+
+    type FileMetadata = {}
+
+    type ImageMetadata = {
+      exif: Object
+      gps: Object
+      width: number
+      height: number
+      isFull:	boolean
+    }
+
+    type VideoMetadata = {}
+
+    type MetadataFor<T extends FileType> = (
+      T extends 'file' ? FileMetadata :
+      T extends 'image' ? ImageMetadata :
+      T extends 'video' ? VideoMetadata :
+      never
+    )
+
+    type File<T extends FileType = any> = {
+      fileId:	string
+      type: T
+      fileUrl: string
+      attributes: {
+        name: string
+        extension: string
+        size: string
+        mimeType: string
+        metadata: MetadataFor<T>
+      }
+    }
+    & Amity.Timestamps
+    & Amity.SoftDelete
+  }
+}

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

@@ -0,0 +1,37 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type GroupType = ('channel' | 'community')
+
+    type Group = {
+      membersCount: number
+    }
+
+    type Member<T extends GroupType> = {
+      userId: User['userId']
+    } & (
+      T extends 'channel' ? {
+        channelId: Amity.Channel['channelId']
+        membership: 'member' | 'none' | 'banned'
+        readToSegment: number
+      } :
+      T extends 'community' ? {
+        communityId: Amity.Community['communityId']
+        communityMembership: 'member' | 'none' | 'banned'
+      } :
+      never
+    )
+    & Timestamps
+
+
+    type Membership<T extends GroupType> = {
+      isBanned: boolean
+      isMuted: boolean
+      muteTimeout: string
+      lastActivity: timestamp
+    }
+    & Member<T>
+    & Amity.Accredited
+  }
+}

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

@@ -0,0 +1,26 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type MessageContentType = ('text' | 'file' | 'image')
+
+    type Message<T extends Amity.MessageContentType = any> = {
+      messageId: string
+
+      channelId: Amity.Channel['channelId']
+      userId: Amity.User['userId']
+
+      parentId?: Message['messageId']
+      childrenNumber: number
+
+      channelSegment: number
+
+      editedAt: timestamp
+    }
+    & Amity.Content<T, 'type'>
+    & Amity.Metadata
+    & Amity.Timestamps
+    & Amity.SoftDelete
+    & Amity.Reactable
+  }
+}

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

@@ -0,0 +1,64 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type timestamp = string
+
+    type CreatedAt = {
+      createdAt: timestamp
+    }
+
+    type UpdatedAt = {
+      updatedAt?: timestamp
+    }
+
+    type DeletedAt = {
+      deletedAt?: timestamp
+    }
+
+    type Timestamps = CreatedAt & UpdatedAt
+
+    type SoftDelete = DeletedAt & {
+      isDeleted?: boolean
+    }
+
+    type Metadata = {
+      metadata?: Record<string, any>
+    }
+
+    type Relationship<T extends string> = {
+      referenceId: string
+      referenceType: T
+    }
+
+    type Flaggable = {
+      flagCount: number
+      hashFlag: {
+        bits: number
+        hashes: number
+        hash: string
+      } | null
+    }
+
+    type Taggable = {
+      tags?: string[]
+    }
+
+    type Accredited = {
+        roles: Amity.Role['displayName'][]
+        permissions: Amity.Permission[]
+    }
+
+    type Subscribable = {
+      path: string
+    }
+
+    type MentionTypes = {
+      user: { userIds: Amity.User['userId'][] }
+    }
+
+    type Mentionable<T extends keyof MentionTypes> = {
+      mentionees?: {type: T & MentionTypes}[]
+    }
+  }
+}

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

@@ -0,0 +1,35 @@
+export {}
+
+declare global {
+  namespace Amity {
+    // bad hack until we get proper feed objects in backend
+    type PostTargetType = Amity.FeedType | 'content'
+
+    type PostContentType = ('text' | 'image' | 'file' | 'video')
+
+    type PostMentionType = keyof MentionTypes
+
+    type Post<T extends PostContentType = any> = {
+      postId: string
+      postedUserId: User['userId'] // API-FIX: it should be "userId"
+      parentId: Post['postId']
+      targetType: PostTargetType
+      targetId: string
+      feedId: Feed['feedId']
+      children: Amity.Post['postId'][]
+      comments: Amity.Comment['commentId'][]
+      commentsCount: number // API-FIX: backend doesnt follow its own convention
+      hasFlaggedChildren: false
+      hasFlaggedComment: false
+      editedAt: timestamp,
+    }
+    & Amity.Content<T, 'dataType'>
+    & Amity.Metadata
+    & Amity.Flaggable
+    & Amity.Reactable
+    & Amity.Timestamps
+    & Amity.SoftDelete
+    & Amity.Subscribable
+    & Amity.Mentionable<PostMentionType>
+  }
+}

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

@@ -0,0 +1,30 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type ReactableType = ('message' | 'post' | 'comment')
+
+    type Reaction =  {
+      reactionId: string
+      userId: string
+      reactionName: string
+    }
+    & Amity.CreatedAt
+    & Amity.Relationship<ReactableType>
+
+    type Reactions = {
+      reactions: Record<string, number>
+      count: number
+    }
+
+    type Reactable = {
+      reactionsCount: number
+      reactions: Record<string, number>
+      myReactions?: string[]
+
+      latestReaction?: Amity.Reaction & {
+        eventName: ('added' | 'removed')
+      }
+    }
+  }
+}

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

@@ -0,0 +1,68 @@
+export {}
+
+declare global {
+  namespace Amity {
+    const enum StreamStatus {
+      IDLE = 'idle',
+      LIVE = 'live',
+      ENDED = 'ended',
+      RECORDED = 'recorded',
+    }
+
+    const enum StreamResolution {
+      SD = 'SD',
+      HD = 'HD',
+      FHD = 'FHD',
+    }
+
+    type MultiFormat<T> = {
+      flv?: T
+      mp4?: T
+      m3u8?: T
+    }
+
+    type StreamPlatform = {
+      name: string
+      version: string
+    }
+
+    type StreamEndpoint = {
+      url: string
+      components: {
+        origin: string
+        appName: string
+        streamName: string
+        query: string
+      }
+    }
+
+    type StreamRecording = {
+      url: string
+      duration: number
+      startTime: number
+      stopTime: number
+    }
+
+    type Stream = {
+      streamId: string
+      title: string
+      thumbnailFileId?: Amity.File<'image'>['fileId']
+      description?: string
+      status: StreamStatus
+      platform: StreamPlatform
+
+      isLive?: boolean
+      endedAt: timestamp
+      startedAt: timestamp
+      userId: User['userId']
+      resolution: StreamResolution
+
+      streamerUrl: StreamEndpoint
+      watcherUrl: MultiFormat<StreamEndpoint>
+      recordings: MultiFormat<StreamRecording>[]
+    }
+    & Amity.Metadata
+    & Amity.Timestamps
+    & Amity.SoftDelete
+  }
+}

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

@@ -0,0 +1,19 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type User = {
+      _id: string
+      userId: string
+      displayName?: string
+      avatarFileId?: Amity.File<'image'>['fileId']
+      description?: string
+    }
+    & Amity.Metadata
+    & Amity.Taggable
+    & Amity.Flaggable
+    & Amity.Accredited
+    & Amity.Timestamps
+    & Amity.Subscribable
+  }
+}

package/src/@types/global.ts

@@ -0,0 +1,25 @@
+export {}
+
+declare global {
+  type Writeable<T> = { -readonly [P in keyof T]: T[P] }
+
+  type Patch<T, K extends keyof T> = Partial<Pick<T, K>>
+
+  type Unwrap<T> = (
+    T extends Promise<infer U> ? U :
+    T extends (...args: any) => Promise<infer U> ? U :
+    T extends (...args: any) => infer U ? U :
+    T
+  )
+
+  interface ObjectConstructor {
+    keys<T>(o: T): ObjectKeys<T>
+  }
+
+  type ObjectKeys<T> =  (
+    T extends object ? (keyof T)[] :
+    T extends number ? [] :
+    T extends Array<any> | string ? string[] :
+    never
+  )
+}

package/src/@types/index.ts

@@ -0,0 +1,31 @@
+import './global' // global types (system)
+
+import './core/errors' // global errors
+import './core/permissions' // permissions enum
+
+import './core/payload' // backend payload definition
+import './core/events' // sdk events definitions
+import './core/paging' // createQuery, runQuery
+import './core/query' // createQuery, runQuery
+import './core/cache' // cache.pull('user', ...)
+
+// domains
+import './domains/client' // client definition
+
+import './domains/user'
+import './domains/file'
+
+import './domains/partials' // small model partials (CreatedAt, etc...)
+import './domains/content' // content partial
+import './domains/reaction'
+
+import './domains/group'
+import './domains/channel'
+import './domains/message'
+
+import './domains/community'
+import './domains/category'
+import './domains/post'
+import './domains/comment'
+
+import './domains/stream'

package/src/@types/mqtt.d.ts

@@ -0,0 +1,3 @@
+declare module 'mqtt/dist/mqtt' {
+  export * from 'mqtt';
+}