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

package/src/reaction/api/removeReaction.ts

@@ -0,0 +1,84 @@
+import { getActiveClient } from '~/client/api'
+
+import { mutateCache } from '~/core/cache'
+
+import { dispatchReactable, fetchReference } from '../utils'
+
+/**
+ * ```js
+ * import { deleteReaction } from '@amityco/ts-sdk'
+ * const success = await deleteReaction('post', 'foobar', 'like')
+ * ```
+ *
+ * Removes a {@link Amity.Reaction} from a {@link Amity.Reactable} object
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The removed result.
+ *
+ * @category Reaction API
+ * @async
+ **/
+export const removeReaction = async (
+  referenceType: Amity.Reaction['referenceType'],
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reaction['reactionName']
+) => {
+  const client = getActiveClient()
+  client.log('reaction/removeReaction', {
+    referenceId,
+    referenceType,
+    reactionName,
+  })
+
+  await client.http.delete<{ removedId: string }>(
+    `/api/v2/reactions`,
+    { data: { referenceId, referenceType, reactionName } }
+  )
+
+  const model = await fetchReference(referenceType, referenceId)
+  dispatchReactable(referenceType, model)
+
+  return !model.myReactions?.includes(reactionName) ?? false
+}
+
+/**
+ * ```js
+ * import { removeReaction } from '@amityco/ts-sdk'
+ * const success = removeReaction.optimistically('post', postId, 'like')
+ * ```
+ *
+ * Removes a {@link Amity.Reaction} from a {@link Amity.Reactable} object optimistically
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ **/
+removeReaction.optimistically = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reaction['reactionName']
+) => {
+  const model = mutateCache(referenceType, referenceId, model => {
+    if (!model.myReactions?.includes(reactionName)) return
+
+    return {
+      ...model,
+      syncedAt: -1,
+      reactionsCount: Math.max(0, model.reactionsCount - 1),
+      myReactions: (model.myReactions ?? []).filter(item => item !== reactionName),
+      reactions: {
+        ...model.reactions,
+        [reactionName]: Math.max(0, (model.reactions[reactionName] ?? 0) - 1),
+      },
+    }
+  })
+
+  model && dispatchReactable(referenceType, model)
+
+  return !model?.myReactions?.includes(reactionName) ?? false
+}

package/src/reaction/events/index.ts

@@ -0,0 +1 @@
+export * from './onReactionRemoved'

package/src/reaction/events/onReactionAdded.ts

@@ -0,0 +1,43 @@
+import { getActiveClient } from '~/client/api'
+import { ingestInCache } from '~/core/cache'
+import { createEventSubscriber } from '~/core/events'
+import { decoratePayload } from '~/core/query'
+
+/**
+ * ```js
+ * import { onReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onReactionAdded(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reaction} has been added
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ **/
+export const onReactionAdded = (
+  referenceType: Amity.Reaction['referenceType'],
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Model[typeof referenceType]>
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const event = `v3.${referenceType}.didUpdate` as const
+
+  const filter = (payload: Amity.Events[typeof event]) => {
+    // TODO: lol
+
+    decoratePayload(payload)
+    ingestInCache(payload)
+  }
+
+  return createEventSubscriber(
+    client,
+    'reaction/onReactionAdded',
+    event,
+    filter
+  )
+}

package/src/reaction/events/onReactionRemoved.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api'
+import { ingestInCache } from '~/core/cache'
+import { createEventSubscriber } from '~/core/events'
+import { decoratePayload } from '~/core/query'
+
+/**
+ * ```js
+ * import { onReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onReactionRemoved(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reaction} has been removed
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ **/
+export const onReactionRemoved = (
+  referenceType: Amity.Reaction['referenceType'],
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Model[typeof referenceType]>
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.MessagePayload) => {
+    // TODO: lol
+
+    decoratePayload(payload)
+    ingestInCache(payload)
+  }
+
+  return createEventSubscriber(
+    client,
+    'reaction/onReactionRemoved',
+    'v3.message.didUpdate',
+    filter
+  )
+}

package/src/reaction/utils/dispatchReactable.ts

