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

package/src/cache/api/pullFromCache.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api/activeClient'
+
+import { encodeKey } from '../utils'
+
+/**
+ * ```js
+ * import { pullFromCache } from '@amityco/ts-sdk'
+ * const user = pullFromCache<Amity.User>(["user", "foobar"])
+ * ```
+ *
+ * Retrieves a {@link Amity.CacheEntry} object matching a given
+ * {@link Amity.CacheKey}. The cache entry is not typed, so the
+ * expected returned type must be passed manually.
+ *
+ * @param key the key matching the object to retrieve from cache
+ * @returns the matching cache entry, or undefined.
+ *
+ * @category Cache API
+ */
+ export const pullFromCache = <T extends unknown>(
+  key: Amity.CacheKey
+): Amity.CacheEntry<T> | undefined => {
+  const { log, cache } = getActiveClient()
+
+  if (!cache) return
+  log('cache/api/pullFromCache', key)
+
+  const str = encodeKey(key)
+
+  return !!cache.data[str]
+    ? cache.data[str] as Amity.CacheEntry<T>
+    : undefined
+};

package/src/cache/api/pushToCache.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api/activeClient'
+
+import { encodeKey } from '../utils'
+
+/**
+ * ```js
+ * import { pushToCache } from '@amityco/ts-sdk'
+ * pushToCache<Amity.User>(["user", "foobar"], user)
+ * ```
+ *
+ * Saves any provided value as {@link Amity.CacheEntry} for the matching {@link Amity.CacheKey}
+ *
+ * @param key the key to save the object to
+ * @param data the object to save
+ * @param options customisation object around cache behavior (default gives a 2mn lifespan)
+ * @returns a success boolean if the object was saved in cache
+ *
+ * @category Cache API
+ */
+ export const pushToCache = (
+  key: Amity.CacheKey,
+  data: unknown,
+  options: Amity.CacheOptions = { cachedAt: Date.now() },
+): boolean => {
+  const { log, cache } = getActiveClient()
+
+  if (!cache) return false
+  log('cache/api/pushToCache', { key, data, options })
+
+  // if consumer did not pass offline but a offline policy is
+  // defined, use the fn to determine if the object needs to
+  // be saved in persistent storage or not.
+  if (!options?.hasOwnProperty('offline') && cache.persistIf)
+    options.offline = cache.persistIf(key, data)
+
+  const encodedKey = encodeKey(key)
+  cache.data[encodedKey] = { key, data, ...options }
+
+  return true
+}

package/src/cache/api/queryCache.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api/activeClient'
+
+import { decodeKey, partialMatch } from '../utils'
+
+/**
+ * ```js
+ * import { queryCache } from '@amityco/ts-sdk'
+ * const entries = queryCache(["user"])
+ * ```
+ *
+ * Retrieves a list of {@link Amity.CacheEntry} objects matching a
+ * partial {@link Amity.CacheKey}. The cache entries can't be typed,
+ * but the expected returned type can be passed manually.
+ *
+ * @param partialKey the partial key matching the objects to retrieve from cache
+ * @returns the matching cache entries, or empty array.
+ *
+ * @category Cache API
+ */
+ export const queryCache = <T extends unknown>(
+  key: Amity.CacheKey
+): Amity.CacheEntry<T>[] | undefined => {
+  const { log, cache } = getActiveClient()
+
+  if (!cache) return
+  log('cache/api/queryCache', { key })
+
+  return Object
+    .keys(cache.data)
+    .filter(stringKey => {
+      const decodedKey = decodeKey(stringKey)
+      return partialMatch(key, decodedKey)
+    })
+    .map(stringKey => cache.data[stringKey]) as Amity.CacheEntry<T>[]
+};

package/src/cache/api/restoreCache.ts

