@amityco/ts-sdk 0.0.1-02f0fa3.0

package/src/comment/api/updateComment.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { updateComment } from '@amityco/ts-sdk'
+ * const updated = await updateComment(commentId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Comment}
+ *
+ * @param commentId The ID of the {@link Amity.Comment} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Comment} object
+ *
+ * @category Comment API
+ * @async
+ */
+export const updateComment = async (
+  commentId: Amity.Comment['commentId'],
+  patch: Patch<Amity.Comment, 'data' | 'metadata'>,
+) => {
+  const client = getActiveClient()
+  client.log('user/updateComment', patch)
+
+  const { data } = await client.http.put<Amity.CommentPayload>(
+    `/api/v3/comments/${commentId}`, patch,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  fireEvent('v3.comment.didUpdate', data)
+
+  const { comments } = data
+  return comments.find(comment => comment.commentId === commentId)!
+}

package/src/comment/events/index.ts

@@ -0,0 +1,3 @@
+export * from './onCommentCreated'
+export * from './onCommentUpdated'
+export * from './onCommentDeleted'

package/src/comment/events/onCommentCreated.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onCommentCreated } from '@amityco/ts-sdk'
+ * const dispose = onCommentCreated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Comment} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentCreated = <T extends Amity.CommentContentType>(
+  callback: Amity.Listener<Amity.Comment<T>>
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommentPayload<T>) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.comments[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'message/onCommentCreated',
+    'v3.comment.didCreate',
+    filter
+  )
+}

package/src/comment/events/onCommentDeleted.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onCommentDeleted } from '@amityco/ts-sdk'
+ * const dispose = onCommentDeleted(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Comment} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentDeleted = <T extends Amity.CommentContentType>(
+  callback: Amity.Listener<Amity.Comment<T>>
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommentPayload<T>) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.comments[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'message/onCommentDeleted',
+    'v3.comment.didDelete',
+    filter
+  )
+}

package/src/comment/events/onCommentUpdated.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onCommentUpdated } from '@amityco/ts-sdk'
+ * const dispose = onCommentUpdated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Comment} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentUpdated = <T extends Amity.CommentContentType>(
+  callback: Amity.Listener<Amity.Comment<T>>
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommentPayload<T>) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.comments[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'message/onCommentUpdated',
+    'v3.comment.didUpdate',
+    filter
+  )
+}

package/src/comment/observers/index.ts

@@ -0,0 +1,2 @@
+export * from './observeComments'
+export * from './observeComment'

package/src/comment/observers/observeComment.ts