@@ -0,0 +1,19 @@
+import { fireEvent } from "~/core/events"
+
+/** @hidden */
+export const dispatchReactable = <T extends Amity.ReactableType>(
+  referenceType: T,
+  model: Amity.Model[T],
+) => {
+  let payload: any
+
+  if (referenceType === 'message')
+    // @ts-ignore: refactor later
+    fireEvent('v3.message.didUpdate', { messages: [model] })
+  else if (referenceType === 'post')
+    // @ts-ignore: refactor later
+    fireEvent('v3.post.didUpdate', { posts: [model] })
+  else if (referenceType === 'comment')
+    // @ts-ignore: refactor later
+    fireEvent('v3.comment.didUpdate', { comments: [model] })
+}

package/src/reaction/utils/fetchReference.ts

@@ -0,0 +1,18 @@
+import { getMessage } from '~/message/api'
+import { getPost } from '~/post/api'
+import { getComment } from '~/comment/api'
+
+/** @hidden */
+export const fetchReference = async (
+  referenceType: Amity.ReactableType,
+  referenceId: string,
+): Promise<Amity.Model[typeof referenceType]> => {
+  if (referenceType === 'message')
+    return getMessage(referenceId)
+  else if (referenceType === 'post')
+    return getPost(referenceId)
+  else if (referenceType === 'comment')
+    return getComment(referenceId)
+
+  throw new Error(`Incorrect referenceType: ${referenceType}`)
+}

package/src/reaction/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './dispatchReactable'
+export * from './fetchReference'

