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

package/src/post/events/onPostUpdated.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostUpdated } from '@amityco/ts-sdk'
+ * const dispose = onPostUpdated(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostUpdated = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.updated', callback)

package/src/post/events/utils.ts

@@ -0,0 +1,49 @@
+import { getActiveClient } from '~/client/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { createEventSubscriber, fireEvent } from '~/core/events'
+import { queryCache, upsertInCache, pullFromCache } from '~/cache/api'
+
+export const createPostEventSubscriber = (
+  event: keyof Amity.MqttPostMessageEvents,
+  callback: Amity.Listener<Amity.Post>
+) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.PostPayload) => {
+    if (!client.cache) {
+      callback(payload.posts[0])
+    } else {
+      const { communities, ...others } = payload
+
+      ingestInCache(others as Amity.PostPayload)
+
+      if (communities?.[0] && !['post.updated'].includes(event)) {
+        fireEvent('community.updated', { communities })
+      }
+
+      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!
+
+      if (['post.created', 'post.approved', 'post.declined'].includes(event)) {
+        let queries = queryCache(['post', 'query'])
+          // @ts-ignore
+          ?.filter(({key}) => key[2]?.targetId === post.data.targetId);
+
+        if (event === 'post.declined') {
+          // @ts-ignore
+          queries = queries?.filter(({key}) => key[2]?.feedType === 'reviewing');
+        }
+
+        queries?.map(({key, data}) => upsertInCache(key, data as any, { cachedAt: -1 }));
+      }
+
+      callback(post.data)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    event,
+    event,
+    filter
+  )
+}

package/src/post/observers/index.ts

@@ -0,0 +1,2 @@
+export * from './observePosts'
+export * from './observePost'

package/src/post/observers/observePost.ts

