@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

package/src/cache/api/upsertInCache.ts

@@ -0,0 +1,37 @@
+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 Record<string, unknown>>(
+  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,34 @@
+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 = '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,96 @@
+// cache constants
+export const CACHE_KEY_GET = 'get';
+export const CACHE_KEY_QUERY = 'query';
+export const CACHE_KEY_TOMBSTONE = 'dead';
+export const CACHE_KEY_COLLECTION = 'collection';
+
+export const CACHE_LIFESPAN = 1 * 60 * 1000; // 1 minute
+export const CACHE_LIFESPAN_TOMBSTONE = 3 * 60 * 1000; // 3 minutes
+
+/**
+ * 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
+  if (!predicate || !candidate) 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]));
+};
+
+/**
+ * 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));
+
+/**
+ * checks if passed error code is included in
+ * Tombstone errors list
+ *
+ * @param errorCode as {@link Amity.ServerError}
+ * @returns success boolean if the given errorCode
+ * is included in Tombstone errors list
+ *
+ * @category Cache
+ */
+export const checkIfShouldGoesToTombstone = (errorCode: Amity.ServerError): boolean =>
+  [Amity.ServerError.ITEM_NOT_FOUND, Amity.ServerError.FORBIDDEN].includes(errorCode);

package/src/cache/utils/tests/encodeKey.test.ts

@@ -0,0 +1,19 @@
+import { encodeKey } from '..';
+
+describe('cache util > encodeKey', () => {
+  test('it should return encoded string', () => {
+    const key = ['post', 'get', 'post-id'];
+    const keyObject = { 0: 'post', 1: 'get', 2: 'post-id' };
+
+    const expected = JSON.stringify(keyObject);
+
+    expect(encodeKey(key)).toBe(expected);
+  });
+
+  test('it should normalize key', () => {
+    const key = [{ c: 'last', b: 'middle', a: 'first' }];
+    const expected = JSON.stringify({ 0: { a: 'first', b: 'middle', c: 'last' } });
+
+    expect(encodeKey(key)).toBe(expected);
+  });
+});

package/src/cache/utils/tests/partialMatch.test.ts

@@ -0,0 +1,13 @@
+import { partialMatch } from '..';
+
+import { post11, post12 } from '~/utils/tests';
+
+describe('cache util > partialMatch', () => {
+  test('it should return true if objects are deep equal', () => {
+    expect(partialMatch(post11, post11)).toBe(true);
+  });
+
+  test('it should return false if objects are not deep equal', () => {
+    expect(partialMatch(post11, post12)).toBe(false);
+  });
+});

package/src/category/api/getCategory.ts

@@ -1,12 +1,12 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { pullFromCache, dropFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
  * import { getCategory } from '@amityco/ts-sdk'
- * const category = await getCategory('foo')
+ * const { data: category } = await getCategory('foo')
  * ```
  *
  * Fetches a {@link Amity.Category} object
@@ -18,18 +18,53 @@ import { ingestInCache } from '~/core/cache'
  * @async
  */
 export const getCategory = async (
-  categoryId: Amity.Category['categoryId']
-) => {
-  const client = getActiveClient()
-  client.log('category/getCategory', categoryId)
+  categoryId: Amity.Category['categoryId'],
+): Promise<Amity.Cached<Amity.Category>> => {
+  const client = getActiveClient();
+  client.log('category/getCategory', categoryId);
 
   const { data } = await client.http.get<Amity.CategoryPayload>(
-    `/api/v3/community-categories/${categoryId}`
-  )
+    `/api/v3/community-categories/${encodeURIComponent(categoryId)}`,
+  );
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { categories } = data
-  return categories[0]
-}
+  const { categories } = data;
+
+  return {
+    data: categories.find(category => category.categoryId === categoryId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getCategory } from '@amityco/ts-sdk'
+ * const { data: category } = getCategory.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Category} object from cache
+ *
+ * @param categoryId the ID of the {@link Amity.Category} to fetch
+ * @returns the associated {@link Amity.Category} object
+ *
+ * @category Category API
+ */
+getCategory.locally = (
+  categoryId: Amity.Category['categoryId'],
+): Amity.Cached<Amity.Category> | undefined => {
+  const client = getActiveClient();
+  client.log('category/getCategory.locally', categoryId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Category>(['category', 'get', categoryId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/category/api/index.ts

@@ -1,2 +1,2 @@
-export * from './queryCategories'
-export * from './getCategory'
+export * from './queryCategories';
+export * from './getCategory';

package/src/category/api/queryCategories.ts

@@ -1,13 +1,18 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { decoratePayload, toPage, toToken } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { toToken, toPage } from '~/core/query';
 
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+
+/* begin_public_function
+  id: community.category.query
+*/
 /**
  * ```js
  * import { queryCategories } from '@amityco/ts-sdk'
- * const categories = await queryCategories()
+ * const { data: categories, prevPage, nextPage } = await queryCategories()
  * ```
  *
  * Queries a paginable list of {@link Amity.Category} objects
@@ -15,35 +20,92 @@ import { toRecord } from '~/core/model'
  * @param query The query parameters
  * @returns A page of {@link Amity.Category} objects
  *
- * @category Community API
+ * @category Category API
  * @async
- **/
-export const queryCategories = async (query?: {
-  sortBy?: 'lastCreated' | 'firstCreated' | 'name'
-  isDeleted?: Amity.Category['isDeleted']
-  page?: Amity.Page
-}) => {
-  const client = getActiveClient()
-  client.log('category/queryCategories', query)
+ * */
+export const queryCategories = async (
+  query?: Amity.QueryCategories,
+): Promise<Amity.Cached<Amity.Paged<Amity.Category, Amity.Page>>> => {
+  const client = getActiveClient();
+  client.log('category/queryCategories', query);
 
-  const { page, ...params } = query ?? {}
+  const { page = { limit: 10 }, includeDeleted, ...params } = query ?? {};
 
   const { data } = await client.http.get<Amity.CategoryPayload & Amity.Pagination>(
-    `/api/v3/community-categories`, { params : {
-      ...params,
-      options: {
-        token: toToken(page, 'skiplimit')
-      }
-    } })
+    `/api/v3/community-categories`,
+    {
+      params: {
+        ...params,
+        isDeleted: includeDeleted === false ? false : undefined,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const { categories } = payload;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.CategoryPayload, { cachedAt });
+
+    const cacheKey = [
+      'category',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { categories: categories.map(getResolver('category')), paging });
+  }
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: categories, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { queryCategories } from '@amityco/ts-sdk'
+ * const { data: categories, prevPage, nextPage } = queryCategories.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Category} objects from cache
+ *
+ * @param query The query parameters
+ * @returns categories
+ *
+ * @category category API
+ */
+queryCategories.locally = (
+  query: Parameters<typeof queryCategories>[0],
+): Amity.Cached<Amity.Paged<Amity.Category, Amity.Page>> | undefined => {
+  const client = getActiveClient();
+  client.log('category/queryCategories.locally', query);
+
+  if (!client.cache) return;
+
+  const { page = { limit: 10 }, ...params } = query ?? {};
+
+  const queryKey = ['category', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const { data, cachedAt } =
+    pullFromCache<{ categories: Pick<Amity.Category, 'categoryId'>[] } & Amity.Pagination>(
+      queryKey,
+    ) ?? {};
 
-  const { paging, ...response } = data
+  if (!data?.categories.length) return;
 
-  decoratePayload(response as unknown as Record<string, any[]>)
-  ingestInCache(response as unknown as Record<string, any[]>)
+  const categories: Amity.Category[] = data.categories
+    .map(categoryId => pullFromCache<Amity.Category>(['category', 'get', categoryId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
 
-  const prevPage = toPage(paging?.previous)
-  const nextPage = toPage(paging?.next)
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
 
-  const { categories } = response
-  return [toRecord(categories), { prevPage, nextPage }] as const
-}
+  return categories.length === data?.categories?.length
+    ? { data: categories, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/category/observers/index.ts

@@ -0,0 +1 @@
+export * from './liveCategories';

package/src/category/observers/liveCategories.ts

@@ -0,0 +1,143 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByLastCreated,
+  sortByName,
+  sortByFirstCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { queryCategories } from '../api';
+
+/**
+ * ```js
+ * import { liveCategories } from '@amityco/ts-sdk'
+ *
+ * let categories = []
+ * const unsub = liveCategories({}, response => merge(categories, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Category}s
+ *
+ * @param params for querying categories
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the categories
+ *
+ * @category Category Live Collection
+ */
+export const liveCategories = (
+  params: Amity.CategoryLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Category>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveCategories(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = ['category', 'collection', {}];
+
+  const responder = (data: Amity.CategoryLiveCollectionCache) => {
+    let categories: Amity.Category[] =
+      data.data
+        .map(categoryId => pullFromCache<Amity.Category>(['category', 'get', categoryId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    if (params.includeDeleted === false) {
+      categories = filterByPropEquality(categories, 'isDeleted', false);
+    }
+
+    switch (params.sortBy) {
+      case 'firstCreated':
+        categories = categories.sort(sortByFirstCreated);
+        break;
+
+      case 'lastCreated':
+        categories = categories.sort(sortByLastCreated);
+        break;
+
+      default:
+        categories = categories.sort(sortByName);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: categories,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  /*
+   * const realtimeRouter = () => {
+   * @TODO: At the time of creating this method category does not have any
+   * observers
+   *};
+   */
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.CategoryLiveCollectionCache>(cacheKey)?.data;
+
+    const categories = collection?.data ?? [];
+
+    if (categories.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryCategories, {
+      ...queryParams,
+      page: collection?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: categories,
+        };
+
+        if (result) {
+          data.data = [...new Set([...categories, ...result.map(getResolver('category'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(() => {
+    // @TODO -> update once observers added
+  });
+
+  onFetch();
+
+  return () => {
+    log(`liveCategories(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};