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

package/src/comment/events/onCommentReactionAdded.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { createEventSubscriber } from '~/core/events'
+import { preparePayloadForCache } from '~/reaction/utils'
+
+/**
+ * ```js
+ * import { onCommentReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onCommentReactionAdded(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been reacted
+ *
+ * @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 onCommentReactionAdded = (
+  callback: Amity.Listener<Amity.Comment>
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reaction }) => {
+    if (!client.cache) {
+      callback(payload.comments[0])
+    } else {
+      preparePayloadForCache('comment.addReaction', payload)
+      const { reactor, ...commentPayload } = payload;
+
+      ingestInCache(commentPayload as Amity.CommentPayload)
+
+      const comment = pullFromCache<Amity.Comment>(['comment', 'get', payload.comments[0].commentId])!
+
+      callback(comment.data)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    'comment.addReaction',
+    'comment.addReaction',
+    filter
+  )
+}

package/src/comment/events/onCommentReactionRemoved.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { createEventSubscriber } from '~/core/events'
+import { preparePayloadForCache } from '~/reaction/utils'
+
+/**
+ * ```js
+ * import { onCommentReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onCommentReactionRemoved(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Comment}
+ *
+ * @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 onCommentReactionRemoved = (
+  callback: Amity.Listener<Amity.Comment>
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reaction }) => {
+    if (!client.cache) {
+      callback(payload.comments[0])
+    } else {
+      preparePayloadForCache('comment.removeReaction', payload)
+      const { reactor, ...commentPayload } = payload;
+
+      ingestInCache(commentPayload as Amity.CommentPayload)
+
+      const comment = pullFromCache<Amity.Comment>(['comment', 'get', payload.comments[0].commentId])!
+
+      callback(comment.data)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    'comment.removeReaction',
+    'comment.removeReaction',
+    filter
+  )
+}

package/src/comment/events/onCommentUnflagged.ts

@@ -0,0 +1,21 @@
+import { createCommentEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onCommentUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onCommentUnflagged(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Comment}
+ *
+ * @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 onCommentUnflagged = (
+  callback: Amity.Listener<Amity.Comment>
+): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.unflagged', callback)

package/src/comment/events/onCommentUpdated.ts

@@ -0,0 +1,21 @@
+import { createCommentEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onCommentUpdated } from '@amityco/ts-sdk'
+ * const dispose = onCommentUpdated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@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 = (
+  callback: Amity.Listener<Amity.Comment>
+): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.updated', callback)

package/src/comment/events/utils.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+import { queryCache, upsertInCache, pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+export const createCommentEventSubscriber = (
+  event: keyof Amity.MqttCommentMessageEvents,
+  callback: Amity.Listener<Amity.Comment>
+) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommentPayload) => {
+    if (!client.cache) {
+      // TODO: here we are missing specific properties here!
+      callback(payload.comments[0])
+    } else {
+      ingestInCache(payload)
+
+      const comment = pullFromCache<Amity.Comment>(['comment', 'get', payload.comments[0].commentId])!
+
+      if (['comment.created'].includes(event)) {
+        const queries = queryCache(['comment', 'query'])
+          // @ts-ignore
+          ?.filter(({key}) => key[2]?.referenceId === comment.data.referenceId);
+
+        queries?.map(({key, data}) => upsertInCache(key, data as any, { cachedAt: -1 }));
+      }
+
+      callback(comment.data)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    event,
+    event,
+    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,85 @@
+import { getActiveClient } from '~/client/api'
+
+import { createQuery, runQuery, queryOptions } from '~/core/query'
+
+import { getComment } from '../api'
+
+import {
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} 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', 'onFlagged', 'onUnflagged', 'onReactionAdded', 'onReactionRemoved']>(
+  commentId: string,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Comment | undefined>, 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.Snapshot<Amity.Comment | undefined>,
+    action: Events[number]
+  ) => {
+    if (callback instanceof Function) return callback(result)
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result)
+
+    callback[action]?.(result)
+  }
+
+  const realtimeRouter = (
+    result: Amity.Snapshot<Amity.Comment>,
+    action: Events[number]
+  ) => {
+    if (result.data?.commentId !== commentId) return
+
+    router(result, action)
+  }
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  disposers.push(
+    onCommentUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onCommentDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onCommentFlagged(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onFlagged')),
+    onCommentUnflagged(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUnflagged')),
+    onCommentReactionAdded(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionAdded')),
+    onCommentReactionRemoved(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionRemoved')),
+  )
+
+  runQuery(
+    createQuery(getComment, commentId),
+    result => (result.data || result.error) && router(result, 'onFetch'),
+    queryOptions(policy)
+  )
+
+  return () => {
+    log(`observeComment(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/comment/observers/observeComments.ts

@@ -0,0 +1,69 @@
+import { getActiveClient } from '~/client/api'
+
+import {
+  onCommentCreated,
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} 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', 'onFlagged', 'onUnflagged', 'onReactionAdded', 'onReactionRemoved']
+  >
+): 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' | 'onFlagged' | 'onUnflagged' | 'onReactionAdded' | 'onReactionRemoved'
+  ) => {
+    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')),
+    onCommentFlagged(comment => router(comment, 'onFlagged')),
+    onCommentUnflagged(comment => router(comment, 'onUnflagged')),
+    onCommentReactionAdded(comment => router(comment, 'onReactionAdded')),
+    onCommentReactionRemoved(comment => router(comment, 'onReactionRemoved')),
+  )
+
+  return () => {
+    log(`observeComments(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/community/api/addCommunityMembers.ts

@@ -0,0 +1,43 @@
+import { getActiveClient } from '~/client/api'
+
+import { fireEvent } from '~/core/events'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```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'][]
+): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('community/addCommunityMembers', communityId, userIds)
+
+  const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/users`,
+    { communityId, userIds }
+  )
+
+  if (client.cache) ingestInCache(data)
+
+  fireEvent('community.userAdded', data)
+
+  const { communityUsers } = data
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId &&
+      communityUser.communityMembership === 'member'
+  )
+}

package/src/community/api/addCommunityMembersRole.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```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'][]
+): Promise<boolean> => {
+  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 }
+  )
+
+  if (client.cache) 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,46 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+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
+  }): Promise<Amity.Cached<Amity.Community>> => {
+  const client = getActiveClient()
+  client.log('user/createCommunity', bundle)
+
+  const { data } = await client.http.post<Amity.CommunityPayload>(
+    '/api/v3/communities/', bundle,
+  )
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+
+  fireEvent('community.created', data)
+
+  const { communities } = data
+  return {
+    data: communities[0],
+    cachedAt,
+  }
+}

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'],
+): Promise<Amity.Community> => {
+  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('community.deleted', { communities: [deleted.data] })
+
+  return deleted.data
+}

package/src/community/api/getCommunities.ts

@@ -0,0 +1,76 @@
+import { getActiveClient } from '~/client/api'
+
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```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'][]
+): Promise<Amity.Cached<Amity.Community[]>> => {
+  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 } },
+  )
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+
+  return {
+    data: data.communities,
+    cachedAt
+  }
+}
+
+/**
+ * ```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'][]
+): Amity.Cached<Amity.Community[]> | undefined => {
+  const client = getActiveClient()
+  client.log('community/getCommunities.locally', communityIds)
+
+  if (!client.cache) return
+
+  const cached = communityIds
+    .map(communityId => pullFromCache<Amity.Community>(['community', 'get', communityId])!)
+    .filter(Boolean)
+
+  const communities = cached.map(({ data }) => data)
+  const oldest = cached.sort((a, b) => a.cachedAt! < b.cachedAt! ? -1 : 1)?.[0]
+
+  if (cached?.length < communityIds.length)
+    return
+
+  return {
+    data: communities,
+    cachedAt: oldest.cachedAt,
+  }
+}

package/src/community/api/getCommunity.ts

@@ -0,0 +1,72 @@
+import { getActiveClient } from '~/client/api'
+
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```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']
+): Promise<Amity.Cached<Amity.Community>> => {
+  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}`,
+  )
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+
+  const { communities } = data
+
+  return {
+    data: communities.find(community => community.communityId === communityId)!,
+    cachedAt,
+  }
+}
+
+/**
+ * ```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']
+): Amity.Cached<Amity.Community> | undefined => {
+  const client = getActiveClient()
+  client.log('community/getCommunity.locally', communityId)
+
+  if (!client.cache) return
+
+  const cached = pullFromCache<Amity.Community>(['community', 'get', communityId])
+
+  if (!cached)
+    return
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  }
+}

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'