@@ -0,0 +1,88 @@
+import { getActiveClient } from '~/client/api'
+
+import { createQuery, runQuery, queryOptions } from '~/core/query'
+
+import { getPost } from '../api'
+
+import {
+  onPostUpdated,
+  onPostDeleted,
+  onPostApproved,
+  onPostDeclined,
+  onPostFlagged,
+  onPostUnflagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
+} from '../events'
+
+/**
+ * ```js
+ * import { observePost } from '@amityco/ts-sdk'
+ *
+ * let post = {}
+ * const dispose = observePost(postId, updated => post = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Post}
+ *
+ * @param postId the ID of the post 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 post
+ *
+ * @category Post Observer
+ */
+export const observePost = <Events extends ['onFetch', 'onUpdate', 'onDelete', 'onApproved', 'onDeclined', 'onFlagged', 'onUnflagged', 'onReactionAdded', 'onReactionRemoved']>(
+  postId: string,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Post | undefined>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server'
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient()
+
+  const timestamp = Date.now()
+  log(`observePost(tmpid: ${timestamp}) > listen`)
+
+  // wrapper function to make sure
+  const router = (
+    result: Amity.Snapshot<Amity.Post | 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.Post>,
+    action: Events[number]
+  ) => {
+    if (result.data?.postId !== postId) return
+
+    router(result, action)
+  }
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  disposers.push(
+    onPostUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onPostDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onPostApproved(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onApproved')),
+    onPostDeclined(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDeclined')),
+    onPostFlagged(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onFlagged')),
+    onPostUnflagged(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUnflagged')),
+    onPostReactionAdded(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionAdded')),
+    onPostReactionRemoved(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionRemoved')),
+  )
+
+  runQuery(
+    createQuery(getPost, postId),
+    result => (result.data || result.error) && router(result, 'onFetch'),
+    queryOptions(policy),
+  )
+
+  return () => {
+    log(`observePosts(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/post/observers/observePosts.ts

@@ -0,0 +1,76 @@
+import { getActiveClient } from '~/client/api'
+
+import {
+  onPostCreated,
+  onPostUpdated,
+  onPostDeleted,
+  onPostApproved,
+  onPostDeclined,
+  onPostFlagged,
+  onPostUnflagged, onPostReactionAdded, onPostReactionRemoved
+} from '../events'
+
+/**
+ * ```js
+ * import { observePosts } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsub = observePosts({
+ *   targetType: Amity.PostTargetType,
+ *   targetId: Amity.Post['targetId'],
+ * }, post => merge(posts, post))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given target object
+ *
+ * @param targetType the type of the target
+ * @param targetId the ID of the target
+ * @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 messages
+ *
+ * @category Post Observer
+ */
+export const observePosts = (params: {
+    targetType: Amity.PostTargetType,
+    targetId: Amity.Post['targetId'],
+  },
+  callback: Amity.ObjectListener<Amity.Post, ['onCreate', 'onUpdate', 'onDelete', 'onApproved', 'onDeclined', 'onFlagged', 'onUnflagged', 'onReactionAdded', 'onReactionRemoved']>
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient()
+
+  const timestamp = Date.now()
+  log(`observePosts(tmpid: ${timestamp}) > listen`)
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  const router = (
+    post: Amity.Post,
+    action: 'onCreate' | 'onUpdate' | 'onDelete' | 'onApproved' | 'onDeclined' | 'onFlagged' | 'onUnflagged' | 'onReactionAdded' | 'onReactionRemoved'
+  ) => {
+    if (params.targetId !== post.targetId
+      || params.targetType !== post.targetType)
+      return
+
+    if (callback instanceof Function) return callback(post)
+
+    callback.onEvent?.(action, post)
+    callback[action]?.(post)
+  }
+
+  disposers.push(
+    onPostCreated(post => router(post, 'onCreate')),
+    onPostUpdated(post => router(post, 'onUpdate')),
+    onPostDeleted(post => router(post, 'onDelete')),
+    onPostApproved(post => router(post, 'onApproved')),
+    onPostDeclined(post => router(post, 'onDeclined')),
+    onPostFlagged(post => router(post, 'onFlagged')),
+    onPostUnflagged(post => router(post, 'onUnflagged')),
+    onPostReactionAdded(post => router(post, 'onReactionAdded')),
+    onPostReactionRemoved(post => router(post, 'onReactionRemoved')),
+  )
+
+  return () => {
+    log(`observePosts(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/reaction/api/addReaction.ts

@@ -0,0 +1,94 @@
+import { getActiveClient } from '~/client/api'
+
+import { upsertInCache, pullFromCache } from '~/cache/api'
+
+import { dispatchReactable, fetchReference } from '../utils'
+
+/**
+ * ```js
+ * import { addReaction } from '@amityco/ts-sdk'
+ * const success = await addReaction('post', postId, 'like')
+ * ```
+ *
+ * Creates an {@link Amity.Reaction}
+ *
+ * @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
+ * @async
+ **/
+export const addReaction = async (
+  referenceType: Amity.Reaction['referenceType'],
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reaction['reactionName']
+): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('reaction/createReaction', {
+    referenceId,
+    referenceType,
+    reactionName,
+  })
+
+  await client.http.post<{ addedId: 'string' }>(
+    '/api/v2/reactions',
+    { referenceId, referenceType, reactionName }
+  )
+
+  const model = await fetchReference(referenceType, referenceId)
+  dispatchReactable(referenceType, model.data)
+
+  return model.data.myReactions?.includes(reactionName) ?? false
+}
+
+/**
+ * ```js
+ * import { addReaction } from '@amityco/ts-sdk'
+ * const success = addReaction.optimistically('post', postId, 'like')
+ * ```
+ *
+ * Creates an {@link Amity.Reaction} 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
+ **/
+addReaction.optimistically = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reaction['reactionName']
+): boolean | undefined => {
+  const client = getActiveClient()
+  client.log('reaction/createReaction.optimistically', {
+    referenceId,
+    referenceType,
+    reactionName,
+  })
+
+  if (!client.cache) return
+
+  const model = pullFromCache<Amity.Model[Amity.ReactableType]>([referenceType, 'get', referenceId])
+
+  if (!model?.data || model.data.myReactions?.includes(reactionName)) return
+
+  const reaction = {
+    ...model.data,
+    reactionsCount: model.data.reactionsCount + 1,
+    myReactions: [...(model.data.myReactions ?? []), reactionName],
+    reactions: {
+      ...model.data.reactions,
+      [reactionName]: (model.data.reactions[reactionName] ?? 0) + 1,
+    },
+  } as Amity.Model[Amity.ReactableType]
+
+  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 })
+
+  dispatchReactable(referenceType, reaction)
+
+  return reaction?.myReactions?.includes(reactionName) ?? false
+}

package/src/reaction/api/index.ts

@@ -0,0 +1,2 @@
+export * from './addReaction'
+export * from './removeReaction'

package/src/reaction/api/removeReaction.ts

@@ -0,0 +1,94 @@
+import { getActiveClient } from '~/client/api'
+
+import { upsertInCache, pullFromCache } from '~/cache/api'
+
+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']
+): Promise<boolean> => {
+  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.data)
+
+  return !model.data.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']
+): boolean | undefined => {
+  const client = getActiveClient()
+  client.log('reaction/removeReaction.optimistically', {
+    referenceId,
+    referenceType,
+    reactionName,
+  })
+
+  if (!client.cache) return
+
+  const model = pullFromCache<Amity.Model[Amity.ReactableType]>([referenceType, 'get', referenceId])
+
+  if (!model?.data || !model.data.myReactions?.includes(reactionName)) return
+
+  const reaction = {
+    ...model.data,
+    reactionsCount: Math.max(0, model.data.reactionsCount - 1),
+    myReactions: (model.data.myReactions ?? []).filter(item => item !== reactionName),
+    reactions: {
+      ...model.data.reactions,
+      [reactionName]: Math.max(0, (model.data.reactions[reactionName] ?? 0) - 1),
+    },
+  } as Amity.Model[Amity.ReactableType]
+
+  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 })
+
+  dispatchReactable(referenceType, reaction)
+
+  return !reaction?.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,64 @@
+import { getActiveClient } from '~/client/api'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache} from '~/cache/api/ingestInCache'
+import { createEventSubscriber } from '~/core/events'
+import { getResolver } from '~/core/model'
+import { onPostReactionAdded } from '~/post/events'
+import { onCommentReactionAdded } from '~/comment/events'
+
+/**
+ * ```js
+ * import { onReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onReactionAdded('post', postId, post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reaction} has been added
+ *
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @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.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Model[typeof referenceType]>
+): Amity.Unsubscriber => {
+  const callbackWrapper = (model: Amity.Model[typeof referenceType]) => {
+    if (getResolver(referenceType)(model as any) === referenceId) {
+      callback(model)
+    }
+  }
+
+  if (referenceType === 'message') {
+    const client = getActiveClient()
+
+    const filter = (payload: Amity.MessagePayload) => {
+      const cached = pullFromCache<Amity.Message>(['message', 'get', payload.messages[0].messageId])
+      const isReactionEvent = cached?.data?.reactionsCount !== payload.messages[0].reactionsCount
+
+      ingestInCache(payload)
+
+      if (isReactionEvent) {
+        callbackWrapper(payload.messages[0])
+      }
+    }
+
+    return createEventSubscriber(
+      client,
+      'reaction/onReactionAdded',
+      'v3.message.didUpdate',
+      filter
+    )
+  }
+
+  if (referenceType === 'post') {
+    return onPostReactionAdded(callbackWrapper)
+  }
+
+  return onCommentReactionAdded(callbackWrapper)
+}

package/src/reaction/events/onReactionRemoved.ts

@@ -0,0 +1,64 @@
+import { getActiveClient } from '~/client/api'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { createEventSubscriber } from '~/core/events'
+import { getResolver } from '~/core/model'
+import { onPostReactionRemoved } from '~/post/events'
+import { onCommentReactionRemoved } from '~/comment/events'
+
+/**
+ * ```js
+ * import { onReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onReactionRemoved('post', postId, post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reaction} has been removed
+ *
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @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.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Model[typeof referenceType]>
+): Amity.Unsubscriber => {
+  const callbackWrapper = (model: Amity.Model[typeof referenceType]) => {
+    if (getResolver(referenceType)(model as any) === referenceId) {
+      callback(model)
+    }
+  }
+
+  if (referenceType === 'message') {
+    const client = getActiveClient()
+
+    const filter = (payload: Amity.MessagePayload) => {
+      const cached = pullFromCache<Amity.Message>(['message', 'get', payload.messages[0].messageId])
+      const isReactionEvent = cached?.data?.reactionsCount !== payload.messages[0].reactionsCount
+
+      ingestInCache(payload)
+
+      if (isReactionEvent) {
+        callbackWrapper(payload.messages[0])
+      }
+    }
+
+    return createEventSubscriber(
+      client,
+      'reaction/onReactionRemoved',
+      'v3.message.didUpdate',
+      filter
+    )
+  }
+
+  if (referenceType === 'post') {
+    return onPostReactionRemoved(callbackWrapper)
+  }
+
+  return onCommentReactionRemoved(callbackWrapper)
+}

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('post.updated', { posts: [model] })
+  else if (referenceType === 'comment')
+    // @ts-ignore: refactor later
+    fireEvent('comment.updated', { 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.Cached<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,3 @@
+export * from './dispatchReactable'
+export * from './fetchReference'
+export * from './preparePayloadForCache'

package/src/reaction/utils/preparePayloadForCache.ts

@@ -0,0 +1,45 @@
+import { pullFromCache } from '~/cache/api'
+import { getActiveClient } from '~/client/api'
+
+/** @hidden */
+export const preparePayloadForCache = <T extends 'post.addReaction' | 'post.removeReaction' | 'comment.addReaction' | 'comment.removeReaction'>(
+  event: T,
+  payload: Amity.Events[T],
+) => {
+  const client = getActiveClient()
+
+  if (client.userId !== payload.reactor.userId) {
+    return
+  }
+
+  let model: Amity.Reactable
+  let cached: Amity.Reactable | undefined
+
+  if (event === 'post.addReaction' || event === 'post.removeReaction') {
+    const post = (payload as Amity.Events['post.addReaction']).posts[0]
+    cached = pullFromCache<Amity.Post>(['post', 'get', post.postId])?.data
+    model = post
+  } else {
+    const comment = (payload as Amity.Events['comment.addReaction']).comments[0]
+    cached = pullFromCache<Amity.Comment>(['comment', 'get', comment.commentId])?.data
+    model = comment
+  }
+
+  if (!cached || !cached.myReactions) {
+    return
+  }
+
+  if (event === 'post.addReaction' || event === 'comment.addReaction') {
+    if (cached.myReactions.includes(payload.reactor.reactionName)) {
+      return
+    }
+
+    Object.assign(model, { myReactions: [...cached.myReactions, payload.reactor.reactionName] })
+  } else {
+    if (!cached.myReactions.includes(payload.reactor.reactionName)) {
+      return
+    }
+
+    Object.assign(model, { myReactions: cached.myReactions.filter(x => x !== payload.reactor.reactionName) })
+  }
+}