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

package/src/comment/api/getComment.ts

@@ -1,7 +1,7 @@
 import { getActiveClient } from '~/client/api'
 
-import { ingestInCache, pullFromCache, dropFromCache } from '~/core/cache'
-import { decoratePayload } from '~/core/query'
+import { pullFromCache, dropFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
@@ -19,7 +19,7 @@ import { decoratePayload } from '~/core/query'
  */
 export const getComment = async (
   commentId: Amity.Comment['commentId']
-) => {
+): Promise<Amity.Cached<Amity.Comment>> => {
   const client = getActiveClient()
   client.log('comment/getComment', commentId)
 
@@ -34,17 +34,20 @@ export const getComment = async (
     data = response.data;
   } catch (error) {
     if ((error as Amity.ErrorResponse)?.code  === Amity.ServerError.ITEM_NOT_FOUND) {
-      dropFromCache('comment', {commentId})
+      dropFromCache(['comment', 'get', commentId], true)
     }
 
     throw error;
   }
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
 
   const { comments } = data
-  return comments.find(comment => comment.commentId === commentId)!
+  return {
+    data: comments.find(comment => comment.commentId === commentId)!,
+    cachedAt,
+  }
 }
 
 /**
@@ -62,10 +65,19 @@ export const getComment = async (
  */
 getComment.locally = (
   commentId: Amity.Comment['commentId']
-) => {
+): Amity.Cached<Amity.Comment> | undefined => {
   const client = getActiveClient()
   client.log('comment/getComment.locally', commentId)
 
-  const [comment] = pullFromCache('comment', commentId) ?? []
-  return comment
+  if (!client.cache) return
+
+  const cached = pullFromCache<Amity.Comment>(['comment', 'get', commentId])
+
+  if (!cached)
+    return
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  }
 }

package/src/comment/api/getComments.ts