@@ -0,0 +1,43 @@
+import AsyncStorage from '@react-native-async-storage/async-storage'
+
+import { getActiveClient } from '~/client/api/activeClient'
+
+/**
+ * ```js
+ * import { restoreCache } from '@amityco/ts-sdk'
+ * const success = await restoreCache()
+ * ```
+ *
+ * Reads a previously saved {@link Amity.Cache} from a persistent storage,
+ * and inserts it into the current {@link Amity.Cache} instance.
+ *
+ * The strategy for persistent storage will depend on the runtime,
+ * which is supported by @react-native-async-storage/async-storage.
+ *
+ * The current userId will be appended to the given storageKey to ensures
+ * the cached data concerns only the current user.
+ *
+ * @param storageKey the name of the persistent storage
+ * @returns a success boolean if the cache was dumped to persistent storage
+ *
+ * @category Cache API
+ */
+export const restoreCache = async (
+  storageKey: string = 'amitySdk'
+) => {
+  const client = getActiveClient()
+
+  if (!client.cache) return false
+  client.log('cache/api/restoreCache', { storageKey })
+
+  const serializedData = (await AsyncStorage.getItem(`${storageKey}#${client.userId}`)) ?? '{}'
+
+  let cache: Amity.Cache['data'] = {}
+
+  try { cache = JSON.parse(serializedData) }
+  catch (err) {}
+
+  // current cache should override. in case there's something fresher.
+  client.cache.data = { ...cache, ...client.cache.data }
+  return true
+}

package/src/cache/api/snipeIdFromCollection.ts

@@ -0,0 +1,53 @@
+import { getActiveClient } from '~/client/api/activeClient'
+
+import { queryCache, mergeInCache, dropFromCache } from '.';
+
+import { decodeKey, partialMatch } from '../utils'
+
+/**
+ * ```js
+ * import { snipeFromCollection } from '@amityco/ts-sdk'
+ * const user = snipeFromCollection("user", "foobar")
+ * ```
+ *
+ * Removes a {@link Amity.Model} object from  matching a given
+ * {@link Amity.CacheKey}. The cache entry is not typed, so the
+ * expected returned type must be passed manually.
+ *
+ * @param domain the key matching the object to retrieve from cache
+ * @param id the key matching the object to retrieve from cache
+ * @returns a success boolean if the id was removed from all matching collections
+ *
+ * @category Cache API
+ */
+ export const snipeIdFromCollections = (
+  domain: Amity.Domain,
+  id: string,
+) => {
+  const { log, cache } = getActiveClient()
+
+  if (!cache) return false
+  log('cache/api/snipeFromCollections', { domain, id })
+
+  const entries = (queryCache<unknown[]>([domain, 'query']) ?? [])
+    .filter(entry => entry?.data.includes(id))
+
+  if (!entries.length)
+    return false
+
+  const toBeDeleted: Amity.CacheKey[] = []
+
+  entries.forEach(({ key }) => {
+    mergeInCache<unknown[]>(key, (oldVal) => {
+      const newVal = oldVal.filter(itemId => itemId !== id)
+
+      if (!newVal.length)
+        toBeDeleted.push(key)
+
+      return newVal
+    })
+  })
+
+  toBeDeleted.forEach(key => dropFromCache(key, true))
+  return true
+};

package/src/cache/api/upsertInCache.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api/activeClient'
+
+import { pullFromCache } from './pullFromCache'
+import { pushToCache } from './pushToCache'
+import { mergeInCache } from './mergeInCache'
+
+/**
+ * ```js
+ * import { upsertInCache } from '@amityco/ts-sdk'
+ * upsertInCache<Amity.User>(["user", "foobar"], user)
+ * ```
+ *
+ * Insert or update any provided value as {@link Amity.CacheEntry} for
+ * the matching {@link Amity.CacheKey}
+ *
+ * @param key the key to save the object to
+ * @param data the object to save
+ * @param options customisation object around cache behavior (default gives a 2mn lifespan)
+ * @returns a success boolean if the object was saved in cache
+ *
+ * @category Cache API
+ * @hidden
+ */
+ export const upsertInCache = <T extends {}>(
+  key: Amity.CacheKey,
+  data: T,
+  options: Amity.CacheOptions = { cachedAt: Date.now() },
+): boolean => {
+  const { log, cache } = getActiveClient()
+
+  if (!cache) return false
+  log('cache/api/upsertInCache', { key, data, options })
+
+  const cached = pullFromCache<T>(key)
+
+  return cached
+    ? mergeInCache<T>(key, data, options)
+    : pushToCache(key, data, options)
+}

