@amityco/ts-sdk 0.0.1-beta.8 → 0.0.1-beta.9

package/src/post/events/onPostFlagged.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostFlagged } from '@amityco/ts-sdk'
+ * const dispose = onPostFlagged(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been flagged
+ *
+ * @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 onPostFlagged = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.flagged', callback)

package/src/post/events/onPostReactionAdded.ts

@@ -0,0 +1,50 @@
+import { getActiveClient } from '~/client/api'
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { createEventSubscriber } from '~/core/events'
+import { preparePayloadForCache } from '~/reaction/utils'
+import { isMatch } from '~/core/model'
+
+/**
+ * ```js
+ * import { onPostReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionAdded(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been reacted
+ *
+ * @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 onPostReactionAdded = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.Events['post.addReaction']) => {
+    const [cached] = pullFromCache('post', payload.posts[0].postId) ?? []
+
+    const { reactor, ...postPayload } = payload;
+
+    decoratePayload(postPayload as Amity.PostPayload)
+    preparePayloadForCache('post.addReaction', payload)
+    ingestInCache(postPayload as Amity.PostPayload)
+
+    const [post] = pullFromCache('post', payload.posts[0].postId) ?? []
+
+    if (cached && isMatch(cached, post)) {
+      return
+    }
+
+    callback(post)
+  }
+
+  return createEventSubscriber(
+    client,
+    'post.addReaction',
+    'post.addReaction',
+    filter
+  )
+}

package/src/post/events/onPostReactionRemoved.ts

@@ -0,0 +1,50 @@
+import { getActiveClient } from '~/client/api'
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { createEventSubscriber } from '~/core/events'
+import { preparePayloadForCache } from '~/reaction/utils/preparePayloadForCache'
+import { isMatch } from '~/core/model'
+
+/**
+ * ```js
+ * import { onPostReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionRemoved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Post}
+ *
+ * @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 onPostReactionRemoved = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.Events['post.removeReaction']) => {
+    const [cached] = pullFromCache('post', payload.posts[0].postId) ?? []
+
+    const { reactor, ...postPayload } = payload;
+
+    decoratePayload(postPayload as Amity.PostPayload)
+    preparePayloadForCache('post.removeReaction', payload)
+    ingestInCache(postPayload as Amity.PostPayload)
+
+    const [post] = pullFromCache('post', payload.posts[0].postId) ?? []
+
+    if (cached && isMatch(cached, post)) {
+      return
+    }
+
+    callback(post)
+  }
+
+  return createEventSubscriber(
+    client,
+    'post.removeReaction',
+    'post.removeReaction',
+    filter
+  )
+}

package/src/post/events/onPostUnflagged.ts

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

package/src/post/events/onPostUpdated.ts

@@ -1,8 +1,4 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { createPostEventSubscriber } from './utils'
 
 /**
  * ```js
@@ -12,28 +8,12 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Post} has been updated
+ * 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 => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.PostPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.posts[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onPostUpdated',
-    'v3.post.didUpdate',
-    filter
-  )
-}
+export const onPostUpdated = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.updated', callback)

package/src/post/events/utils.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api'
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { createEventSubscriber, fireEvent } from '~/core/events'
+import { isMatch } from '~/core/model'
+
+export const createPostEventSubscriber = (
+  event: keyof Amity.MqttPostMessageEvents,
+  callback: Amity.Listener<Amity.Post>
+) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.PostPayload) => {
+    const [cached] = pullFromCache('post', payload.posts[0].postId) ?? []
+
+    const { communities, ...others } = payload
+
+    decoratePayload(others as Amity.PostPayload)
+    ingestInCache(others as Amity.PostPayload)
+
+    if (communities?.[0]) {
+      fireEvent('community.updated', { communities })
+    }
+
+    const [post] = pullFromCache('post', others.posts[0].postId) ?? []
+
+    if (cached && isMatch(cached, post)) {
+      return
+    }
+
+    callback(post)
+  }
+
+  return createEventSubscriber(
+    client,
+    event,
+    event,
+    filter
+  )
+}

package/src/post/observers/observePost.ts

@@ -7,6 +7,12 @@ import { getPost } from '../api'
 import {
   onPostUpdated,
   onPostDeleted,
+  onPostApproved,
+  onPostDeclined,
+  onPostFlagged,
+  onPostUnflagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
 } from '../events'
 
 /**
@@ -25,7 +31,7 @@ import {
  *
  * @category Post Observer
  */
-export const observePost = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
+export const observePost = <Events extends ['onFetch', 'onUpdate', 'onDelete', 'onApproved', 'onDeclined', 'onFlagged', 'onUnflagged', 'onReactionAdded', 'onReactionRemoved']>(
   postId: string,
   callback: Amity.ObjectListener<Amity.QueryResult<Amity.Post>, Events>,
   policy: Amity.QueryPolicy = 'cache_then_server',
@@ -40,9 +46,6 @@ export const observePost = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
     result: Amity.QueryResult<Amity.Post>,
     action: Events[number]
   ) => {
-    // filter function
-    if (result.data?.postId !== postId) return
-
     if (callback instanceof Function)
       return callback(result)
 
@@ -52,16 +55,31 @@ export const observePost = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
     callback[action]?.(result)
   }
 
+  const realtimeRouter = (
+    result: Amity.QueryResult<Amity.Post>,
+    action: Events[number]
+  ) => {
+    if (result.data?.postId !== postId) return
+
+    router(result, action)
+  }
+
   const disposers: Amity.Unsubscriber[] = []
 
   disposers.push(
-    onPostUpdated(data => router({ data }, 'onUpdate')),
-    onPostDeleted(data => router({ data }, 'onDelete')),
+    onPostUpdated(data => realtimeRouter({ data }, 'onUpdate')),
+    onPostDeleted(data => realtimeRouter({ data }, 'onDelete')),
+    onPostApproved(data => realtimeRouter({ data }, 'onApproved')),
+    onPostDeclined(data => realtimeRouter({ data }, 'onDeclined')),
+    onPostFlagged(data => realtimeRouter({ data }, 'onFlagged')),
+    onPostUnflagged(data => realtimeRouter({ data }, 'onUnflagged')),
+    onPostReactionAdded(data => realtimeRouter({ data }, 'onReactionAdded')),
+    onPostReactionRemoved(data => realtimeRouter({ data }, 'onReactionRemoved')),
   )
 
   runQuery(
     createQuery(getPost, postId),
-    (result) => result.data && router(result, 'onFetch'),
+    (result) => router(result, 'onFetch'),
     queryOptions(policy),
   )
 

package/src/post/observers/observePosts.ts

@@ -4,6 +4,10 @@ import {
   onPostCreated,
   onPostUpdated,
   onPostDeleted,
+  onPostApproved,
+  onPostDeclined,
+  onPostFlagged,
+  onPostUnflagged, onPostReactionAdded, onPostReactionRemoved
 } from '../events'
 
 /**
@@ -30,7 +34,7 @@ export const observePosts = (params: {
     targetType: Amity.PostTargetType,
     targetId: Amity.Post['targetId'],
   },
-  callback: Amity.ObjectListener<Amity.Post, ['onCreate', 'onUpdate', 'onDelete']>
+  callback: Amity.ObjectListener<Amity.Post, ['onCreate', 'onUpdate', 'onDelete', 'onApproved', 'onDeclined', 'onFlagged', 'onUnflagged', 'onReactionAdded', 'onReactionRemoved']>
 ): Amity.Unsubscriber => {
   const { log } = getActiveClient()
 
@@ -41,7 +45,7 @@ export const observePosts = (params: {
 
   const router = (
     post: Amity.Post,
-    action: 'onCreate' | 'onUpdate' | 'onDelete'
+    action: 'onCreate' | 'onUpdate' | 'onDelete' | 'onApproved' | 'onDeclined' | 'onFlagged' | 'onUnflagged' | 'onReactionAdded' | 'onReactionRemoved'
   ) => {
     if (params.targetId !== post.targetId
       || params.targetType !== post.targetType)
@@ -57,6 +61,12 @@ export const observePosts = (params: {
     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 () => {

package/src/reaction/events/onReactionAdded.ts

@@ -1,43 +1,64 @@
 import { getActiveClient } from '~/client/api'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache, pullFromCache } from '~/core/cache'
 import { createEventSubscriber } from '~/core/events'
+import { getResolver } from '~/core/model'
 import { decoratePayload } from '~/core/query'
+import { onPostReactionAdded } from '~/post/events'
+import { onCommentReactionAdded } from '~/comment/events'
 
 /**
  * ```js
  * import { onReactionAdded } from '@amityco/ts-sdk'
- * const dispose = onReactionAdded(message => {
+ * 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.Reaction['referenceType'],
+  referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
   callback: Amity.Listener<Amity.Model[typeof referenceType]>
 ): Amity.Unsubscriber => {
-  const client = getActiveClient()
+  const callbackWrapper = (model: Amity.Model[typeof referenceType]) => {
+    if (getResolver(referenceType)(model) === referenceId) {
+      callback(model)
+    }
+  }
+
+  if (referenceType === 'message') {
+    const client = getActiveClient()
 
-  const event = `v3.${referenceType}.didUpdate` as const
+    const filter = (payload: Amity.MessagePayload) => {
+      const reactionsCountInCache = (pullFromCache('message', payload.messages[0].messageId) ?? [])[0]?.reactionsCount
+      const isReactionEvent = reactionsCountInCache !== payload.messages[0].reactionsCount
 
-  const filter = (payload: Amity.Events[typeof event]) => {
-    // TODO: lol
+      decoratePayload(payload)
+      ingestInCache(payload)
+      if (isReactionEvent) {
+        callbackWrapper(payload.messages[0])
+      }
+    }
+
+    return createEventSubscriber(
+      client,
+      'reaction/onReactionAdded',
+      'v3.message.didUpdate',
+      filter
+    )
+  }
 
-    decoratePayload(payload)
-    ingestInCache(payload)
+  if (referenceType === 'post') {
+    return onPostReactionAdded(callbackWrapper)
   }
 
-  return createEventSubscriber(
-    client,
-    'reaction/onReactionAdded',
-    event,
-    filter
-  )
+  return onCommentReactionAdded(callbackWrapper)
 }

package/src/reaction/events/onReactionRemoved.ts

@@ -1,41 +1,64 @@
 import { getActiveClient } from '~/client/api'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache, pullFromCache } from '~/core/cache'
 import { createEventSubscriber } from '~/core/events'
+import { getResolver } from '~/core/model'
 import { decoratePayload } from '~/core/query'
+import { onPostReactionRemoved } from '~/post/events'
+import { onCommentReactionRemoved } from '~/comment/events'
 
 /**
  * ```js
  * import { onReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onReactionRemoved(message => {
+ * 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.Reaction['referenceType'],
+  referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
   callback: Amity.Listener<Amity.Model[typeof referenceType]>
 ): Amity.Unsubscriber => {
-  const client = getActiveClient()
+  const callbackWrapper = (model: Amity.Model[typeof referenceType]) => {
+    if (getResolver(referenceType)(model) === referenceId) {
+      callback(model)
+    }
+  }
+
+  if (referenceType === 'message') {
+    const client = getActiveClient()
+
+    const filter = (payload: Amity.MessagePayload) => {
+      const reactionsCountInCache = (pullFromCache('message', payload.messages[0].messageId) ?? [])[0]?.reactionsCount
+      const isReactionEvent = reactionsCountInCache !== payload.messages[0].reactionsCount
 
-  const filter = (payload: Amity.MessagePayload) => {
-    // TODO: lol
+      decoratePayload(payload)
+      ingestInCache(payload)
+      if (isReactionEvent) {
+        callbackWrapper(payload.messages[0])
+      }
+    }
+
+    return createEventSubscriber(
+      client,
+      'reaction/onReactionRemoved',
+      'v3.message.didUpdate',
+      filter
+    )
+  }
 
-    decoratePayload(payload)
-    ingestInCache(payload)
+  if (referenceType === 'post') {
+    return onPostReactionRemoved(callbackWrapper)
   }
 
-  return createEventSubscriber(
-    client,
-    'reaction/onReactionRemoved',
-    'v3.message.didUpdate',
-    filter
-  )
+  return onCommentReactionRemoved(callbackWrapper)
 }

package/src/reaction/utils/dispatchReactable.ts

@@ -12,8 +12,8 @@ export const dispatchReactable = <T extends Amity.ReactableType>(
     fireEvent('v3.message.didUpdate', { messages: [model] })
   else if (referenceType === 'post')
     // @ts-ignore: refactor later
-    fireEvent('v3.post.didUpdate', { posts: [model] })
+    fireEvent('post.updated', { posts: [model] })
   else if (referenceType === 'comment')
     // @ts-ignore: refactor later
-    fireEvent('v3.comment.didUpdate', { comments: [model] })
+    fireEvent('comment.updated', { comments: [model] })
 }

package/src/reaction/utils/index.ts

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

package/src/reaction/utils/preparePayloadForCache.ts

@@ -0,0 +1,45 @@
+import { pullFromCache } from '~/core/cache'
+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
+
+  if (event === 'post.addReaction' || event === 'post.removeReaction') {
+    const post = (payload as Amity.Events['post.addReaction']).posts[0]
+    cached = (pullFromCache('post', post.postId) ?? [])[0]
+    model = post
+  } else {
+    const comment = (payload as Amity.Events['comment.addReaction']).comments[0]
+    cached = (pullFromCache('comment', comment.commentId) ?? [])[0]
+    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) })
+  }
+}

package/src/report/api/createReport.ts

@@ -32,9 +32,13 @@ export const createReport = async (
     `/api/v3/${domainName}/${referenceId}/flag`
   )
 
+  const event = referenceType === 'message'
+    ? 'v3.message.didUpdate' as const
+    : `${referenceType}.updated` as const
+
   decoratePayload(data)
   ingestInCache(data)
-  fireEvent(`v3.${referenceType}.didUpdate`, data)
+  fireEvent(event, data)
 
   return !!data
 }

package/src/report/api/deleteReport.ts

@@ -32,9 +32,13 @@ export const deleteReport = async (
     `/api/v3/${domainName}/${referenceId}/unflag`
   )
 
+  const event = referenceType === 'message'
+    ? 'v3.message.didUpdate' as const
+    : `${referenceType}.updated` as const
+
   decoratePayload(data)
   ingestInCache(data)
-  fireEvent(`v3.${referenceType}.didUpdate`, data)
+  fireEvent(event, data)
 
   return !!data
 }

package/src/user/events/index.ts

@@ -1 +1,5 @@
 export * from './onUserUpdated'
+
+export * from './onUserFlagged'
+export * from './onUserUnflagged'
+export * from './onUserFlagCleared'

package/src/user/events/onUserFlagCleared.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onUserFlagCleared } from '@amityco/ts-sdk'
+ * const dispose = onUserFlagCleared(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when flags have been cleared for a {@link Amity.User}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserFlagCleared = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.flagCleared', callback)

package/src/user/events/onUserFlagged.ts

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

package/src/user/events/onUserUnflagged.ts

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