@@ -0,0 +1,73 @@
+import { getActiveClient } from '~/client/api'
+
+import { createQuery, runQuery, queryOptions } from '~/core/query'
+
+import { getComment } from '../api'
+
+import {
+  onCommentUpdated,
+  onCommentDeleted,
+} from '../events'
+
+
+/**
+ * ```js
+ * import { observeComment } from '@amityco/ts-sdk'
+ *
+ * let comment = {}
+ * const dispose = observeComment(commentId, ({ data }) => comment = data)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Comment}
+ *
+ * @param commentId the ID of the comment to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
+ *
+ * @category Comment Observer
+ */
+export const observeComment = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
+  commentId: string,
+  callback: Amity.ObjectListener<Amity.QueryResult<Amity.Comment>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server',
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient()
+
+  const timestamp = Date.now()
+  log(`observeComment(tmpid: ${timestamp}) > listen`)
+
+  // wrapper function to make sure
+  const router = (
+    result: Amity.QueryResult<Amity.Comment>,
+    action: Events[number]
+  ) => {
+    // filter function
+    if (result.data?.commentId !== commentId) return
+
+    if (callback instanceof Function)
+      return callback(result)
+
+    if (action !== 'onFetch')
+      callback.onEvent?.(action, result)
+
+    callback[action]?.(result)
+  }
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  disposers.push(
+    onCommentUpdated(data => router({ data }, 'onUpdate')),
+    onCommentDeleted(data => router({ data }, 'onDelete')),
+  )
+
+  runQuery(
+    createQuery(getComment, commentId),
+    result => result.data && router(result, 'onFetch'),
+    queryOptions(policy)
+  )
+
+  return () => {
+    log(`observeComment(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/comment/observers/observeComments.ts

@@ -0,0 +1,61 @@
+import { getActiveClient } from '~/client/api'
+
+import {
+  onCommentCreated,
+  onCommentUpdated,
+  onCommentDeleted,
+} from '../events'
+
+/**
+ * ```js
+ * import { observeComments } from '@amityco/ts-sdk'
+ *
+ * let comments = []
+ * const unsub = observeComments(postId, comment => merge(comments, comment))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Comment} for a given {@link Amity.Post} object
+ *
+ * @param postId the ID of the post where to observe the comments
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comments
+ *
+ * @category Comment Observer
+ */
+export const observeComments = (
+  postId: Amity.Post['postId'],
+  callback: Amity.ObjectListener<
+    Amity.Comment,
+    ['onCreate', 'onUpdate', 'onDelete']
+  >
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient()
+
+  const timestamp = Date.now()
+  log(`observeComments(tmpid: ${timestamp}) > listen`)
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  const router = (
+    comment: Amity.Comment,
+    action: 'onCreate' | 'onUpdate' | 'onDelete'
+  ) => {
+    if (comment.referenceId !== postId) return
+
+    if (callback instanceof Function) return callback(comment)
+
+    callback.onEvent?.(action, comment)
+    callback[action]?.(comment)
+  }
+
+  disposers.push(
+    onCommentCreated(comment => router(comment, 'onCreate')),
+    onCommentUpdated(comment => router(comment, 'onUpdate')),
+    onCommentDeleted(comment => router(comment, 'onDelete'))
+  )
+
+  return () => {
+    log(`observeComments(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/community/api/addCommunityMembers.ts

@@ -0,0 +1,46 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { addCommunityMembers } from '@amityco/ts-sdk'
+ * const updated = await addCommunityMembers(communityId, ['foo', 'bar'])
+ * ```
+ *
+ * Adds a list of {@link Amity.User} to a {@link Amity.Community} to add users to
+ *
+ * @param communityId The ID of the {@link Amity.Community} to perform
+ * @param userIds The list of IDs {@link Amity.User} to add
+ * @returns A success boolean if the {@link Amity.User} were added to the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const addCommunityMembers = async (
+  communityId: Amity.Community['communityId'],
+  userIds: Amity.User['userId'][]
+) => {
+  const client = getActiveClient()
+  client.log('community/addCommunityMembers', communityId, userIds)
+
+  const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/users`,
+    { communityId, userIds }
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  fireEvent('v3.community.didAddUsers', {
+    communities: data.communities!,
+  })
+
+  const { communityUsers } = data
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId &&
+      communityUser.communityMembership === 'member'
+  )
+}

package/src/community/api/addCommunityMembersRole.ts

@@ -0,0 +1,43 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { addCommunityMembersRole } from '@amityco/ts-sdk'
+ * const updated = await addCommunityMembersRole(communityId, 'foo', ['bar'])
+ * ```
+ *
+ * Adds an {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to perform
+ * @param roleId The ID of the {@link Amity.Role} to apply
+ * @param userId Array of IDs of the {@link Amity.User} to perform
+ * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.User} in the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const addCommunityMembersRole = async (
+  communityId: Amity.Community['communityId'],
+  roleId: Amity.Role['roleId'],
+  userIds: Amity.User['userId'][]
+) => {
+  const client = getActiveClient()
+  client.log('community/addCommunityMembersRole', communityId, roleId, userIds)
+
+  const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/users/roles`,
+    { communityId, role: roleId, userIds }
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  const { communityUsers } = data
+  return !!communityUsers.find(
+    communityUser =>
+    communityUser.communityId === communityId && communityUser.roles.includes(roleId)
+  )
+}

package/src/community/api/createCommunity.ts

@@ -0,0 +1,43 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { createCommunity } from '@amityco/ts-sdk'
+ * const created = await createCommunity({ communityId: 'foobar', displayName: 'foobar' })
+ * ```
+ *
+ * Creates an {@link Amity.Community}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Community}
+ * @returns The newly created {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const createCommunity = async (
+  bundle: Pick<
+    Amity.Community,
+    'displayName' | 'avatarFileId' | 'description' | 'isPublic' | 'isOfficial' | 'onlyAdminCanPost' | 'needApprovalOnPostCreation' | 'tags' | 'metadata'
+  > & {
+    userIds?: string[]
+    categoryIds?: string[]
+    isUniqueDisplayName?: boolean
+  }) => {
+  const client = getActiveClient()
+  client.log('user/createCommunity', bundle)
+
+  const { data } = await client.http.post<Amity.CommunityPayload>(
+    '/api/v3/communities/', bundle,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  fireEvent('v3.community.didCreate', data)
+
+  const { communities } = data
+  return communities[0]
+}

package/src/community/api/deleteCommunity.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api'
+
+import { fireEvent } from '~/core/events'
+import { getCommunity } from './getCommunity'
+
+/**
+ * ```js
+ * import { deleteCommunity } from '@amityco/ts-sdk'
+ * const success = await deleteCommunity('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Community}
+ *
+ * @param communityId The {@link Amity.Community} ID to delete
+ * @return A success boolean if the {@link Amity.Community} was deleted
+ *
+ * @category Community API
+ * @async
+ */
+export const deleteCommunity = async (
+  communityId: Amity.Community['communityId'],
+) => {
+  const client = getActiveClient()
+  client.log('community/deleteCommunity', communityId)
+
+  // API-FIX: This endpoint has not been implemented yet.
+  await client.http.delete<{ success: boolean }>(
+    `/api/v3/communities/${communityId}`,
+  )
+
+  const deleted = await getCommunity(communityId)
+  fireEvent('v3.community.didDelete', { communities: [deleted] })
+
+  return deleted
+}

package/src/community/api/getCommunities.ts

@@ -0,0 +1,63 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { toRecord } from '~/core/model'
+
+/**
+ * ```js
+ * import { getCommunities } from '@amityco/ts-sdk'
+ * const communities = await getCommunities(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Community} objects
+ *
+ * @param communityIds the IDs of the {@link Amity.Community} to fetch
+ * @returns the associated collection of {@link Amity.Community} objects
+ *
+ * @category Community API
+ * @async
+ */
+export const getCommunities = async (
+  communityIds: Amity.Community['communityId'][]
+) => {
+  const client = getActiveClient()
+  client.log('community/getCommunities', communityIds)
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.CommunityPayload>(
+    `/api/v3/communities/list`,
+    { params: { communityIds } },
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  const { communities } = data
+  return toRecord(communities)
+}
+
+/**
+ * ```js
+ * import { getCommunities } from '@amityco/ts-sdk'
+ * const communities = getCommunities.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Community} objects from cache
+ *
+ * @param communityIds the IDs of the {@link Amity.Community} to fetch
+ * @returns the associated collection of {@link Amity.Community} objects
+ *
+ * @category Community API
+ */
+getCommunities.locally = (
+  communityIds: Amity.Community['communityId'][]
+) => {
+  const client = getActiveClient()
+  client.log('community/getCommunities.locally', communityIds)
+
+  const cached = pullFromCache('community', ...communityIds) ?? []
+
+  if (cached?.length === communityIds.length)
+    return toRecord(cached)
+}

package/src/community/api/getCommunity.ts

@@ -0,0 +1,58 @@
+import { getActiveClient } from '~/client/api'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { decoratePayload } from '~/core/query'
+
+/**
+ * ```js
+ * import { getCommunity } from '@amityco/ts-sdk'
+ * const community = await getCommunity('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Community} object
+ *
+ * @param communityId the ID of the {@link Amity.Community} to fetch
+ * @returns the associated {@link Amity.Community} object
+ *
+ * @category Community API
+ * @async
+ */
+export const getCommunity = async (
+  communityId: Amity.Community['communityId']
+) => {
+  const client = getActiveClient()
+  client.log('community/getCommunity', communityId)
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.CommunityPayload>(
+    `/api/v3/communities/${communityId}`,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  const { communities } = data
+  return communities.find(community => community.communityId === communityId)!
+}
+
+/**
+ * ```js
+ * import { getCommunity } from '@amityco/ts-sdk'
+ * const community = getCommunity.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Community} object from cache
+ *
+ * @param communityId the ID of the {@link Amity.Community} to fetch
+ * @returns the associated {@link Amity.Community} object
+ *
+ * @category Community API
+ */
+getCommunity.locally = (
+  communityId: Amity.Community['communityId']
+) => {
+  const client = getActiveClient()
+  client.log('community/getCommunity.locally', communityId)
+
+  const [community] = pullFromCache('community', communityId) ?? []
+  return community
+}

package/src/community/api/index.ts

@@ -0,0 +1,17 @@
+export * from './queryCommunities'
+export * from './getCommunities'
+export * from './getCommunity'
+
+export * from './createCommunity'
+export * from './updateCommunity'
+export * from './deleteCommunity'
+
+export * from './joinCommunity'
+export * from './leaveCommunity'
+
+export * from './queryCommunityMembers'
+export * from './addCommunityMembers'
+export * from './removeCommunityMembers'
+
+export * from './addCommunityMembersRole'
+export * from './removeCommunityMembersRole'

package/src/community/api/joinCommunity.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { joinCommunity } from '@amityco/ts-sdk'
+ * const isJoined = await joinCommunity('foobar')
+ * ```
+ *
+ * Joins a {@link Amity.Community} object
+ *
+ * @param communityId the {@link Amity.Community} to join
+ * @returns A success boolean if the {@link Amity.Community} was joined
+ *
+ * @category Community API
+ * @async
+ */
+export const joinCommunity = async (communityId: Amity.Community['communityId']) => {
+  const client = getActiveClient()
+  client.log('community/joinCommunity', communityId)
+
+  const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/join`,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  fireEvent('v3.community.didJoin', {
+    communities: data.communities!
+  })
+
+  const { communityUsers } = data
+
+  return !!communityUsers.find(communityUser => (
+    communityUser.communityId === communityId
+    && communityUser.communityMembership === 'member'
+  ))
+}