@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

package/src/cache/api/upsertInCache.ts

@@ -1,37 +0,0 @@
-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.InternalUser>(["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

@@ -1,34 +0,0 @@
-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 = {};
-  if (localStorage) {
-    await localStorage.setItem(`${storageKey}#${userId}`, '{}');
-  }
-
-  return true;
-};

package/src/cache/utils/index.ts

@@ -1,99 +0,0 @@
-// cache constants
-import { MINUTE, SECOND } from '~/utils/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_SHORTEN_LIFESPAN = 2 * SECOND;
-export const CACHE_LIFESPAN = 1 * MINUTE; // 1 minute
-export const CACHE_LIFESPAN_TOMBSTONE = 3 * MINUTE; // 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

@@ -1,19 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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/categoryRepository/api/getCategory.ts

@@ -1,77 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { pullFromCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: community.category.get
-*/
-/**
- * ```js
- * import { getCategory } from '@amityco/ts-sdk'
- * const { data: category } = await getCategory('foo')
- * ```
- *
- * Fetches a {@link Amity.Category} object
- *
- * @param categoryId the ID of the {@link Amity.Category} to fetch
- * @returns the associated {@link Amity.Category} object
- *
- * @category Category API
- * @async
- */
-export const getCategory = async (
-  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/${encodeURIComponent(categoryId)}`,
-  );
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  const { categories } = data;
-
-  return {
-    data: LinkedObject.category(
-      (categories ?? []).find(category => category.categoryId === categoryId)!,
-    ),
-    cachedAt,
-  };
-};
-/* end_public_function */
-
-/**
- * ```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.InternalCategory>(['category', 'get', categoryId]);
-
-  if (!cached) return;
-
-  return {
-    data: LinkedObject.category(cached.data),
-    cachedAt: cached.cachedAt,
-  };
-};

package/src/categoryRepository/api/index.ts

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

package/src/categoryRepository/index.ts

@@ -1,2 +0,0 @@
-export * from './api';
-export * from './observers';

package/src/categoryRepository/internalApi/getCategory.ts

@@ -1,43 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { pullFromCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-export const getCategory = async (
-  categoryId: Amity.InternalCategory['categoryId'],
-): Promise<Amity.Cached<Amity.InternalCategory>> => {
-  const client = getActiveClient();
-  client.log('category/getCategory', categoryId);
-
-  const { data } = await client.http.get<Amity.CategoryPayload>(
-    `/api/v3/community-categories/${encodeURIComponent(categoryId)}`,
-  );
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  const { categories } = data;
-
-  return {
-    data: categories.find(category => category.categoryId === categoryId)!,
-    cachedAt,
-  };
-};
-
-getCategory.locally = (
-  categoryId: Amity.InternalCategory['categoryId'],
-): Amity.Cached<Amity.InternalCategory> | undefined => {
-  const client = getActiveClient();
-  client.log('category/getCategory.locally', categoryId);
-
-  if (!client.cache) return;
-
-  const cached = pullFromCache<Amity.InternalCategory>(['category', 'get', categoryId]);
-
-  if (!cached) return;
-
-  return {
-    data: cached.data,
-    cachedAt: cached.cachedAt,
-  };
-};

package/src/categoryRepository/internalApi/index.ts

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

package/src/categoryRepository/internalApi/queryCategories.ts

@@ -1,95 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { toPage } from '~/core/query';
-
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { getResolver } from '~/core/model';
-
-import { inferIsDeleted } from '~/utils/inferIsDeleted';
-
-export const queryCategories = async (
-  query?: Amity.QueryCategories,
-): Promise<Amity.Cached<Amity.PageToken<Amity.InternalCategory>>> => {
-  const client = getActiveClient();
-  client.log('category/queryCategories', query);
-
-  const { page, limit, includeDeleted, ...params } = query ?? {};
-
-  const options = (() => {
-    if (page) return { token: page };
-    if (limit) return { limit };
-
-    return undefined;
-  })();
-
-  const { data } = await client.http.get<Amity.CategoryPayload & Amity.Pagination>(
-    `/api/v3/community-categories`,
-    {
-      params: {
-        ...params,
-        isDeleted: inferIsDeleted(includeDeleted),
-        options,
-      },
-    },
-  );
-
-  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, includeDeleted, options } as Amity.Serializable,
-    ];
-    pushToCache(cacheKey, { categories: categories?.map(getResolver('category')), paging });
-  }
-
-  return {
-    data: categories ?? [],
-    cachedAt,
-    paging,
-  };
-};
-
-queryCategories.locally = (
-  query: Parameters<typeof queryCategories>[0],
-): Amity.Cached<Amity.PageToken<Amity.InternalCategory>> | undefined => {
-  const client = getActiveClient();
-  client.log('category/queryCategories.locally', query);
-
-  if (!client.cache) return;
-
-  const { page, limit = 10, ...params } = query ?? {};
-
-  const options = (() => {
-    if (page) return { token: page };
-    if (limit) return { limit };
-
-    return undefined;
-  })();
-
-  const queryKey = ['category', 'query', { ...params, options } as Amity.Serializable];
-  const { data, cachedAt } =
-    pullFromCache<{ categories: Pick<Amity.InternalCategory, 'categoryId'>[] } & Amity.Pagination>(
-      queryKey,
-    ) ?? {};
-
-  if (!data?.categories.length) return;
-
-  const categories: Amity.InternalCategory[] = data.categories
-    .map(categoryId => pullFromCache<Amity.InternalCategory>(['category', 'get', categoryId])!)
-    .filter(Boolean)
-    .map(({ data }) => data);
-
-  const { paging } = data;
-
-  return categories.length === data?.categories?.length
-    ? { data: categories, cachedAt, paging }
-    : undefined;
-};

package/src/categoryRepository/observers/getCategories.ts

@@ -1,149 +0,0 @@
-/* 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 '../internalApi/queryCategories';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: community.category.query
-*/
-/**
- * ```js
- * import { getCategories } from '@amityco/ts-sdk'
- *
- * let categories = []
- * const unsub = getCategories({}, 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 getCategories = (
-  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(`getCategories(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.InternalCategory>(['category', 'get', categoryId])!)
-        .filter(Boolean)
-        .map(({ data }) => LinkedObject.category(data)) ?? [];
-
-    if (!params.includeDeleted) {
-      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 = (initial = false) => {
-    const collection = pullFromCache<Amity.CategoryLiveCollectionCache>(cacheKey)?.data;
-
-    const categories = collection?.data ?? [];
-
-    if (!initial && categories.length > 0 && !collection?.params.page) return;
-
-    const query = createQuery(queryCategories, {
-      ...queryParams,
-      limit: initial ? limit : undefined,
-      page: !initial ? collection?.params.page : undefined,
-    });
-
-    runQuery(
-      query,
-      ({ data: result, error, loading, paging }) => {
-        const data = {
-          loading,
-          error,
-          params: { page: paging?.next },
-          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(true);
-
-  return () => {
-    log(`getCategories(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};
-/* end_public_function */

package/src/categoryRepository/observers/index.ts

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