package/src/cache/api/wipeCache.ts

@@ -0,0 +1,36 @@
+import AsyncStorage from '@react-native-async-storage/async-storage'
+
+import { getActiveClient } from '~/client/api/activeClient'
+
+/**
+ * ```js
+ * import { wipeCache } from '@amityco/ts-sdk'
+ * const success = await wipeCache()
+ * ```
+ *
+ * Wipes a persistent storage for the current {@link Amity.Cache} instance.
+ *
+ * The strategy for persistent storage will depend on the runtime,
+ * which is supported by @react-native-async-storage/async-storage.
+ *
+ * The current userId will be appended to the given storageKey to avoid
+ * collision between multiple client instances over time.
+ *
+ * @param storageKey the name of the persistent storage
+ * @returns a success boolean if the persistent cache was wiped.
+ *
+ * @category Cache API
+ */
+export const wipeCache = async (
+  storageKey: string = 'amitySdk'
+) => {
+  const { log, cache, userId } = getActiveClient()
+
+  if (!cache) return false
+  log('cache/api/wipeCache', { storageKey })
+
+  cache.data = {}
+  await AsyncStorage.setItem(`${storageKey}#${userId}`, '{}')
+
+  return true
+}

package/src/cache/utils/index.ts

@@ -0,0 +1,84 @@
+/**
+ * Shallow-clones an object and sort its keys
+ *
+ * @param source a plain object to clone
+ * @returns a clone of source, with keys sorted with default javascript sorting
+ *
+ * @category Cache
+ * @hidden
+ */
+const normalize = (
+  source: Record<string, Amity.Serializable>
+): Record<string, Amity.Serializable> => (
+  Object.keys(source)
+    .sort()
+    .reduce((acc, key) => ({ ...acc, [key]: source[key] }), {})
+)
+
+/**
+ * Encodes a given {@link Amity.CacheKey} to a plain string
+ *
+ * @param key the key to encode
+ * @returns an encoded string
+ *
+ * @category Cache
+ * @hidden
+ */
+export const encodeKey = (key: Amity.CacheKey): string => (
+ JSON.stringify(key, (_, val) =>
+   typeof val === "object" ? normalize(val) : val
+ )
+);
+
+/**
+ * Decodes a string back into a {@link Amity.CacheKey}
+
+ *
+ * @param key the string key to decode
+ * @returns a plain Amity.CacheKey object.
+ *
+ * @category Cache
+ * @hidden
+ */
+export const decodeKey = (key: string): Amity.CacheKey => JSON.parse(key);
+
+
+/**
+ * Performs a recursive partial deep equal check on two objects.
+ *
+ * @param predicate the reference object containing the partial information
+ * @param candidate the object to check against
+ * @returns true if the candidate contains all the values of the predicate
+ *
+ * @category Cache
+ */
+export const partialMatch = (predicate: any, candidate: any): boolean => {
+  if (predicate === candidate) return true;
+
+  // if one or the other is nullish, there can't be equality
+  else if (!predicate || !candidate) return false;
+
+ // we only perform recursive check on objects
+ else if (typeof predicate !== "object") {
+   return false;
+ }
+
+ // recursively call for partial match based on the predicate
+ return Object.keys(predicate).every((key) =>
+   partialMatch(predicate[key], candidate[key])
+ );
+}
+
+/**
+ * Type guard to check and cast that a given predicate matched {@link Amity.Cached} shape
+ *
+ * @param obj any {@link Amity.Cached}-like object
+ * @returns success boolean if the given object is of {@link Amity.Cached} shape
+ *
+ * @category Cache
+ */
+export const isCached = <T extends unknown>(
+  obj?: any
+): obj is Amity.Cached<T> => (
+  ['data', 'cachedAt'].every(prop => obj?.hasOwnProperty(prop))
+)

