@amityco/ts-sdk 0.0.1-65d7c8a.0 → 0.0.1-669cd80.0

package/src/cache/api/disableCache.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
 /**
  * ```js
@@ -12,12 +12,12 @@ import { getActiveClient } from '~/client/api/activeClient'
  * @category Cache API
  */
 export const disableCache = () => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
-  if (!client.cache) return
-  client.log('cache/api/disableCache')
+  if (!client.cache) return;
+  client.log('cache/api/disableCache');
 
   // we do this so that testing if cache is enabled
   // is only `if (client.cache)
-  delete client.cache
-}
+  delete client.cache;
+};

package/src/cache/api/dropFromCache.ts

@@ -1,5 +1,5 @@
-import { getActiveClient } from '~/client/api/activeClient'
-import { decodeKey, encodeKey, partialMatch } from '../utils'
+import { getActiveClient } from '~/client/api/activeClient';
+import { decodeKey, encodeKey, partialMatch } from '../utils';
 
 /**
  * ```js
@@ -16,29 +16,26 @@ import { decodeKey, encodeKey, partialMatch } from '../utils'
  *
  * @category Cache API
  */
-export const dropFromCache = (
-  key: Amity.CacheKey,
-  exact: boolean = false,
-): boolean => {
-  const { log, cache } = getActiveClient()
+export const dropFromCache = (key: Amity.CacheKey, exact = false): boolean => {
+  const { log, cache } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/dropFromCache', { key, exact })
+  if (!cache) return false;
+  log('cache/api/dropFromCache', { key, exact });
 
   if (!exact) {
-    return (Object.keys(cache.data))
+    return Object.keys(cache.data)
       .map(stringKey => decodeKey(stringKey))
       .filter(candidate => partialMatch(key, candidate))
       .map<boolean>(filteredKey => dropFromCache(filteredKey, true))
-      .every(returned => returned)
+      .every(returned => returned);
   }
 
-  const encodedKey = encodeKey(key)
+  const encodedKey = encodeKey(key);
 
   if (encodedKey in cache.data) {
-    delete cache.data[encodedKey]
-    return true
+    delete cache.data[encodedKey];
+    return true;
   }
 
-  return false
-}
+  return false;
+};

package/src/cache/api/enableCache.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
 /**
  * ```js
@@ -20,10 +20,10 @@ export const enableCache = (
   prevState: Amity.Cache['data'] = {},
   persistIf?: Amity.Cache['persistIf'],
 ) => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
-  if (client.cache) return
-  client.log('cache/api/enableCache')
+  if (client.cache) return;
+  client.log('cache/api/enableCache');
 
-  client.cache = { data: prevState, persistIf }
-}
+  client.cache = { data: prevState, persistIf };
+};

package/src/cache/api/index.ts

@@ -1,21 +1,21 @@
 // on/off
-export * from './enableCache'
-export * from './disableCache'
+export * from './enableCache';
+export * from './disableCache';
 
 // persistency
-export * from './restoreCache'
-export * from './backupCache'
-export * from './wipeCache'
+export * from './restoreCache';
+export * from './backupCache';
+export * from './wipeCache';
 
 // fetch
-export * from './queryCache'
-export * from './pullFromCache'
+export * from './queryCache';
+export * from './pullFromCache';
 
 // mutate
-export * from './pushToCache'
-export * from './mergeInCache'
-export * from './upsertInCache'
-export * from './dropFromCache'
+export * from './pushToCache';
+export * from './mergeInCache';
+export * from './upsertInCache';
+export * from './dropFromCache';
 
 /*
  * ingestInCache and syncInCache are not exported ;

package/src/cache/api/ingestInCache.ts

@@ -1,4 +1,4 @@
-import { PAYLOAD2MODEL, getResolver } from '~/core/model'
+import { PAYLOAD2MODEL, getResolver } from '~/core/model';
 
 import { upsertInCache } from './upsertInCache';
 
@@ -15,19 +15,18 @@ export const ingestInCache = (
   payload: Record<string, Record<string, unknown>[]> = {},
   options?: Amity.CacheOptions,
 ) => {
-  Object.entries(payload)
-    .forEach(([key, models]) => {
-      const type = PAYLOAD2MODEL[key];
-      if (!type) return
+  Object.entries(payload).forEach(([key, models]) => {
+    const type = PAYLOAD2MODEL[key];
+    if (!type) return;
 
-      const resolver = getResolver(type);
-      models.forEach(model => {
-        upsertInCache(
-          // eslint-disable @typescript-eslint no-explicit-any
-          [type, 'get', resolver(model as any)], // this 'any' cannot be avoided, sorry.
-          model,
-          options,
-        );
-      })
-    })
-}
+    const resolver = getResolver(type);
+    models.forEach(model => {
+      upsertInCache(
+        // eslint-disable @typescript-eslint no-explicit-any
+        [type, 'get', resolver(model as any)], // this 'any' cannot be avoided, sorry.
+        model,
+        options,
+      );
+    });
+  });
+};

package/src/cache/api/mergeInCache.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { pullFromCache } from './pullFromCache'
-import { pushToCache } from './pushToCache'
+import { pullFromCache } from './pullFromCache';
+import { pushToCache } from './pushToCache';
 
 /**
  * ```js
@@ -21,24 +21,22 @@ import { pushToCache } from './pushToCache'
  *
  * @category Cache API
  */
