@amityco/ts-sdk 0.0.1-beta.2 → 0.0.1-c58e50d.0

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

@@ -0,0 +1,95 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type Syncable = {
+      localId: string
+      syncedAt: number
+    }
+
+    type Local = {
+      localId: string
+      syncedAt: -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
+    }
+
+    type MutatorFunc<Args extends any[], Returned extends any> = {
+      (...args: Args): Promise<Returned>
+      optimistically: (...args: 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
+    }
+
+    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
+  }
+}

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

@@ -0,0 +1,52 @@
+export {}
+
+declare global {
+  namespace Amity {
+    /**
+     * Represents what needs to be done to read the state of a store
+     * @hidden
+     */
+    type StateReader<T extends {}> = () => Record<string, T>
+
+    /**
+     * Represents what needs to be done to write in the state of a store.
+     * @hidden
+     */
+    type StateWriter<T extends {}> = (payload: Record<string, T>) => void
+
+    /**
+     * Represents what needs to be done to erase records in the state of a store.
+     * @hidden
+     */
+    type StateEraser = (...payload: string[]) => void
+
+    /**
+     * Every object which has a read:StateReader function and a write:StateWriter function can be
+     * considered as a valid store. This opens the door for open and generic storage implementations.
+     * We can imagine linking this to React Context, Redux, MobX, VueX, any local database...
+     *
+     * Below "defaultStore" is a minimal "in memory + mutable" storage implementation, which is the
+     * bare minimum required to make the cache implementation working.
+     *
+     * Further storage strategies (offline, immutables, etc...) could be provided as
+     * core or community plugins.
+     * @hidden
+     */
+    type Store<T extends {} = any> = {
+      read: StateReader<T>
+      write: StateWriter<T>
+      erase: StateEraser
+    }
+
+    /**
+     * Manually computed type to output a dictionary of { StoreName: Amity.Store<Model> }
+     * with proper typing based on T
+     * @hidden
+     */
+    type StoreCollection<
+      T extends Amity.Domain[],
+    > = {
+      [K in T[number]]: Store<Amity.Model[K]>
+    }
+  }
+}

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

@@ -0,0 +1,32 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type SuccessResponse<T> = {
+      status: 'success'
+      data: T
+    }
+
+    type FailResponse = {
+      status: 'fail'
+      code: Amity.ClientError
+    }
+
+    type ErrorResponse = {
+      status: 'error'
+      message: string
+      code: Amity.ClientError
+    }
+
+    type Response<T> = (SuccessResponse<T> | FailResponse | ErrorResponse)
+
+    type Token = string
+
+    type Pagination = {
+      paging: {
+        previous?: Token
+        next?: Token
+      }
+    }
+  }
+}

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

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

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

@@ -0,0 +1,38 @@
+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
+    & Amity.Syncable
+  }
+}

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

@@ -0,0 +1,36 @@
+import { AxiosInstance } from 'axios'
+import { Emitter } from 'mitt'
+
+declare global {
+  namespace Amity {
+    type Logger = (topic: string, ...args: any[]) => void
+
+    type Client = {
+      log: Logger
+      http: AxiosInstance
+      ws: SocketIOClient.Socket
+      emitter: Emitter<Amity.Events>
+
+      cache?: Amity.Cache
+
+      apiKey?: string
+      userId?: 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,26 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type CommentContentType = ('text')
+    type CommentReferenceType = ('content' | 'post')
+
+    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
+  }
+}

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.Syncable
+  }
+}

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

@@ -0,0 +1,35 @@
+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'  ? object :
+      T extends string  ? any : // custom type
+      never
+    )
+
+    type ContentTypeFor<T> = (
+      T extends ContentDataText ? 'text' :
+      T extends ContentDataFile ? 'file' :
+      T extends ContentDataImage ? 'image' :
+      T extends ContentDataVideo ? 'video' :
+      T extends object ? 'json' :
+      'custom'
+    )
+
+    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'
+
+    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 :
+      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
+    & Amity.Syncable
+  }
+}

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

@@ -0,0 +1,38 @@
+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' | 'notMember' | 'banned'
+        readToSegment: number
+      } :
+      T extends 'community' ? {
+        communityId: Amity.Community['communityId']
+        communityMembership: 'member' | 'notMember' | 'banned'
+      } :
+      never
+    )
+    & Timestamps
+
+
+    type Membership<T extends GroupType> = {
+      isBanned: boolean
+      isMuted: boolean
+      muteTimeout: string
+      lastActivity: timestamp
+    }
+    & Member<T>
+    & Amity.Accredited
+    & Amity.Syncable
+  }
+}

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

@@ -0,0 +1,27 @@
+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.Syncable
+    & Amity.Reactable
+  }
+}

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

@@ -0,0 +1,52 @@
+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[]
+    }
+  }
+}

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

@@ -0,0 +1,31 @@
+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')
+
+    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.Syncable
+  }
+}

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,57 @@
+export {}
+
+declare global {
+  namespace Amity {
+    const enum StreamStatus {
+      IDLE = 'idle',
+      LIVE = 'live',
+      ENDED = 'ended',
+      RECORDED = 'recorded',
+    }
+
+    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
+
+      streamerUrl: StreamEndpoint
+      watcherUrl: MultiFormat<StreamEndpoint>
+      recordings: MultiFormat<StreamRecording>[]
+    }
+    & Amity.Metadata
+    & Amity.Timestamps
+    & Amity.SoftDelete
+    & Amity.Syncable
+  }
+}

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

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