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

package/src/file/observers/observeFile.ts

@@ -22,7 +22,7 @@ import { getFile } from '../api'
  */
 export const observeFile = <Events extends ['onFetch']>(
   fileId: string,
-  callback: Amity.ObjectListener<Amity.QueryResult<Amity.File>, Events>,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.File>, Events>
 ): Amity.Unsubscriber => {
   const { log } = getActiveClient()
 
@@ -31,24 +31,22 @@ export const observeFile = <Events extends ['onFetch']>(
 
   // wrapper function to make sure
   const router = (
-    result: Amity.QueryResult<Amity.File>,
+    result: Amity.Snapshot<Amity.File>,
     action: Events[number]
   ) => {
     // filter function
     if (result.data?.fileId !== fileId) return
 
-    if (callback instanceof Function)
-      return callback(result)
+    if (callback instanceof Function) return callback(result)
 
-    if (action !== 'onFetch')
-      callback.onEvent?.(action, result)
+    if (action !== 'onFetch') callback.onEvent?.(action, result)
 
     callback[action]?.(result)
   }
 
   runQuery(
     createQuery(getFile, fileId),
-    (result) => result.data && router(result, 'onFetch'),
+    result => result.data && router(result, 'onFetch')
   )
 
   return () => {

package/src/index.ts

@@ -5,8 +5,8 @@ export * from './version'
 
 // sdk core
 export * from './core/query'
-export * from './core/cache'
-export * from './core/stores'
+export * from './core/subscription'
+export * from './cache/api'
 
 export * from './client/api'
 export * from './client/events'
@@ -21,13 +21,13 @@ export * from './file/observers'
 
 export * from './role/api'
 
-// asc partials
+// // asc partials
 export * from './reaction/api'
 export * from './reaction/events'
 
 export * from './report/api'
 
-// asc messaging
+// // asc messaging
 export * from './channel/api'
 export * from './channel/events'
 export * from './channel/observers'
@@ -36,7 +36,7 @@ export * from './message/api'
 export * from './message/events'
 export * from './message/observers'
 
-// asc social
+// // asc social
 export * from './community/api'
 export * from './community/events'
 export * from './community/observers'
@@ -52,4 +52,4 @@ export * from './comment/events'
 export * from './comment/observers'
 
 export * from './stream/api'
-// export * from './stream/events'
+export * from './stream/events'

package/src/message/api/createMessage.ts

@@ -2,8 +2,8 @@ import { uuid } from '~/core/uuid'
 
 import { getActiveClient } from '~/client/api'
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache, pullFromCache, pushToCache } from '~/core/cache'
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 import { fireEvent } from '~/core/events'
 
 /**
@@ -25,7 +25,7 @@ import { fireEvent } from '~/core/events'
  */
 export const createMessage = async <T extends Amity.MessageContentType>(
   bundle: Pick<Amity.Message<T>, 'channelId' | 'type' | 'data' | 'metadata'>
-) => {
+): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient()
   client.log('user/createMessage', bundle)
 
@@ -33,12 +33,16 @@ export const createMessage = async <T extends Amity.MessageContentType>(
     '/api/v3/messages', bundle,
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
   // no need for event, fired by server
 
   const { messages } = data
-  return messages[0]
+
+  return {
+    data: messages[0],
+    cachedAt,
+  }
 }
 
 /**
@@ -59,32 +63,32 @@ export const createMessage = async <T extends Amity.MessageContentType>(
  */
 createMessage.optimistically = (
   bundle: Pick<Amity.Message, 'channelId' | 'type' | 'data' | 'metadata'>
-) => {
+): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient()
   client.log('user/createMessage.locally', bundle)
 
-  // should we do this?
   if (!client.cache) return
 
-  const [channel] = pullFromCache('channel', bundle.channelId) ?? []
+  const channel = pullFromCache<Amity.Channel>(['channel', 'get', bundle.channelId])
 
-  pushToCache('channel', {
-    ...channel,
-    messageCount: (channel.messageCount ?? 0) + 1,
+  upsertInCache(['channel', 'get', bundle.channelId], {
+    ...channel?.data,
+    messageCount: (channel?.data.messageCount ?? 0) + 1,
   })
 
   const message = {
-    localId: uuid(),
     messageId: Math.random().toString(16),
     userId: client.userId,
-    channelSegment: (channel?.messageCount ?? 0) + 1,
+    channelSegment: (channel?.data.messageCount ?? 0) + 1,
     createdAt: new Date().toISOString(),
     ...bundle,
-    syncedAt: -1,
   } as Amity.Message
 
-  pushToCache('message', message)
+  pushToCache(['message', 'get', message.messageId], message, { cachedAt: -1 })
   fireEvent('v3.message.didCreate', { messages: [message] })
 
-  return message
+  return {
+    data: message,
+    cachedAt: -1
+  }
 }

package/src/message/api/deleteMessage.ts

@@ -2,10 +2,7 @@ import { getActiveClient } from '~/client/api'
 
 import { getMessage } from './getMessage'
 
-import {
-  pullFromCache,
-  pushToCache,
-} from '~/core/cache'
+import { pullFromCache, upsertInCache } from '~/cache/api'
 import { fireEvent } from '~/core/events'
 
 /**
@@ -24,7 +21,7 @@ import { fireEvent } from '~/core/events'
  */
 export const deleteMessage = async (
   messageId: Amity.Message['messageId'],
-) => {
+): Promise<Amity.Message> => {
   const client = getActiveClient()
   client.log('message/deleteMessage', messageId)
 
@@ -36,7 +33,7 @@ export const deleteMessage = async (
   const deleted = await getMessage(messageId)
   // no need for event, fired by server
 
-  return deleted
+  return deleted.data
 }
 
 /**
@@ -54,22 +51,26 @@ export const deleteMessage = async (
  */
 deleteMessage.optimistically = (
   messageId: Amity.Message['messageId'],
-) => {
+): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient()
   client.log('message/deleteMessage', messageId)
 
-  const [message] = pullFromCache('message', messageId) ?? []
+  const message = pullFromCache<Amity.Message>(['message', 'get', messageId])
 
   if (!message) return
 
+  const cachedAt = -1
   const deleted: Amity.Message = {
-    ...message,
+    ...message.data,
     isDeleted: true,
     updatedAt: new Date().toISOString(),
   }
 
-  pushToCache('message', deleted)
+  upsertInCache(['message', 'get', messageId], deleted, { cachedAt })
   fireEvent('v3.message.didDelete', { messages: [deleted] })
 
-  return deleted
+  return {
+    data: deleted,
+    cachedAt
+  }
 }

package/src/message/api/getMessage.ts

@@ -1,8 +1,7 @@
 import { getActiveClient } from '~/client/api'
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { decoratePayload } from '~/core/query'
 
-import { getMessages } from './getMessages'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
@@ -20,7 +19,7 @@ import { getMessages } from './getMessages'
  */
 export const getMessage = async (
   messageId: Amity.Message['messageId'],
-) => {
+): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient()
   client.log('message/getMessage', messageId)
 
@@ -29,11 +28,15 @@ export const getMessage = async (
     `/api/v3/messages/${messageId}`,
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
 
   const { messages } = data
-  return messages.find(message => message.messageId === messageId)!
+
+  return {
+    data: messages.find(message => message.messageId === messageId)!,
+    cachedAt,
+  }
 }
 
 /**
@@ -51,10 +54,19 @@ export const getMessage = async (
  */
 getMessage.locally = (
   messageId: Amity.Message['messageId'],
-) => {
+): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient()
   client.log('message/getMessage.locally', messageId)
 
-  const [message] = pullFromCache('message', messageId) ?? []
-  return message
+  if (!client.cache) return
+
+  const cached = pullFromCache<Amity.Message>(['message', 'get', messageId])
+
+  if (!cached)
+    return
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  }
 }

package/src/message/api/getMessages.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 getMessages = async (
   messageIds: Amity.Message['messageId'][],
-) => {
+): Promise<Amity.Cached<Amity.Message[]>> => {
   const client = getActiveClient()
   client.log('message/getMessages', messageIds)
 
@@ -30,11 +29,13 @@ export const getMessages = async (
     { params: { messageIds } },
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
 
-  const { messages } = data
-  return toRecord(messages)
+  return {
+    data: data.messages,
+    cachedAt
+  }
 }
 
 /**
@@ -52,12 +53,24 @@ export const getMessages = async (
  */
 getMessages.locally = (
   messageIds: Amity.Message['messageId'][],
-) => {
+): Amity.Cached<Amity.Message[]> | undefined => {
   const client = getActiveClient()
   client.log('message/getMessages.locally', messageIds)
 
-  const cached = pullFromCache('message', ...messageIds) ?? []
+  if (!client.cache) return
 
-  if (cached?.length === messageIds.length)
-    return toRecord(cached)
+  const cached = messageIds
+    .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
+    .filter(Boolean)
+
+  const messages = cached.map(({ data }) => data)
+  const oldest = cached.sort((a, b) => a.cachedAt! < b.cachedAt! ? -1 : 1)?.[0]
+
+  if (cached?.length < messageIds.length)
+    return
+
+  return {
+    data: messages,
+    cachedAt: oldest.cachedAt,
+  }
 }

package/src/message/api/queryMessages.ts

@@ -1,16 +1,9 @@
 import { getActiveClient } from '~/client/api'
 
-import {
-  decoratePayload,
-  toPage,
-  toToken,
-  filterByPropEquality,
-  sortByChannelSegment,
-} from '~/core/query'
-
-import { ingestInCache, pullFromCache } from '~/core/cache'
-
-import { toRecord } from '~/core/model'
+import { toPage, toToken } from '~/core/query'
+import { pullFromCache, pushToCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { getResolver } from '~/core/model'
 
 /**
  * ```js
@@ -35,11 +28,11 @@ export const queryMessages = async (query: {
   tags?: Amity.Taggable['tags']
   excludeTags?: Amity.Taggable['tags']
   page?: Amity.Page
-}) => {
+}): Promise<Amity.Cached<Amity.Paged<Amity.Message>>> => {
   const client = getActiveClient()
   client.log('message/queryMessages', 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)
@@ -56,17 +49,23 @@ export const queryMessages = async (query: {
 
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, messages } = unwrapPayload(data)
-  const { paging, ...response } = data
 
-  decoratePayload(response as unknown as Record<string, any[]>)
-  ingestInCache(response as unknown as Record<string, any[]>)
+  const { paging, ...payload } = data
+  const { messages } = payload
+
+  const cachedAt = client.cache && Date.now()
 
-  const { messages } = response
+  if (client.cache) {
+    ingestInCache(payload as Amity.MessagePayload, { cachedAt })
+
+    const cacheKey = ['message', 'query', { ...params, options: { ...page } } as Amity.Serializable]
+    pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging })
+  }
 
   const nextPage = toPage(paging.next)
   const prevPage = toPage(paging.previous)
 
-  return { data: toRecord(messages), nextPage, prevPage }
+  return { data: messages, cachedAt, prevPage, nextPage }
 }
 
 /**
@@ -82,64 +81,31 @@ export const queryMessages = async (query: {
  *
  * @category Message API
  */
-queryMessages.locally = (query: Parameters<typeof queryMessages>[0]) => {
+queryMessages.locally = (
+  query: Parameters<typeof queryMessages>[0]
+): Amity.Cached<Amity.Paged<Amity.Message>> | undefined => {
   const client = getActiveClient()
   client.log('message/queryMessages.locally', query)
 
-  const { channelId, page } = query
-
-  const [channel] = pullFromCache('channel', channelId) ?? []
-
-  let messages: Amity.Message<any>[] = pullFromCache('message') ?? []
-
-  // filter
-  messages = filterByPropEquality(messages, 'channelId', channelId)
-
-  // API-FIX filter by isDeleted doesn't work in backend... srsly wtf... how do they test things???
-  // messages = filterByPropEquality(messages, 'isDeleted', query?.isDeleted)
+  if (!client.cache) return
 
-  // sort
-  messages = messages.sort(sortByChannelSegment)
+  const { page = { limit: 10 }, ...params } = query
 
-  // paging
-  if (page) {
-    // slice
-    // API-FIX we can't reuse proper page because the message page is done
-    // by channelSegment which is sadly unique to the entire platform.
-    // this part is copied and adapted from sliceByPaging function
+  const queryKey = ['message', 'query', { ...params, options: { ...page }} as Amity.Serializable];
+  const { data, cachedAt } = pullFromCache<{messages: Pick<Amity.Message, 'messageId'>[]} & Amity.Pagination>(queryKey) ?? {}
 
-    let start: number | undefined = 0
-    let end: number | undefined = undefined
+  if (!data?.messages.length)
+    return
 
-    // next page behavior
-    if ('after' in page) {
-      start = page.after !== 0
-        ? messages.findIndex(message => message.channelSegment === page?.after) + 1
-        : 0
+  const messages: Amity.Message[] = data.messages
+    .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
+    .filter(Boolean)
+    .map(({ data }) => data)
 
-      end = start + page.limit
+  const prevPage = toPage(data?.paging.previous)
+  const nextPage = toPage(data?.paging.next)
 
-    // prev page behavior
-    } else if ('before' in page) {
-      end = page.before !== 0
-        ? messages.findIndex(message => message.channelSegment === page?.before) + 1
-        : messages.length - 1
-
-      start = end > page.limit ? end - page.limit : 0
-    }
-
-    const paged = messages.slice(start, end)
-
-    messages = paged.length === page.limit ? paged : []
-  }
-
-  const prevPage = messages[0]?.channelSegment > 0
-    ? { before: messages[0].channelSegment, limit: page?.limit }
-    : undefined
-
-  const nextPage = messages[messages.length - 1]?.channelSegment < (channel?.messageCount ?? 0)
-    ? { after: messages[messages.length - 1].channelSegment, limit: page?.limit }
+  return messages.length === data?.messages?.length
+    ? { data: messages, cachedAt, prevPage, nextPage }
     : undefined
-
-  return { data: toRecord(messages), nextPage, prevPage }
 }

package/src/message/api/updateMessage.ts

@@ -1,7 +1,7 @@
 import { getActiveClient } from '~/client/api'
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache, pullFromCache, pushToCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { pullFromCache, upsertInCache } from '~/cache/api'
 import { fireEvent } from '~/core/events'
 
 /**
@@ -24,7 +24,7 @@ import { fireEvent } from '~/core/events'
 export const updateMessage = async (
   messageId: Amity.Message['messageId'],
   patch: Patch<Amity.Message, 'data' | 'metadata'>,
-) => {
+): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient()
   client.log('user/updateMessage', patch)
 
@@ -32,11 +32,15 @@ export const updateMessage = async (
     `/api/v3/messages/${messageId}`, patch,
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
-  // no need for event, fired by server
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
 
-  return data.messages.find(message => message.messageId === messageId)!
+  const { messages } = data
+
+  return {
+    data: messages.find(message => message.messageId === messageId)!,
+    cachedAt,
+  }
 }
 
 /**
@@ -58,22 +62,28 @@ export const updateMessage = async (
 updateMessage.optimistically = (
   messageId: Amity.Message['messageId'],
   patch: Patch<Amity.Message, 'data' | 'metadata'>,
-) => {
+): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient()
   client.log('user/updateMessage', patch)
 
-  const [message] = pullFromCache('message', messageId) ?? []
+  if (!client.cache) return
+
+  const message = pullFromCache<Amity.Message>(['message', 'get', messageId])
 
   if (!message) return
 
+  const cachedAt = -1
   const updated: Amity.Message = {
-    ...message,
+    ...message.data,
     ...patch,
     updatedAt: new Date().toISOString(),
   }
 
-  pushToCache('message', updated)
+  upsertInCache(['message', 'get', messageId], updated, { cachedAt })
   fireEvent('v3.message.didUpdate', { messages: [updated] })
 
-  return updated
+  return {
+    data: updated,
+    cachedAt
+  }
 }

package/src/message/events/onMessageCreated.ts

@@ -1,8 +1,7 @@
 import { getActiveClient } from '~/client/api'
 import { createEventSubscriber } from '~/core/events'
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
@@ -25,7 +24,6 @@ export const onMessageCreated = (
   const client = getActiveClient()
 
   const filter = (payload: Amity.MessagePayload) => {
-    decoratePayload(payload)
     ingestInCache(payload)
     callback(payload.messages[0])
   }

package/src/message/events/onMessageDeleted.ts

@@ -1,8 +1,7 @@
 import { getActiveClient } from '~/client/api'
 import { createEventSubscriber } from '~/core/events'
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
@@ -25,7 +24,6 @@ export const onMessageDeleted = (
   const client = getActiveClient()
 
   const filter = (payload: Amity.MessagePayload) => {
-    decoratePayload(payload)
     ingestInCache(payload)
     callback(payload.messages[0])
   }

package/src/message/events/onMessageUpdated.ts

@@ -1,8 +1,7 @@
 import { getActiveClient } from '~/client/api'
 import { createEventSubscriber } from '~/core/events'
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
@@ -25,7 +24,6 @@ export const onMessageUpdated = (
   const client = getActiveClient()
 
   const filter = (payload: Amity.MessagePayload) => {
-    decoratePayload(payload)
     ingestInCache(payload)
     callback(payload.messages[0])
   }

package/src/message/observers/observeMessage.ts

@@ -29,8 +29,8 @@ import {
  */
 export const observeMessage = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
   messageId: Amity.Message['messageId'],
-  callback: Amity.ObjectListener<Amity.QueryResult<Amity.Message>, Events>,
-  policy: Amity.QueryPolicy = 'cache_then_server',
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Message>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server'
 ): Amity.Unsubscriber => {
   const { log } = getActiveClient()
 
@@ -39,17 +39,15 @@ export const observeMessage = <Events extends ['onFetch', 'onUpdate', 'onDelete'
 
   // wrapper function to make sure
   const router = (
-    result: Amity.QueryResult<Amity.Message>,
+    result: Amity.Snapshot<Amity.Message>,
     action: Events[number]
   ) => {
     // filter function
     if (result.data?.messageId !== messageId) return
 
-    if (callback instanceof Function)
-      return callback(result)
+    if (callback instanceof Function) return callback(result)
 
-    if (action !== 'onFetch')
-      callback.onEvent?.(action, result)
+    if (action !== 'onFetch') callback.onEvent?.(action, result)
 
     callback[action]?.(result)
   }
@@ -57,14 +55,14 @@ export const observeMessage = <Events extends ['onFetch', 'onUpdate', 'onDelete'
   const disposers: Amity.Unsubscriber[] = []
 
   disposers.push(
-    onMessageUpdated(message => router(message, 'onUpdate')),
-    onMessageDeleted(message => router(message, 'onDelete')),
+    onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete'))
   )
 
   if (policy !== 'no_fetch') {
     runQuery(
       createQuery(getMessage, messageId),
-      (result) => result.data && router(result, 'onFetch'),
+      result => result.data && router(result, 'onFetch'),
       queryOptions(policy)
     )
   }