package/src/category/api/getCategory.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'
 
 /**
  * ```js
@@ -27,8 +26,8 @@ export const getCategory = async (
     `/api/v3/community-categories/${categoryId}`
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
+  // decoratePayload(data)
+  // ingestInCache(data)
 
   const { categories } = data
   return categories[0]

package/src/category/api/queryCategories.ts

@@ -1,8 +1,7 @@
 import { getActiveClient } from '~/client/api/activeClient'
 
-import { decoratePayload, toPage, toToken } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { toPage, toToken } from '~/core/query'
+// import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
@@ -38,12 +37,12 @@ export const queryCategories = async (query?: {
 
   const { paging, ...response } = data
 
-  decoratePayload(response as unknown as Record<string, any[]>)
-  ingestInCache(response as unknown as Record<string, any[]>)
+  // decoratePayload(response as unknown as Record<string, any[]>)
+  // ingestInCache(response as unknown as Record<string, any[]>)
 
   const prevPage = toPage(paging?.previous)
   const nextPage = toPage(paging?.next)
 
   const { categories } = response
-  return [toRecord(categories), { prevPage, nextPage }] as const
+  return { data: categories, prevPage, nextPage }
 }

package/src/channel/api/addChannelMembers.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'
 
 /**
@@ -22,7 +21,7 @@ import { fireEvent } from '~/core/events'
 export const addChannelMembers = async (
   channelId: Amity.Channel['channelId'],
   userIds: Amity.User['userId'][]
-) => {
+): Promise<boolean> => {
   const client = getActiveClient()
   client.log('channel/addChannelMembers', channelId, userIds)
 
@@ -31,8 +30,8 @@ export const addChannelMembers = async (
     { channelId, userIds }
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
+  if (client.cache) ingestInCache(data)
+
   fireEvent('v3.channel.didAddUsers', {
     channels: data.channels!,
   })

package/src/channel/api/addChannelMembersRole.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'
 
 /**
  * ```js
@@ -23,7 +22,7 @@ export const addChannelMembersRole = async (
   channelId: Amity.Channel['channelId'],
   roleId: Amity.Role['roleId'],
   userIds: Amity.User['userId'][]
-) => {
+): Promise<boolean> => {
   const client = getActiveClient()
   client.log('channel/addChannelMembersRole', channelId, roleId, userIds)
 
@@ -32,8 +31,7 @@ export const addChannelMembersRole = async (
     { channelId, role: roleId, userIds }
   )
 
-  decoratePayload(data)
-  ingestInCache(data)
+  if (client.cache) ingestInCache(data)
 
   const { channelUsers } = data
   return !!channelUsers.find(

package/src/channel/api/createChannel.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'
 
 /**
  * ```js
@@ -20,18 +19,24 @@ import { ingestInCache } from '~/core/cache'
 export const createChannel = async <T extends Amity.ChannelType>(
   bundle: { type: T, userIds?: Amity.User['userId'] }
   & Pick<Amity.Channel<T>, 'displayName' | 'avatarFileId' | 'tags' | 'metadata'>
-) => {
+): Promise<Amity.Cached<Amity.Channel>> => {
   const client = getActiveClient()
   client.log('user/createChannel', bundle)
 
-  const { data } = await client.http.post<Amity.ChannelPayload>(
-    '/api/v3/channels', bundle,
-  )
+  let payload;
 
-  decoratePayload(data)
-  ingestInCache(data)
-  // no need for event, fired by server
+  if (bundle?.type === 'conversation') {
+    payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels/conversation', {...bundle, isDistinct: true })
+  } else {
+    payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels', bundle)
+  }
 
-  const { channels } = data
-  return channels[0]
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(payload.data, { cachedAt })
+
+  const { channels } = payload.data
+  return {
+    data: channels[0],
+    cachedAt,
+  }
 }

package/src/channel/api/deleteChannel.ts

@@ -18,7 +18,7 @@ import { getChannel } from './getChannel'
  */
 export const deleteChannel = async (
   channelId: Amity.Channel['channelId'],
-) => {
+): Promise<Amity.Channel> => {
   const client = getActiveClient()
   client.log('channel/deleteChannel', channelId)
 
@@ -30,5 +30,5 @@ export const deleteChannel = async (
   const deleted = await getChannel(channelId)
   // no need for event, fired by server
 
-  return deleted
+  return deleted.data
 }

package/src/channel/api/getChannel.ts

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

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