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

package/src/message/observers/observeMessages.ts

@@ -25,7 +25,7 @@ import {
  */
 export const observeMessages = (
   channelId: Amity.Channel['channelId'],
-  callback: Amity.ObjectListener<Amity.Message, ['onCreate', 'onUpdate', 'onDelete']>,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Message>, ['onCreate', 'onUpdate', 'onDelete']>,
 ): Amity.Unsubscriber => {
   const { log } = getActiveClient()
 
@@ -35,10 +35,10 @@ export const observeMessages = (
   const disposers: Amity.Unsubscriber[] = []
 
   const router = (
-    message: Amity.Message,
+    message: Amity.Snapshot<Amity.Message>,
     action: 'onCreate' | 'onUpdate' | 'onDelete',
   ) => {
-    if (message.channelId !== channelId) return
+    if (message.data?.channelId !== channelId) return
 
     if (callback instanceof Function)
       return callback(message)
@@ -48,9 +48,9 @@ export const observeMessages = (
   }
 
   disposers.push(
-    onMessageCreated(message => router(message, 'onCreate')),
-    onMessageUpdated(message => router(message, 'onUpdate')),
-    onMessageDeleted(message => router(message, 'onDelete')),
+    onMessageCreated(data => router({ data, loading: false, origin: 'event' }, 'onCreate')),
+    onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
   )
 
   return () => {

package/src/post/api/createPost.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'
 
 /**
@@ -26,7 +25,7 @@ export const createPost = async <T extends Amity.PostContentType | string>(
   bundle: Pick<Amity.Post, 'targetType' | 'targetId' | 'metadata'> & {
     dataType?: T, data: { [k: string]: any }
   },
-) => {
+): Promise<Amity.Cached<Amity.Post>> => {
   const client = getActiveClient()
   client.log('post/createPost', bundle)
 
@@ -38,12 +37,16 @@ export const createPost = async <T extends Amity.PostContentType | string>(
     '/api/v3/posts', bundle
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
 
   fireEvent('community.updated', { communities: data.communities! })
   fireEvent('post.created', data)
 
   const { posts } = data
-  return posts[0]
+
+  return {
+    data: posts[0],
+    cachedAt,
+  }
 }

package/src/post/api/deletePost.ts

@@ -1,7 +1,9 @@
 import { getActiveClient } from '~/client/api'
+
 import { getCommunity } from '~/community/api'
+import { dropFromCache } from '~/cache/api'
+import { upsertInCache } from '~/cache/api'
 import { fireEvent } from '~/core/events'
-import { dropFromCache, mergeInCache } from '~/core/cache'
 
 import { getPost } from './getPost'
 
@@ -22,7 +24,7 @@ import { getPost } from './getPost'
 export const deletePost = async (
   postId: Amity.Post['postId'],
   permanent: boolean = false,
-) => {
+): Promise<Amity.Post> => {
   const client = getActiveClient()
   client.log('post/deletePost', postId)
 
@@ -42,22 +44,22 @@ export const deletePost = async (
   // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
   // and so we cannot refetch the community or advertise on events. hopefully this should be solved
   // later when realtime events covers that for us.
-  if (post.targetType === 'community') {
-    const community = await getCommunity(post.targetId);
-    fireEvent('community.updated', { communities: [community] })
+  if (post.data.targetType === 'community') {
+    const community = await getCommunity(post.data.targetId);
+    fireEvent('community.updated', { communities: [community.data] })
   }
 
   // to support hard deletion
-  const deleted = { ...post, isDeleted: true }
+  const deleted = { ...post.data, isDeleted: true }
 
-  fireEvent('post.afterDeleted', { posts: [deleted] })
+  fireEvent('post.deleted', { posts: [deleted] })
 
   if (permanent) {
     setTimeout(() => {
-      dropFromCache('post', {postId})
+      dropFromCache(['post', 'get', postId], true)
     }, 0)
   } else {
-    mergeInCache('post', {postId, isDeleted: true})
+    upsertInCache(['post', 'get', postId], {isDeleted: true})
   }
 
   return deleted

package/src/post/api/getPost.ts

@@ -1,13 +1,12 @@
 import { getActiveClient } from '~/client/api'
-import { ingestInCache, pullFromCache, dropFromCache } from '~/core/cache'
-import { decoratePayload } from '~/core/query'
 
-import { getPosts } from './getPosts'
+import { pullFromCache, dropFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
  * import { getPost } from '@amityco/ts-sdk'
- * const post = await getPost('foobar')
+ * const { data: post } = await getPost('foobar')
  * ```
  *
  * Fetches a {@link Amity.Post} object
@@ -20,7 +19,7 @@ import { getPosts } from './getPosts'
  */
 export const getPost = async (
   postId: Amity.Post['postId']
-) => {
+): Promise<Amity.Cached<Amity.Post>> => {
   const client = getActiveClient()
   client.log('post/getPost', postId)
 
@@ -35,26 +34,30 @@ export const getPost = async (
     data = response.data;
   } catch (error) {
     if ((error as Amity.ErrorResponse)?.code  === Amity.ServerError.ITEM_NOT_FOUND) {
-      dropFromCache('post', {postId})
+      dropFromCache(['post', 'get', postId], true)
     }
 
     throw error;
   }
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
 
   const { posts } = data
-  return posts.find(post => post.postId === postId)!
+
+  return {
+    data: posts.find(post => post.postId === postId)!,
+    cachedAt,
+  }
 }
 
 /**
  * ```js
  * import { getPost } from '@amityco/ts-sdk'
- * const post = getPost.locally('foobar')
+ * const { data. post } = getPost.locally('foobar')
  * ```
  *
- * Fetches a {@link Amity.Post} object
+ * Fetches a {@link Amity.Post} object from cache
  *
  * @param postId the ID of the {@link Amity.Post} to fetch
  * @returns the associated {@link Amity.Post} object
@@ -63,10 +66,19 @@ export const getPost = async (
  */
 getPost.locally = (
   postId: Amity.Post['postId']
-) => {
+): Amity.Cached<Amity.Post> | undefined => {
   const client = getActiveClient()
   client.log('post/getPost.locally', postId)
 
-  const [post] = pullFromCache('post', postId) ?? []
-  return post
+  if (!client.cache) return
+
+  const cached = pullFromCache<Amity.Post>(['post', 'get', postId])
+
+  if (!cached)
+    return
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  }
 }

package/src/post/api/getPosts.ts

@@ -1,13 +1,12 @@
 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
  * import { getPosts } from '@amityco/ts-sdk'
- * const posts = await getPosts(['foo', 'bar'])
+ * const { data: posts } = await getPosts(['foo', 'bar'])
  * ```
  *
  * Fetches a collection of {@link Amity.Post} objects
@@ -20,7 +19,7 @@ import { toRecord } from '~/core/model'
  */
 export const getPosts = async (
   postIds: Amity.Post['postId'][]
-) => {
+): Promise<Amity.Cached<Amity.Post[]>> => {
   const client = getActiveClient()
   client.log('post/getPosts', postIds)
 
@@ -30,17 +29,19 @@ export const getPosts = async (
     { params: { postIds } }
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
 
-  const { posts } = data
-  return posts
+  return {
+    data: data.posts,
+    cachedAt
+  }
 }
 
 /**
  * ```js
  * import { getPosts } from '@amityco/ts-sdk'
- * const posts = getPosts.locally(['foo', 'bar'])
+ * const { data: posts } = getPosts.locally(['foo', 'bar'])
  * ```
  *
  * Fetches a collection of {@link Amity.Post} objects from cache
@@ -52,12 +53,24 @@ export const getPosts = async (
  */
 getPosts.locally = (
   postIds: Amity.Post['postId'][]
-) => {
+): Amity.Cached<Amity.Post[]> | undefined => {
   const client = getActiveClient()
   client.log('post/getPosts.locally', postIds)
 
-  const cached = pullFromCache('post', ...postIds) ?? []
+  if (!client.cache) return
 
-  if (cached?.length === postIds.length)
-    return toRecord(cached)
+  const cached = postIds
+    .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+    .filter(Boolean)
+
+  const posts = cached.map(({ data }) => data)
+  const oldest = cached.sort((a, b) => a.cachedAt! < b.cachedAt! ? -1 : 1)?.[0]
+
+  if (cached?.length < postIds.length)
+    return
+
+  return {
+    data: posts,
+    cachedAt: oldest.cachedAt,
+  }
 }

package/src/post/api/queryPosts.ts

@@ -1,14 +1,15 @@
 import { getActiveClient } from '~/client/api'
 
-import { decoratePayload, toPage, toToken } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { toPageRaw, toToken } from '~/core/query'
 
-import { toRecord } from '~/core/model'
+import { pullFromCache, pushToCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { getResolver } from '~/core/model'
 
 /**
  * ```js
  * import { queryPosts } from '@amityco/ts-sdk'
- * const posts = await queryPosts({ targetId, targetType })
+ * const { data: posts, prevPage, nextPage } = await queryPosts({ targetId, targetType })
  * ```
  *
  * Queries a paginable list of {@link Amity.Post} objects
@@ -32,43 +33,49 @@ export const queryPosts = async (
     matchingOnlyParentPost?: boolean
     page?: Amity.Page
   }
-) => {
+): Promise<Amity.Cached<Amity.PagedRaw<Amity.Post>>> => {
   const client = getActiveClient()
   client.log('post/queryPosts', query)
 
-  const { page, ...params } = query ?? {}
+  const { page = { limit: 10 }, ...params } = query
 
   // API-FIX: parameters should be querystring. (1)
   // API-FIX: backend should answer Amity.Response (2)
-  // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<Amity.PostPayload>>>(
+  // const { data } = await client.http.get<Amity.Response<Amity.PagedRawResponse<Amity.PostPayload>>>(
   const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
-    `/api/v3/posts`, { params: {
+    `/api/v4/posts`, { params: {
       ...params,
       options: {
-        token: toToken(page, 'skiplimit'),
+        token: toToken(page, 'afterbeforeraw'),
       },
     }, }
   )
 
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, posts } = unwrapPayload(data)
-  const { paging, ...response } = data
+  // unpacking
+  const { paging, ...payload } = data
+  const { posts } = payload
 
-  decoratePayload(response as unknown as Record<string, Object[]>)
-  ingestInCache(response as unknown as Record<string, Object[]>)
+  const cachedAt = client.cache && Date.now()
 
-  const { posts } = response
+  if (client.cache) {
+    ingestInCache(payload as Amity.PostPayload, { cachedAt })
 
-  const nextPage = toPage(paging.next)
-  const prevPage = toPage(paging.previous)
+    const cacheKey = ['post', 'query', { ...params, options: { ...page } } as Amity.Serializable]
+    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging })
+  }
+
+  const nextPage = toPageRaw(paging.next)
+  const prevPage = toPageRaw(paging.previous)
 
-  return { data: toRecord(posts), nextPage, prevPage }
+  return { data: posts, cachedAt, prevPage, nextPage }
 }
 
 /**
  * ```js
  * import { queryPosts } from '@amityco/ts-sdk'
- * const posts = queryPosts.locally({ targetId, targetType })
+ * const { data: posts, prevPage, nextPage } = queryPosts.locally({ targetId, targetType })
  * ```
  *
  * Queries a paginable list of {@link Amity.Post} objects from cache
@@ -80,9 +87,29 @@ export const queryPosts = async (
  */
 queryPosts.locally = (
   query: Parameters<typeof queryPosts>[0],
-) => {
+): Amity.Cached<Amity.PagedRaw<Amity.Post>> | undefined => {
   const client = getActiveClient()
   client.log('post/queryPosts.locally', query)
 
-  // TODO
+  if (!client.cache) return
+
+  const { page = { limit: 10 }, ...params } = query
+
+  const queryKey = ['post', 'query', { ...params, options: { ...page }} as Amity.Serializable];
+  const { data, cachedAt } = pullFromCache<{posts: Pick<Amity.Post, 'postId'>[]} & Amity.Pagination>(queryKey) ?? {}
+
+  if (!data?.posts.length)
+    return
+
+  const posts: Amity.Post[] = data.posts
+    .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+    .filter(Boolean)
+    .map(({ data }) => data)
+
+  const prevPage = toPageRaw(data?.paging.previous)
+  const nextPage = toPageRaw(data?.paging.next)
+
+  return posts.length === data?.posts?.length
+    ? { data: posts, cachedAt, prevPage, nextPage }
+    : undefined
 }

package/src/post/api/updatePost.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 updatePost = async (
   postId: Amity.Post['postId'],
   patch: Patch<Amity.Post, 'data' | 'metadata'>,
-) => {
+): Promise<Amity.Cached<Amity.Post>> => {
   const client = getActiveClient()
   client.log('user/updatePost', patch)
 
@@ -32,11 +31,16 @@ export const updatePost = async (
     `/api/v3/posts/${postId}`, patch,
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
 
   fireEvent('post.updated', data)
 
   const { posts } = data
-  return posts.find(post => post.postId === postId)!
+
+  return {
+    data: posts.find(post => post.postId === postId)!,
+    cachedAt,
+  }
+
 }

package/src/post/events/onPostApproved.ts

@@ -8,7 +8,7 @@ import { createPostEventSubscriber } from './utils'
  * })
  * ```
  *
- * 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

package/src/post/events/onPostCreated.ts

@@ -8,7 +8,7 @@ import { createPostEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Post} has been created
+ * Fired when a {@link Amity.Post} has been created
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening

package/src/post/events/onPostDeclined.ts

@@ -8,7 +8,7 @@ import { createPostEventSubscriber } from './utils'
  * })
  * ```
  *
- * 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

package/src/post/events/onPostDeleted.ts

@@ -8,7 +8,7 @@ import { createPostEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Post} has been deleted
+ * Fired when a {@link Amity.Post} has been deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
@@ -16,4 +16,4 @@ import { createPostEventSubscriber } from './utils'
  * @category Post Events
  */
 export const onPostDeleted = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
-  createPostEventSubscriber('post.afterDeleted', callback)
+  createPostEventSubscriber('post.deleted', callback)

package/src/post/events/onPostFlagged.ts

@@ -8,7 +8,7 @@ import { createPostEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Post} has been updated
+ * 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

package/src/post/events/onPostReactionAdded.ts

@@ -1,4 +1,9 @@
-import { createPostEventSubscriber } 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,12 +13,41 @@ import { createPostEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Post} has been reacted
+ * 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 =>
-  createPostEventSubscriber('post.addReaction', callback)
+export const onPostReactionAdded = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.Events['post.addReaction']) => {
+    if (!client.cache) {
+      callback(payload.posts[0])
+    } else {
+      const cached = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])
+
+      preparePayloadForCache('post.addReaction', payload)
+      const { reactor, ...postPayload } = payload;
+
+      ingestInCache(postPayload as Amity.CommentPayload)
+
+      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!
+
+      if (cached && isMatch(cached.data, post.data)) {
+        return
+      }
+
+      callback(post.data)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    'post.addReaction',
+    'post.addReaction',
+    filter
+  )
+}

package/src/post/events/onPostReactionRemoved.ts

@@ -1,4 +1,9 @@
-import { createPostEventSubscriber } 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,12 +13,41 @@ import { createPostEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when a reaction has been removed from an {@link Amity.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 =>
-  createPostEventSubscriber('post.removeReaction', callback)
+export const onPostReactionRemoved = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.Events['post.removeReaction']) => {
+    if (!client.cache) {
+      callback(payload.posts[0])
+    } else {
+      const cached = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])
+
+      preparePayloadForCache('post.removeReaction', payload)
+      const { reactor, ...postPayload } = payload;
+
+      ingestInCache(postPayload as Amity.CommentPayload)
+
+      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!
+
+      if (cached && isMatch(cached.data, post.data)) {
+        return
+      }
+
+      callback(post.data)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    'post.removeReaction',
+    'post.removeReaction',
+    filter
+  )
+}

package/src/post/events/onPostUnflagged.ts

@@ -8,7 +8,7 @@ import { createPostEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when an {@link Amity.Post} has been updated
+ * 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

package/src/post/events/onPostUpdated.ts

@@ -8,7 +8,7 @@ import { createPostEventSubscriber } from './utils'
  * })
  * ```
  *
- * 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