package/src/report/api/createReport.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api/activeClient'
+
+import { ingestInCache } from '~/core/cache'
+import { fireEvent } from '~/core/events'
+import { decoratePayload } from '~/core/query'
+
+import REFERENCE_TYPES from '../constants/referenceTypes'
+
+/**
+ * ```js
+ * import { createReport } from '@amityco/ts-sdk'
+ * const flagged = await createReport('post', postId)
+ * ```
+ *
+ * @param referenceType The type of thing to add a report to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new report to.
+ * @returns the created report result
+ *
+ * @category Report API
+ * @async
+ **/
+export const createReport = async (
+  referenceType: keyof typeof REFERENCE_TYPES,
+  referenceId: string
+) => {
+  const client = getActiveClient()
+  client.log('report/createReport', { referenceType, referenceId })
+
+  const { domainName } = REFERENCE_TYPES[referenceType]
+
+  const { data } = await client.http.post<Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload>(
+    `/api/v3/${domainName}/${referenceId}/flag`
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  fireEvent(`v3.${referenceType}.didUpdate`, data)
+
+  return !!data
+}

package/src/report/api/deleteReport.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api/activeClient'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+import REFERENCE_TYPES from '../constants/referenceTypes'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { deleteReport } from '@amityco/ts-sdk'
+ * const unflagged = await deleteReport('post', postId)
+ * ```
+ *
+ * @param referenceType The type of thing to delete a report to, such as a post or a comment.
+ * @param referenceId The ID of the thing to delete a report to.
+ * @returns the deleted report result
+ *
+ * @category Report API
+ * @async
+ **/
+export const deleteReport = async (
+  referenceType: keyof typeof REFERENCE_TYPES,
+  referenceId: string
+) => {
+  const client = getActiveClient()
+  client.log('report/deleteReport', { referenceType, referenceId })
+
+  const { domainName } = REFERENCE_TYPES[referenceType]
+
+  const { data } = await client.http.delete<Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload>(
+    `/api/v3/${domainName}/${referenceId}/unflag`
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  fireEvent(`v3.${referenceType}.didUpdate`, data)
+
+  return !!data
+}

package/src/report/api/index.ts

@@ -0,0 +1,4 @@
+export * from './createReport'
+export * from './deleteReport'
+
+export * from './isReportedByMe'

package/src/report/api/isReportedByMe.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api/activeClient'
+import { synchronousWSCall } from '~/core/transports'
+
+import REFERENCE_TYPES from '../constants/referenceTypes'
+
+/**
+ * ```js
+ * import { isReportedByMe } from '@amityco/ts-sdk'
+ * const isReported = await isReportedByMe('post', postId)
+ * ```
+ *
+ * @param referenceType The type of thing to check a report to, such as a post or a comment.
+ * @param referenceId The ID of the thing to check a report to.
+ * @returns `true` if the report is created by me, `false` if doesn't.
+ *
+ * @category Report API
+ * @async
+ **/
+export const isReportedByMe = async (
+  referenceType: keyof typeof REFERENCE_TYPES,
+  referenceId: string
+) => {
+  const client = getActiveClient()
+  client.log('report/isReportedByMe', { referenceType, referenceId })
+
+  const { eventName, primaryKey } = REFERENCE_TYPES[referenceType]
+
+  const { result, isFlagByMe } =
+    (await synchronousWSCall<{
+      result?: boolean
+      isFlagByMe?: boolean
+    }>(client, eventName, {
+      [primaryKey]: referenceId,
+    })) ?? {}
+
+  return result ?? isFlagByMe ?? false
+}

package/src/report/constants/referenceTypes.ts

@@ -0,0 +1,22 @@
+export default {
+  post: {
+    domainName: 'posts',
+    eventName: 'v3/post.isflagbyme',
+    primaryKey: 'postId',
+  },
+  comment: {
+    domainName: 'comments',
+    eventName: 'v3/comment.isflagbyme',
+    primaryKey: 'commentId',
+  },
+  message: {
+    domainName: 'messages',
+    eventName: 'v3/message.isFlaggedByMe',
+    primaryKey: 'messageId',
+  },
+  user: {
+    domainName: 'users',
+    eventName: 'user.isFlagByMe',
+    primaryKey: 'userId',
+  },
+}

package/src/role/api/getRole.ts

@@ -0,0 +1,53 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { decorateModels } from '~/core/query'
+
+/**
+ * ```js
+ * import { getRole } from '@amityco/ts-sdk'
+ * const role = await getRole('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Role} object
+ *
+ * @param roleId the ID of the {@link Amity.Role} to fetch
+ * @returns the associated {@link Amity.Role} object
+ *
+ * @category Role API
+ * @async
+ */
+export const getRole = async (roleId: Amity.Role['roleId']) => {
+  const client = getActiveClient()
+  client.log('role/getRole', roleId)
+
+  const { data } = await client.http.get<Amity.Role[]>(
+    `/api/v3/roles/${roleId}`
+  )
+
+  decorateModels(data)
+  ingestInCache({ roles: data })
+
+  return data.find(role => role.roleId === roleId)!
+}
+
+/**
+ * ```js
+ * import { getRole } from '@amityco/ts-sdk'
+ * const role = getRole.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Role} object from cache
+ *
+ * @param roleId the ID of the {@link Amity.Role} to fetch
+ * @returns the associated {@link Amity.Role} object
+ *
+ * @category Role API
+ */
+getRole.locally = (roleId: Amity.Role['roleId']) => {
+  const client = getActiveClient()
+  client.log('role/getRole.locally', roleId)
+
+  const [role] = pullFromCache('role', roleId) ?? []
+  return role
+}

package/src/role/api/index.ts

@@ -0,0 +1,2 @@
+export { queryRoles } from './queryRoles'
+export { getRole } from './getRole'

package/src/role/api/queryRoles.ts

@@ -0,0 +1,79 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload, toPage, toToken } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+import { toRecord } from '~/core/model'
+
+/**
+ * ```js
+ * import { queryRoles } from '@amityco/ts-sdk'
+ * const roles = await queryRoles()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Role} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Role} objects
+ *
+ * @category Role API
+ * @async
+ */
+export const queryRoles = async (query?: {
+  displayName?: Amity.Role['displayName']
+  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated'
+  page?: Amity.Page
+}) => {
+  const client = getActiveClient()
+  client.log('role/queryRoles', query)
+
+  const { page, displayName, sortBy, ...params } = query ?? {}
+
+  // API-FIX: parameters should be querystring.
+  const { data } = await client.http.get<Amity.RolePayload & Amity.Pagination>(
+    `/api/v3/roles`,
+    {
+      params: {
+        ...params,
+        keyword: displayName,
+        sortBy,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    }
+  )
+
+  // unpacking
+  const { paging, ...response } = data
+
+  decoratePayload(response as unknown as Record<string, any[]>)
+  ingestInCache(response as unknown as Record<string, any[]>)
+
+  const prevPage = toPage(paging.previous)
+  const nextPage = toPage(paging.next)
+
+  const { roles } = response
+  return { data: toRecord(roles), prevPage, nextPage }
+}
+
+/**
+ * ```js
+ * import { queryRoles } from '@amityco/ts-sdk'
+ * const roles = queryRoles.locally({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Role} objects from cache
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Role} objects
+ *
+ * @category Role API
+ */
+queryRoles.locally = (query: Parameters<typeof queryRoles>[0]) => {
+  const client = getActiveClient()
+  client.log('role/queryRoles.locally', query)
+
+  // TODO
+}

package/src/stream/api/createStream.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api'
+
+import { unwrapPayload } from '~/core/transports'
+
+/**
+ * ```js
+ * import { createStream } from '@amityco/ts-sdk'
+ * const created = await createStream({ title: 'my stream', 'thumbnailFileId': fileId  })
+ * ```
+ *
+ * Creates an {@link Amity.Stream}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Stream}
+ * @returns The newly created {@link Amity.Stream}
+ *
+ * @category Stream API
+ * @async
+ */
+export const createStream = async (
+  bundle: Pick<Amity.Stream, 'title' | 'thumbnailFileId' | 'description'> & { isSecure?: boolean }
+) => {
+  const client = getActiveClient()
+  client.log('stream/createStream', bundle)
+
+  const { data } = await client.http.post<Amity.Response<Amity.StreamPayload>>(
+    '/api/v3/video-streaming/', bundle,
+  )
+
+  // TODO:
+
+  const { videoStreamings } = unwrapPayload(data)
+  return videoStreamings[0]!
+}

package/src/stream/api/deleteStream.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api'
+
+import { getStream } from './getStream'
+
+import { unwrapPayload } from '~/core/transports'
+
+/**
+ * ```js
+ * import { deleteStream } from '@amityco/ts-sdk'
+ * const success = await deleteStream(streamId)
+ * ```
+ *
+ * Deletes a {@link Amity.Stream}
+ *
+ * @param streamId The {@link Amity.Stream} ID to delete
+ * @return A success boolean if the {@link Amity.Stream} was deleted
+ *
+ * @category Stream API
+ * @async
+ */
+export const deleteStream = async (
+  streamId: Amity.Stream['streamId'],
+) => {
+  const client = getActiveClient()
+  client.log('stream/deleteStream', streamId)
+
+  const { data } = await client.http.delete<Amity.Response<{ success: boolean }>>(
+    `/api/v3/video-streaming/${streamId}`
+  )
+
+  // TODO:
+
+  const { success } = unwrapPayload(data)
+
+  const deleted = await getStream(streamId)
+
+  return deleted
+}

package/src/stream/api/getStream.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api'
+
+import { unwrapPayload } from '~/core/transports'
+
+/**
+ * ```js
+ * import { getStream } from '@amityco/ts-sdk'
+ * const stream = await getStream(streamId)
+ * ```
+ *
+ * Fetches a {@link Amity.Stream} object
+ * @category Stream API
+ * @async
+ */
+export const getStream = async (
+  streamId: Amity.Stream['streamId'],
+) => {
+  const client = getActiveClient()
+  client.log('stream/getStream', streamId)
+
+  const { data } = await client.http.get<Amity.Response<Amity.StreamPayload>>(
+    `/api/v3/video-streaming/${streamId}`
+  )
+
+  // TODO:
+
+  const { videoStreamings } = unwrapPayload(data)
+  return videoStreamings.find(stream => stream.streamId === streamId)!
+}

package/src/stream/api/index.ts

@@ -0,0 +1,7 @@
+export * from './getStream'
+// export * from './getStreams' // API-FIX: missing from api
+export * from './queryStreams'
+
+export * from './createStream'
+export * from './updateStream'
+export * from './deleteStream'

package/src/stream/api/queryStreams.ts

@@ -0,0 +1,44 @@
+import { getActiveClient } from '~/client/api'
+
+import { unwrapPayload } from '~/core/transports'
+
+/**
+ * ```js
+ * import { queryStreams } from '@amityco/ts-sdk'
+ * const streams = await queryStreams(query)
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Stream} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Stream} objects
+ *
+ * @category Stream API
+ * @async
+ */
+export const queryStreams = async (
+  query?: {
+    isLive?: boolean
+    statuses?: Amity.StreamStatus[]
+    userPublicIds?: Amity.User['userId'][]
+    sortBy: 'lastCreated'
+    isDeleted?: Amity.Stream['isDeleted']
+    page?: Amity.Page
+  }
+) => {
+  const client = getActiveClient()
+  client.log('stream/queryStreams', query)
+
+  const { page, ...params } = query ?? {}
+
+  const { data } = await client.http.get<
+    Amity.Response<Amity.StreamPayload & Amity.Pagination>
+  >(`/api/v3/video-streaming`, { params })
+
+  // TODO:
+
+  // unpacking
+  const { videoStreamings: streams, paging } = unwrapPayload(data)
+
+  return streams
+}