@amityco/ts-sdk 0.0.1-be4fc2f.0 → 0.0.1-beta.10

package/src/post/events/utils.ts

@@ -1,7 +1,9 @@
+import isMatch from 'lodash.ismatch'
 import { getActiveClient } from '~/client/api'
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { createEventSubscriber } from '~/core/events'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { createEventSubscriber, fireEvent } from '~/core/events'
+import { queryCache, upsertInCache } from '~/cache/api'
 
 export const createPostEventSubscriber = (
   event: keyof Amity.MqttPostMessageEvents,
@@ -10,9 +12,40 @@ export const createPostEventSubscriber = (
   const client = getActiveClient()
 
   const filter = (payload: Amity.PostPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.posts[0])
+    if (!client.cache) {
+      callback(payload.posts[0])
+    } else {
+      const cached = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])
+
+      const { communities, ...others } = payload
+
+      ingestInCache(others as Amity.PostPayload)
+
+      if (communities?.[0]) {
+        fireEvent('community.updated', { communities })
+      }
+
+      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!
+
+      if (cached && isMatch(cached.data, post.data)) {
+        return
+      }
+
+      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(

package/src/post/observers/observePost.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api'
 
 import { createQuery, runQuery, queryOptions } from '~/core/query'
-import { getTopic, subscribe } from '~/core/subscription'
 
 import { getPost } from '../api'
 
@@ -34,8 +33,8 @@ import {
  */
 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',
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Post | undefined>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server'
 ): Amity.Unsubscriber => {
   const { log } = getActiveClient()
 
@@ -44,45 +43,41 @@ export const observePost = <Events extends ['onFetch', 'onUpdate', 'onDelete', '
 
   // wrapper function to make sure
   const router = (
-    result: Amity.QueryResult<Amity.Post>,
+    result: Amity.Snapshot<Amity.Post | undefined>,
     action: Events[number]
   ) => {
-    // filter function
-    if (result.data?.postId !== postId) return
+    if (callback instanceof Function) return callback(result)
 
-    if (action === 'onFetch') {
-      try {
-        disposers.push(subscribe(getTopic(result.data)))
-      } catch (error) {
-        console.error(error)
-      }
-    }
+    if (action !== 'onFetch') callback.onEvent?.(action, result)
 
-    if (callback instanceof Function)
-      return callback(result)
+    callback[action]?.(result)
+  }
 
-    if (action !== 'onFetch')
-      callback.onEvent?.(action, result)
+  const realtimeRouter = (
+    result: Amity.Snapshot<Amity.Post>,
+    action: Events[number]
+  ) => {
+    if (result.data?.postId !== postId) return
 
-    callback[action]?.(result)
+    router(result, action)
   }
 
   const disposers: Amity.Unsubscriber[] = []
 
   disposers.push(
-    onPostUpdated(data => router({ data }, 'onUpdate')),
-    onPostDeleted(data => router({ data }, 'onDelete')),
-    onPostApproved(data => router({ data }, 'onApproved')),
-    onPostDeclined(data => router({ data }, 'onDeclined')),
-    onPostFlagged(data => router({ data }, 'onFlagged')),
-    onPostUnflagged(data => router({ data }, 'onUnflagged')),
-    onPostReactionAdded(data => router({ data }, 'onReactionAdded')),
-    onPostReactionRemoved(data => router({ data }, 'onReactionRemoved')),
+    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 && router(result, 'onFetch'),
+    result => (result.data || result.error) && router(result, 'onFetch'),
     queryOptions(policy),
   )
 

package/src/reaction/api/addReaction.ts

@@ -1,6 +1,6 @@
 import { getActiveClient } from '~/client/api'
 
-import { mutateCache } from '~/core/cache'
+import { upsertInCache, pullFromCache } from '~/cache/api'
 
 import { dispatchReactable, fetchReference } from '../utils'
 
@@ -24,7 +24,7 @@ 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,
@@ -38,9 +38,9 @@ export const addReaction = async (
   )
 
   const model = await fetchReference(referenceType, referenceId)
-  dispatchReactable(referenceType, model)
+  dispatchReactable(referenceType, model.data)
 
-  return model.myReactions?.includes(reactionName) ?? false
+  return model.data.myReactions?.includes(reactionName) ?? false
 }
 
 /**
@@ -62,23 +62,33 @@ addReaction.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: model.reactionsCount + 1,
-      myReactions: [...(model.myReactions ?? []), reactionName],
-      reactions: {
-        ...model.reactions,
-        [reactionName]: (model.reactions[reactionName] ?? 0) + 1,
-      },
-    }
+): boolean | undefined => {
+  const client = getActiveClient()
+  client.log('reaction/createReaction.optimistically', {
+    referenceId,
+    referenceType,
+    reactionName,
   })
 
-  model && dispatchReactable(referenceType, model)
+  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 model?.myReactions?.includes(reactionName) ?? false
+  return reaction?.myReactions?.includes(reactionName) ?? false
 }

package/src/reaction/api/removeReaction.ts

@@ -1,6 +1,6 @@
 import { getActiveClient } from '~/client/api'
 
-import { mutateCache } from '~/core/cache'
+import { upsertInCache, pullFromCache } from '~/cache/api'
 
 import { dispatchReactable, fetchReference } from '../utils'
 
@@ -24,7 +24,7 @@ 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,
@@ -38,9 +38,9 @@ export const removeReaction = async (
   )
 
   const model = await fetchReference(referenceType, referenceId)
-  dispatchReactable(referenceType, model)
+  dispatchReactable(referenceType, model.data)
 
-  return !model.myReactions?.includes(reactionName) ?? false
+  return !model.data.myReactions?.includes(reactionName) ?? false
 }
 
 /**
@@ -62,23 +62,33 @@ 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),
-      },
-    }
+): boolean | undefined => {
+  const client = getActiveClient()
+  client.log('reaction/removeReaction.optimistically', {
+    referenceId,
+    referenceType,
+    reactionName,
   })
 
-  model && dispatchReactable(referenceType, model)
+  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 !model?.myReactions?.includes(reactionName) ?? false
+  return !reaction?.myReactions?.includes(reactionName) ?? false
 }

package/src/reaction/events/onReactionAdded.ts

@@ -1,45 +1,64 @@
 import { getActiveClient } from '~/client/api'
-import { ingestInCache } from '~/core/cache'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache} from '~/cache/api/ingestInCache'
 import { createEventSubscriber } from '~/core/events'
-import { decoratePayload } from '~/core/query'
+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(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 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
 
-  const event = referenceType === 'message'
-    ? `v3.${referenceType}.didUpdate` as const
-    : `${referenceType}.addReaction` as const
+      ingestInCache(payload)
 
-  const filter = (payload: Amity.Events[typeof event]) => {
-    // TODO: lol
+      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 { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 import { createEventSubscriber } from '~/core/events'
-import { decoratePayload } from '~/core/query'
+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(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 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
 
-  const filter = (payload: Amity.MessagePayload) => {
-    // TODO: lol
+      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/fetchReference.ts

@@ -6,7 +6,7 @@ import { getComment } from '~/comment/api'
 export const fetchReference = async (
   referenceType: Amity.ReactableType,
   referenceId: string,
-): Promise<Amity.Model[typeof referenceType]> => {
+): Promise<Amity.Cached<Amity.Model[typeof referenceType]>> => {
   if (referenceType === 'message')
     return getMessage(referenceId)
   else if (referenceType === 'post')

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 '~/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) })
+  }
+}

package/src/report/api/createReport.ts

@@ -1,8 +1,7 @@
 import { getActiveClient } from '~/client/api/activeClient'
 
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 import { fireEvent } from '~/core/events'
-import { decoratePayload } from '~/core/query'
 
 import REFERENCE_TYPES from '../constants/referenceTypes'
 
@@ -22,7 +21,7 @@ import REFERENCE_TYPES from '../constants/referenceTypes'
 export const createReport = async (
   referenceType: keyof typeof REFERENCE_TYPES,
   referenceId: string
-) => {
+): Promise<boolean> => {
   const client = getActiveClient()
   client.log('report/createReport', { referenceType, referenceId })
 
@@ -32,12 +31,12 @@ export const createReport = async (
     `/api/v3/${domainName}/${referenceId}/flag`
   )
 
+  if (client.cache) ingestInCache(data)
+
   const event = referenceType === 'message'
     ? 'v3.message.didUpdate' as const
     : `${referenceType}.updated` as const
 
-  decoratePayload(data)
-  ingestInCache(data)
   fireEvent(event, data)
 
   return !!data

package/src/report/api/deleteReport.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api/activeClient'
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 import REFERENCE_TYPES from '../constants/referenceTypes'
 import { fireEvent } from '~/core/events'
@@ -22,7 +21,7 @@ import { fireEvent } from '~/core/events'
 export const deleteReport = async (
   referenceType: keyof typeof REFERENCE_TYPES,
   referenceId: string
-) => {
+): Promise<boolean> => {
   const client = getActiveClient()
   client.log('report/deleteReport', { referenceType, referenceId })
 
@@ -32,12 +31,12 @@ export const deleteReport = async (
     `/api/v3/${domainName}/${referenceId}/unflag`
   )
 
+  if (client.cache) ingestInCache(data)
+
   const event = referenceType === 'message'
     ? 'v3.message.didUpdate' as const
     : `${referenceType}.updated` as const
 
-  decoratePayload(data)
-  ingestInCache(data)
   fireEvent(event, data)
 
   return !!data

package/src/role/api/getRole.ts

@@ -1,7 +1,7 @@
 import { getActiveClient } from '~/client/api'
 
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { decorateModels } from '~/core/query'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
@@ -17,7 +17,9 @@ import { decorateModels } from '~/core/query'
  * @category Role API
  * @async
  */
-export const getRole = async (roleId: Amity.Role['roleId']) => {
+export const getRole = async (
+  roleId: Amity.Role['roleId']
+): Promise<Amity.Cached<Amity.Role>> => {
   const client = getActiveClient()
   client.log('role/getRole', roleId)
 
@@ -25,10 +27,13 @@ export const getRole = async (roleId: Amity.Role['roleId']) => {
     `/api/v3/roles/${roleId}`
   )
 
-  decorateModels(data)
-  ingestInCache({ roles: data })
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache({ roles: data }, { cachedAt })
 
-  return data.find(role => role.roleId === roleId)!
+  return {
+    data: data.find(role => role.roleId === roleId)!,
+    cachedAt,
+  }
 }
 
 /**
@@ -44,10 +49,21 @@ export const getRole = async (roleId: Amity.Role['roleId']) => {
  *
  * @category Role API
  */
-getRole.locally = (roleId: Amity.Role['roleId']) => {
+getRole.locally = (
+  roleId: Amity.Role['roleId']
+): Amity.Cached<Amity.Role> | undefined => {
   const client = getActiveClient()
   client.log('role/getRole.locally', roleId)
 
-  const [role] = pullFromCache('role', roleId) ?? []
-  return role
+  if (!client.cache) return
+
+  const cached = pullFromCache<Amity.Role>(['role', 'get', roleId])
+
+  if (!cached)
+    return
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  }
 }