- export const mergeInCache = <T extends {}>(
+export const mergeInCache = <T extends Record<string, unknown>>(
   key: Amity.CacheKey,
   mutation: Partial<T> | ((oldVal: T) => T),
   options?: Amity.CacheOptions,
 ): boolean => {
-  const { log, cache } = getActiveClient()
+  const { log, cache } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/mergeInCache', { key, mutation })
+  if (!cache) return false;
+  log('cache/api/mergeInCache', { key, mutation });
 
   const oldVal = pullFromCache<T>(key);
 
-  if (!oldVal)
-    return false;
+  if (!oldVal) return false;
 
-  const newVal = typeof mutation === 'function'
-    ? mutation(oldVal.data)
-    : { ...oldVal.data, ...mutation };
+  const newVal =
+    typeof mutation === 'function' ? mutation(oldVal.data) : { ...oldVal.data, ...mutation };
 
   pushToCache(key, newVal, options);
   return true;

package/src/cache/api/pullFromCache.ts

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { encodeKey } from '../utils'
+import { encodeKey } from '../utils';
 
 /**
  * ```js
@@ -17,17 +17,15 @@ import { encodeKey } from '../utils'
  *
  * @category Cache API
  */
- export const pullFromCache = <T extends unknown>(
-  key: Amity.CacheKey
+export const pullFromCache = <T extends unknown>(
+  key: Amity.CacheKey,
 ): Amity.CacheEntry<T> | undefined => {
-  const { log, cache } = getActiveClient()
+  const { log, cache } = getActiveClient();
 
-  if (!cache) return
-  log('cache/api/pullFromCache', key)
+  if (!cache) return;
+  log('cache/api/pullFromCache', key);
 
-  const str = encodeKey(key)
+  const str = encodeKey(key);
 
-  return !!cache.data[str]
-    ? cache.data[str] as Amity.CacheEntry<T>
-    : undefined
+  return cache.data[str] ? (cache.data[str] as Amity.CacheEntry<T>) : undefined;
 };

package/src/cache/api/pushToCache.ts

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { encodeKey } from '../utils'
+import { encodeKey } from '../utils';
 
 /**
  * ```js
@@ -17,24 +17,26 @@ import { encodeKey } from '../utils'
  *
  * @category Cache API
  */
- export const pushToCache = (
+export const pushToCache = (
   key: Amity.CacheKey,
   data: unknown,
   options: Amity.CacheOptions = { cachedAt: Date.now() },
 ): boolean => {
-  const { log, cache } = getActiveClient()
+  const { log, cache } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/pushToCache', { key, data, options })
+  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)
+  if (!options?.hasOwnProperty('offline') && cache.persistIf) {
+    // eslint-disable-next-line no-param-reassign
+    options.offline = cache.persistIf(key, data);
+  }
 
-  const encodedKey = encodeKey(key)
-  cache.data[encodedKey] = { key, data, ...options }
+  const encodedKey = encodeKey(key);
+  cache.data[encodedKey] = { key, data, ...options };
 
-  return true
-}
+  return true;
+};

package/src/cache/api/queryCache.ts

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { decodeKey, partialMatch } from '../utils'
+import { decodeKey, partialMatch } from '../utils';
 
 /**
  * ```js
@@ -17,19 +17,18 @@ import { decodeKey, partialMatch } from '../utils'
  *
  * @category Cache API
  */
- export const queryCache = <T extends unknown>(
-  key: Amity.CacheKey
+export const queryCache = <T extends unknown>(
+  key: Amity.CacheKey,
 ): Amity.CacheEntry<T>[] | undefined => {
-  const { log, cache } = getActiveClient()
+  const { log, cache } = getActiveClient();
 
-  if (!cache) return
-  log('cache/api/queryCache', { key })
+  if (!cache) return;
+  log('cache/api/queryCache', { key });
 
-  return Object
-    .keys(cache.data)
+  return Object.keys(cache.data)
     .filter(stringKey => {
-      const decodedKey = decodeKey(stringKey)
-      return partialMatch(key, decodedKey)
+      const decodedKey = decodeKey(stringKey);
+      return partialMatch(key, decodedKey);
     })
-    .map(stringKey => cache.data[stringKey]) as Amity.CacheEntry<T>[]
+    .map(stringKey => cache.data[stringKey]) as Amity.CacheEntry<T>[];
 };

package/src/cache/api/restoreCache.ts

@@ -1,6 +1,6 @@
-import AsyncStorage from '@react-native-async-storage/async-storage'
+import AsyncStorage from '@react-native-async-storage/async-storage';
 
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
 /**
  * ```js
@@ -22,22 +22,23 @@ import { getActiveClient } from '~/client/api/activeClient'
  *
  * @category Cache API
  */
-export const restoreCache = async (
-  storageKey: string = 'amitySdk'
-) => {
-  const client = getActiveClient()
+export const restoreCache = async (storageKey = 'amitySdk') => {
+  const client = getActiveClient();
 
-  if (!client.cache) return false
-  client.log('cache/api/restoreCache', { storageKey })
+  if (!client.cache) return false;
+  client.log('cache/api/restoreCache', { storageKey });
 
-  const serializedData = (await AsyncStorage.getItem(`${storageKey}#${client.userId}`)) ?? '{}'
+  const serializedData = (await AsyncStorage.getItem(`${storageKey}#${client.userId}`)) ?? '{}';
 
-  let cache: Amity.Cache['data'] = {}
+  let cache: Amity.Cache['data'] = {};
 
-  try { cache = JSON.parse(serializedData) }
-  catch (err) {}
+  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
-}
+  client.cache.data = { ...cache, ...client.cache.data };
+  return true;
+};

package/src/cache/api/snipeIdFromCollection.ts

@@ -1,9 +1,7 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
 import { queryCache, mergeInCache, dropFromCache } from '.';
 
-import { decodeKey, partialMatch } from '../utils'
-
 /**
  * ```js
  * import { snipeFromCollection } from '@amityco/ts-sdk'
@@ -20,34 +18,31 @@ import { decodeKey, partialMatch } from '../utils'
  *
  * @category Cache API
  */
- export const snipeIdFromCollections = (
-  domain: Amity.Domain,
-  id: string,
-) => {
-  const { log, cache } = getActiveClient()
+export const snipeIdFromCollections = (domain: Amity.Domain, id: string) => {
+  const { log, cache } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/snipeFromCollections', { domain, id })
+  if (!cache) return false;
+  log('cache/api/snipeFromCollections', { domain, id });
 
-  const entries = (queryCache<unknown[]>([domain, 'query']) ?? [])
-    .filter(entry => entry?.data.includes(id))
+  const entries = (queryCache<unknown[]>([domain, 'query']) ?? []).filter(entry =>
+    entry?.data.includes(id),
+  );
 
-  if (!entries.length)
-    return false
+  if (!entries.length) return false;
 
-  const toBeDeleted: Amity.CacheKey[] = []
+  const toBeDeleted: Amity.CacheKey[] = [];
 
   entries.forEach(({ key }) => {
-    mergeInCache<unknown[]>(key, (oldVal) => {
-      const newVal = oldVal.filter(itemId => itemId !== id)
+    // @ts-ignore
+    mergeInCache<unknown[]>(key, oldVal => {
+      const newVal = oldVal.filter(itemId => itemId !== id);
 
-      if (!newVal.length)
-        toBeDeleted.push(key)
+      if (!newVal.length) toBeDeleted.push(key);
 
-      return newVal
-    })
-  })
+      return newVal;
+    });
+  });
 
-  toBeDeleted.forEach(key => dropFromCache(key, true))
-  return true
+  toBeDeleted.forEach(key => dropFromCache(key, true));
+  return true;
 };

package/src/cache/api/upsertInCache.ts

@@ -1,8 +1,8 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { pullFromCache } from './pullFromCache'
-import { pushToCache } from './pushToCache'
-import { mergeInCache } from './mergeInCache'
+import { pullFromCache } from './pullFromCache';
+import { pushToCache } from './pushToCache';
+import { mergeInCache } from './mergeInCache';
 
 /**
  * ```js
@@ -21,19 +21,17 @@ import { mergeInCache } from './mergeInCache'
  * @category Cache API
  * @hidden
  */
- export const upsertInCache = <T extends {}>(
+export const upsertInCache = <T extends Record<string, unknown>>(
   key: Amity.CacheKey,
   data: T,
   options: Amity.CacheOptions = { cachedAt: Date.now() },
 ): boolean => {
-  const { log, cache } = getActiveClient()
+  const { log, cache } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/upsertInCache', { key, data, options })
+  if (!cache) return false;
+  log('cache/api/upsertInCache', { key, data, options });
 
-  const cached = pullFromCache<T>(key)
+  const cached = pullFromCache<T>(key);
 
-  return cached
-    ? mergeInCache<T>(key, data, options)
-    : pushToCache(key, data, options)
-}
+  return cached ? mergeInCache<T>(key, data, options) : pushToCache(key, data, options);
+};

package/src/cache/api/wipeCache.ts

@@ -1,6 +1,6 @@
-import AsyncStorage from '@react-native-async-storage/async-storage'
+import AsyncStorage from '@react-native-async-storage/async-storage';
 
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
 /**
  * ```js
@@ -21,16 +21,14 @@ import { getActiveClient } from '~/client/api/activeClient'
  *
  * @category Cache API
  */
-export const wipeCache = async (
-  storageKey: string = 'amitySdk'
-) => {
-  const { log, cache, userId } = getActiveClient()
+export const wipeCache = async (storageKey = 'amitySdk') => {
+  const { log, cache, userId } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/wipeCache', { storageKey })
+  if (!cache) return false;
+  log('cache/api/wipeCache', { storageKey });
 
-  cache.data = {}
-  await AsyncStorage.setItem(`${storageKey}#${userId}`, '{}')
+  cache.data = {};
+  await AsyncStorage.setItem(`${storageKey}#${userId}`, '{}');
 
-  return true
-}
+  return true;
+};

package/src/cache/utils/index.ts

@@ -8,12 +8,11 @@
  * @hidden
  */
 const normalize = (
-  source: Record<string, Amity.Serializable>
-): Record<string, Amity.Serializable> => (
+  source: Record<string, Amity.Serializable>,
+): Record<string, Amity.Serializable> =>
   Object.keys(source)
     .sort()
-    .reduce((acc, key) => ({ ...acc, [key]: source[key] }), {})
-)
+    .reduce((acc, key) => ({ ...acc, [key]: source[key] }), {});
 
 /**
  * Encodes a given {@link Amity.CacheKey} to a plain string
@@ -24,11 +23,8 @@ const normalize = (
  * @category Cache
  * @hidden
  */
-export const encodeKey = (key: Amity.CacheKey): string => (
- JSON.stringify(key, (_, val) =>
-   typeof val === "object" ? normalize(val) : val
- )
-);
+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}
@@ -42,7 +38,6 @@ export const encodeKey = (key: Amity.CacheKey): string => (
  */
 export const decodeKey = (key: string): Amity.CacheKey => JSON.parse(key);
 
-
 /**
  * Performs a recursive partial deep equal check on two objects.
  *
@@ -56,18 +51,16 @@ 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;
+  if (!predicate || !candidate) return false;
 
- // we only perform recursive check on objects
- else if (typeof predicate !== "object") {
-   return false;
- }
+  // we only perform recursive check on objects
+  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])
- );
-}
+  // 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
@@ -77,8 +70,5 @@ export const partialMatch = (predicate: any, candidate: any): boolean => {
  *
  * @category Cache
  */
-export const isCached = <T extends unknown>(
-  obj?: any
-): obj is Amity.Cached<T> => (
-  ['data', 'cachedAt'].every(prop => obj?.hasOwnProperty(prop))
-)
+export const isCached = <T extends unknown>(obj?: any): obj is Amity.Cached<T> =>
+  ['data', 'cachedAt'].every(prop => obj?.hasOwnProperty(prop));