@@ -1,8 +1,7 @@
 import { getActiveClient } from '~/client/api'
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
@@ -20,7 +19,7 @@ import { toRecord } from '~/core/model'
  */
 export const getComments = async (
   commentIds: Amity.Comment['commentId'][],
-) => {
+): Promise<Amity.Cached<Amity.Comment[]>> => {
   const client = getActiveClient()
   client.log('comment/getComments', commentIds)
 
@@ -30,11 +29,13 @@ export const getComments = async (
     { params: { commentIds } },
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
 
-  const { comments } = data
-  return toRecord(comments)
+  return {
+    data: data.comments,
+    cachedAt
+  }
 }
 
 /**
@@ -52,12 +53,24 @@ export const getComments = async (
  */
 getComments.locally = (
   commentIds: Amity.Comment['commentId'][]
-) => {
+): Amity.Cached<Amity.Comment[]> | undefined => {
   const client = getActiveClient()
   client.log('comment/getComments.locally', commentIds)
 
-  const cached = pullFromCache('comment', ...commentIds) ?? []
+  if (!client.cache) return
 
-  if (cached?.length === commentIds.length)
-    return toRecord(cached)
+  const cached = commentIds
+    .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
+    .filter(Boolean)
+
+  const comments = cached.map(({ data }) => data)
+  const oldest = cached.sort((a, b) => a.cachedAt! < b.cachedAt! ? -1 : 1)?.[0]
+
+  if (cached?.length < commentIds.length)
+    return
+
+  return {
+    data: comments,
+    cachedAt: oldest.cachedAt,
+  }
 }

package/src/comment/api/queryComments.ts

@@ -1,20 +1,19 @@
 import { getActiveClient } from '~/client/api'
 
 import {
-  decoratePayload,
-  filterByPropEquality,
   sortBySegmentNumber,
   toPage,
   toToken,
 } from '~/core/query'
+import { pullFromCache, pushToCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { getResolver } from '~/core/model'
 
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
 
 /**
  * ```js
  * import { queryComments } from '@amityco/ts-sdk'
- * const comments = await queryComments({ postId })
+ * const comments = await queryComments({ referenceType: 'post', referenceId: 'foo' })
  * ```
  *
  * Queries a paginable list of {@link Amity.Comment} objects
@@ -32,13 +31,13 @@ export const queryComments = async (query: {
   hasFlag?: boolean
   isDeleted?: Amity.Comment['isDeleted']
   page?: Amity.Page
-}) => {
+}): Promise<Amity.Cached<Amity.Paged<Amity.Comment>>> => {
   const client = getActiveClient()
   client.log('comment/queryComments', query)
 
-  const { page, ...params } = query
+  const { page = { limit: 10 }, ...params } = query
 
-  const filterByParentId = query.parentId !== undefined
+  // const filterByParentId = query.parentId !== undefined
 
   // API-FIX: parameters should be querystring. (1)
   // API-FIX: backend should answer Amity.Response (2)
@@ -55,22 +54,28 @@ export const queryComments = async (query: {
 
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, comments } = unwrapPayload(data)
-  const { paging, ...response } = data
+  const { paging, ...payload } = data
+  const { comments } = payload
 
-  decoratePayload(response as unknown as Record<string, Object[]>)
-  ingestInCache(response as unknown as Record<string, Object[]>)
+  const cachedAt = client.cache && Date.now()
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.CommentPayload, { cachedAt })
+
+    const cacheKey = ['comment', 'query', { ...params, options: { ...page } } as Amity.Serializable]
+    pushToCache(cacheKey, { comments: comments.map(getResolver('comment')), paging })
+  }
 
-  const prevPage = toPage(paging.previous)
   const nextPage = toPage(paging.next)
+  const prevPage = toPage(paging.previous)
 
-  const { comments } = response
-  return { data: toRecord(comments), prevPage, nextPage }
+  return { data: comments, cachedAt, prevPage, nextPage }
 }
 
 /**
  * ```js
  * import { queryComments } from '@amityco/ts-sdk'
- * const comments = queryComments.locally({ postId })
+ * const comments = queryComments.locally({ referenceType: 'post', referenceId: 'foo' })
  * ```
  *
  * Queries a paginable list of {@link Amity.Comment} objects from cache
@@ -82,88 +87,29 @@ export const queryComments = async (query: {
  */
 queryComments.locally = (
   query: Parameters<typeof queryComments>[0],
-) => {
+): Amity.Cached<Amity.Paged<Amity.Comment>> | undefined => {
   const client = getActiveClient()
-  client.log('post/queryComments.locally', query)
-
-  const {
-    referenceId,
-    referenceType,
-    parentId,
-    isDeleted,
-    page = { before: 0, limit: 5 },
-  } = query
-
-  if (isNaN(page.after!) && isNaN(page.before!))
-    page.before = 0;
-
-  if (isNaN(page.limit))
-    page.limit = 5
-
-  let comments: Amity.Comment[] = pullFromCache('comment') ?? []
-
-  // no cache
-  if (!comments.length)
-    return
+  client.log('comment/queryComments.locally', query)
 
-  // filter
-  comments = filterByPropEquality(comments, 'referenceId', referenceId)
-  comments = filterByPropEquality(comments, 'referenceType', referenceType)
-  comments = filterByPropEquality(comments, 'parentId', parentId)
-  comments = filterByPropEquality(comments, 'isDeleted', isDeleted)
+  if (!client.cache) return
 
-  // no interesting cache
-  if (!comments.length)
-    return
-
-  // sort
-  comments = comments.sort(sortBySegmentNumber)
-
-  // paging
-  // API-FIX we can't reuse proper page because the message page is done
-  // by segmentNumber which is sadly unique to the entire platform.
-  // this part is copied and adapted from sliceByPaging function
+  const { page = { limit: 10 }, ...params } = query
 
-  const afterIndex = !isNaN(page.after!)
-    ? comments.findIndex(({ segmentNumber }) => segmentNumber === page.after! + 1)
-    : 0
+  const queryKey = ['comment', 'query', { ...params, options: { ...page }} as Amity.Serializable];
+  const { data, cachedAt } = pullFromCache<{comments: Pick<Amity.Comment, 'commentId'>[]} & Amity.Pagination>(queryKey) ?? {}
 
-  const beforeIndex = !isNaN(page.before!) && page.before !== 0
-    ? comments.findIndex(({ segmentNumber }) => segmentNumber === page.before! - 1) + 1
-    : comments.length
-
-  if (afterIndex < 0 || beforeIndex < 0)
+  if (!data?.comments.length)
     return
 
-  let slice = comments.slice(
-    afterIndex !== -1 ? afterIndex : 0,
-    beforeIndex !== -1 ? beforeIndex : undefined,
-  )
+  const comments: Amity.Comment[] = data.comments
+    .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
+    .filter(Boolean)
+    .map(({ data }) => data)
 
-  // nothing left after slicing
-  if (!slice.length)
-    return
+  const prevPage = toPage(data?.paging.previous)
+  const nextPage = toPage(data?.paging.next)
 
-  if (!isNaN(page.after!) && !isNaN(page.before!)) {
-    // do nothing
-  } else if (!isNaN(page.after!)) {
-    slice = slice.slice(0, page.limit)
-  } else if (!isNaN(page.before!)) {
-    slice = slice.slice(-page.limit)
-  }
-
-  for (let i = 0; i < slice.length - 1; i++)
-    if (slice[i].segmentNumber !== slice[i + 1].segmentNumber - 1)
-      return
-
-  const prevPage = slice[0].segmentNumber > 1
-    ? { before: slice[0].segmentNumber, limit: page.limit }
+  return comments.length === data?.comments?.length
+    ? { data: comments, cachedAt, prevPage, nextPage }
     : undefined
-
-  const nextPage = {
-    after: slice[slice.length - 1].segmentNumber,
-    limit: page.limit,
-  }
-
-  return { data: toRecord(slice), nextPage, prevPage }
 }

package/src/comment/api/updateComment.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api'
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 import { fireEvent } from '~/core/events'
 
 /**
@@ -24,7 +23,7 @@ import { fireEvent } from '~/core/events'
 export const updateComment = async (
   commentId: Amity.Comment['commentId'],
   patch: Patch<Amity.Comment, 'data' | 'metadata'>,
-) => {
+): Promise<Amity.Cached<Amity.Comment>> => {
   const client = getActiveClient()
   client.log('user/updateComment', patch)
 
@@ -32,10 +31,14 @@ export const updateComment = async (
     `/api/v3/comments/${commentId}`, patch,
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+
   fireEvent('comment.updated', data)
 
   const { comments } = data
-  return comments.find(comment => comment.commentId === commentId)!
+  return {
+    data: comments.find(comment => comment.commentId === commentId)!,
+    cachedAt,
+  }
 }

package/src/comment/events/onCommentCreated.ts

@@ -8,14 +8,14 @@ import { createCommentEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been created
+ * Fired when a {@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>>
+export const onCommentCreated = (
+  callback: Amity.Listener<Amity.Comment>
 ): Amity.Unsubscriber =>
   createCommentEventSubscriber('comment.created', callback)

package/src/comment/events/onCommentDeleted.ts

@@ -8,14 +8,14 @@ import { createCommentEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been deleted
+ * Fired when a {@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>>
+export const onCommentDeleted = (
+  callback: Amity.Listener<Amity.Comment>
 ): Amity.Unsubscriber =>
   createCommentEventSubscriber('comment.deleted', callback)

package/src/comment/events/onCommentFlagged.ts

@@ -8,14 +8,14 @@ import { createCommentEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been updated
+ * Fired when a {@link Amity.Comment} has been flagged
  *
  * @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 onCommentFlagged = <T extends Amity.CommentContentType>(
-  callback: Amity.Listener<Amity.Comment<T>>
+export const onCommentFlagged = (
+  callback: Amity.Listener<Amity.Comment>
 ): Amity.Unsubscriber =>
   createCommentEventSubscriber('comment.flagged', callback)

package/src/comment/events/onCommentReactionAdded.ts

@@ -1,4 +1,9 @@
-import { createCommentEventSubscriber } from './utils'
+import isMatch from 'lodash.ismatch'
+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
@@ -8,14 +13,43 @@ import { createCommentEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been updated
+ * 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 = <T extends Amity.CommentContentType>(
-  callback: Amity.Listener<Amity.Comment<T>>
-): Amity.Unsubscriber =>
-  createCommentEventSubscriber('comment.addReaction', callback)
+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 {
+      const cached = pullFromCache<Amity.Comment>(['comment', 'get', payload.comments[0].commentId])
+
+      preparePayloadForCache('comment.addReaction', payload)
+      const { reactor, ...commentPayload } = payload;
+
+      ingestInCache(commentPayload as Amity.CommentPayload)
+
+      const comment = pullFromCache<Amity.Comment>(['comment', 'get', payload.comments[0].commentId])!
+
+      if (cached && isMatch(cached.data, comment.data)) {
+        return
+      }
+
+      callback(comment.data)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    'comment.addReaction',
+    'comment.addReaction',
+    filter
+  )
+}

package/src/comment/events/onCommentReactionRemoved.ts

@@ -1,4 +1,9 @@
-import { createCommentEventSubscriber } from './utils'
+import isMatch from 'lodash.ismatch'
+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
@@ -8,14 +13,43 @@ import { createCommentEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been updated
+ * 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 = <T extends Amity.CommentContentType>(
-  callback: Amity.Listener<Amity.Comment<T>>
-): Amity.Unsubscriber =>
-  createCommentEventSubscriber('comment.removeReaction', callback)
+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 {
+      const cached = pullFromCache<Amity.Comment>(['comment', 'get', payload.comments[0].commentId])
+
+      preparePayloadForCache('comment.removeReaction', payload)
+      const { reactor, ...commentPayload } = payload;
+
+      ingestInCache(commentPayload as Amity.CommentPayload)
+
+      const comment = pullFromCache<Amity.Comment>(['comment', 'get', payload.comments[0].commentId])!
+
+      if (cached && isMatch(cached.data, comment.data)) {
+        return
+      }
+
+      callback(comment.data)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    'comment.removeReaction',
+    'comment.removeReaction',
+    filter
+  )
+}

package/src/comment/events/onCommentUnflagged.ts

@@ -8,14 +8,14 @@ import { createCommentEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been updated
+ * 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 = <T extends Amity.CommentContentType>(
-  callback: Amity.Listener<Amity.Comment<T>>
+export const onCommentUnflagged = (
+  callback: Amity.Listener<Amity.Comment>
 ): Amity.Unsubscriber =>
   createCommentEventSubscriber('comment.unflagged', callback)

package/src/comment/events/onCommentUpdated.ts

@@ -8,14 +8,14 @@ import { createCommentEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been updated
+ * 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 = <T extends Amity.CommentContentType>(
-  callback: Amity.Listener<Amity.Comment<T>>
+export const onCommentUpdated = (
+  callback: Amity.Listener<Amity.Comment>
 ): Amity.Unsubscriber =>
   createCommentEventSubscriber('comment.updated', callback)

package/src/comment/events/utils.ts

@@ -1,18 +1,40 @@
+import isMatch from 'lodash.ismatch'
 import { getActiveClient } from '~/client/api'
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 import { createEventSubscriber } from '~/core/events'
+import { queryCache, upsertInCache } from '~/cache/api'
 
-export const createCommentEventSubscriber = <T extends Amity.CommentContentType>(
+export const createCommentEventSubscriber = (
   event: keyof Amity.MqttCommentMessageEvents,
-  callback: Amity.Listener<Amity.Comment<T>>
+  callback: Amity.Listener<Amity.Comment>
 ) => {
   const client = getActiveClient()
 
-  const filter = (payload: Amity.CommentPayload<T>) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.comments[0])
+  const filter = (payload: Amity.CommentPayload) => {
+    if (!client.cache) {
+      callback(payload.comments[0])
+    } else {
+      const cached = pullFromCache<Amity.Comment>(['comment', 'get', payload.comments[0].commentId])
+
+      ingestInCache(payload)
+
+      const comment = pullFromCache<Amity.Comment>(['comment', 'get', payload.comments[0].commentId])!
+
+      if (cached && isMatch(cached.data, comment.data)) {
+        return
+      }
+
+      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(