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

package/src/cache/api/isInTombstone.ts

@@ -1,41 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { ASCApiError } from '~/core/errors';
-import { pullFromCache } from '~/cache/api';
-import { isFresh, queryOptions } from '~/core/query';
-import { CACHE_KEY_TOMBSTONE, CACHE_LIFESPAN_TOMBSTONE } from '~/cache/utils';
-
-/**
- * ```js
- * import { isInTombstone } from '@amityco/ts-sdk'
- * const user = isInTombstone(["message", "messageId"])
- * ```
- *
- * Checks if the {@link Amity.TombstoneCacheOptions} exists
- * in cache and it's not expired means it's in tombstone
- * and we throw an Error
- *
- * @param model the model to check
- * @param modelId the object id to check
- * @returns the matching cache entry, or undefined.
- *
- * @category Cache API
- */
-export const isInTombstone = (model: Amity.Domain, modelId: string) => {
-  const { log, cache } = getActiveClient();
-  const key = [model, CACHE_KEY_TOMBSTONE, modelId];
-
-  if (!cache) return;
-  log('cache/api/isInTombstone', key);
-
-  const isInTombstone = pullFromCache<Amity.TombstoneCacheOptions>(key);
-  const { lifeSpan } = queryOptions('cache_then_server', CACHE_LIFESPAN_TOMBSTONE);
-
-  if (isInTombstone && isFresh(isInTombstone.data, lifeSpan)) {
-    throw new ASCApiError(
-      'Item not found!',
-      Amity.ServerError.ITEM_NOT_FOUND,
-      Amity.ErrorLevel.ERROR,
-    );
-  }
-};

package/src/cache/api/mergeInCache.ts

@@ -1,48 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { isOutdated } from '~/core/model';
-
-import { pullFromCache } from './pullFromCache';
-import { pushToCache } from './pushToCache';
-
-/**
- * ```js
- * import { mergeInCache } from '@amityco/ts-sdk'
- *
- * mergeInCache(
- *   ["foo", "bar"],
- *   (oldVal) => ({ ...oldVal, ...newVal }).
- * )
- * ```
- *
- * Merges a new {@link Amity.Cache} object to an {@link Amity.Client} instance
- *
- * @param key the key matching the object to retrieve from cache
- * @param mutation either a plain object to shallow merge, or a function.
- * @returns a success boolean if the object was updated
- *
- * @category Cache API
- */
-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();
-
-  if (!cache) return false;
-  log('cache/api/mergeInCache', { key, mutation });
-
-  const oldVal = pullFromCache<T>(key);
-
-  if (!oldVal) return false;
-
-  const newVal =
-    typeof mutation === 'function' ? mutation(oldVal.data) : { ...oldVal.data, ...mutation };
-
-  if (isOutdated(oldVal.data, newVal)) {
-    return false;
-  }
-
-  pushToCache(key, newVal, options);
-  return true;
-};

package/src/cache/api/pullFromCache.ts

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

@@ -1,42 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { encodeKey } from '../utils';
-
-/**
- * ```js
- * import { pushToCache } from '@amityco/ts-sdk'
- * pushToCache<Amity.InternalUser>(["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) {
-    // eslint-disable-next-line no-param-reassign
-    options.offline = cache.persistIf(key, data);
-  }
-
-  const encodedKey = encodeKey(key);
-  cache.data[encodedKey] = { key, data, ...options };
-
-  return true;
-};

package/src/cache/api/pushToTombstone.ts

@@ -1,33 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { dropFromCache, pushToCache } from '~/cache/api';
-
-import { CACHE_KEY_GET, CACHE_KEY_TOMBSTONE } from '~/cache/utils';
-
-/**
- * ```js
- * import { pushToTombstone } from '@amityco/ts-sdk'
- * pushToTombstone(["message", "messageId"], { cachedAt: Date.now() })
- * ```
- *
- * Removes an existing {@link Amity.CacheEntry} from the {@link Amity.Client}'s
- * {@link Amity.Cache} from a given {@link Amity.CacheKey}
- *
- * @param model the model to remove and push to Tombstone
- * @param modelId the related model id
- *
- * @category Cache API
- * @hidden
- */
-export const pushToTombstone = (model: Amity.Domain, modelId: string) => {
-  const { log, cache } = getActiveClient();
-
-  const cacheKey = [model, CACHE_KEY_TOMBSTONE, modelId];
-  const data: Pick<Amity.CacheOptions, 'cachedAt'> = { cachedAt: Date.now() };
-
-  if (!cache) return;
-  log('cache/api/pushToTombstone', { cacheKey, data });
-
-  dropFromCache([model, CACHE_KEY_GET, modelId], true);
-  pushToCache(cacheKey, data);
-};

package/src/cache/api/queryCache.ts

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

@@ -1,44 +0,0 @@
-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 = 'amitySdk') => {
-  const client = getActiveClient();
-
-  if (!client.cache) return false;
-  client.log('cache/api/restoreCache', { storageKey });
-
-  const serializedData = localStorage
-    ? (await localStorage.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

@@ -1,48 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { queryCache, mergeInCache, dropFromCache } from '.';
-
-/**
- * ```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 }) => {
-    // @ts-ignore
-    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/tests/dropFromCache.test.ts

@@ -1,59 +0,0 @@
-import {
-  connectClient,
-  disconnectClient,
-  post11,
-  channel1,
-  message11,
-  user14,
-  channelPayload,
-} from '~/utils/tests';
-
-import { dropFromCache, enableCache, disableCache, pushToCache, pullFromCache } from '..';
-import { ingestInCache } from '../ingestInCache';
-
-describe('dropFromCache', () => {
-  beforeAll(connectClient);
-  afterAll(disconnectClient);
-
-  beforeEach(enableCache);
-  afterEach(disableCache);
-
-  test('it should return false if cache disabled', () => {
-    disableCache();
-
-    expect(dropFromCache(['post', 'get', 'postId'])).toBe(false);
-  });
-
-  test('it should return false if candidate not in cache', () => {
-    expect(dropFromCache(['post', 'get', 'non-existent-postId'], true)).toBe(false);
-  });
-
-  test('it should delete multiple matches when exact:false', () => {
-    ingestInCache(channelPayload);
-
-    const recieved = dropFromCache(['user', 'get', user14.userId]);
-
-    expect(recieved).toBe(true);
-    expect(pullFromCache(['user', 'get', user14.userId])).toBeUndefined();
-  });
-
-  const cases: [string, boolean, Amity.CacheKey, unknown][] = [
-    ['post', false, ['post', 'get', post11.postId], post11],
-    ['message', false, ['message', 'get', message11.messageId], message11],
-    ['channel', false, ['channel', 'get', channel1.channelId], channel1],
-    ['post', true, ['post', 'get', post11.postId], post11],
-    ['message', true, ['message', 'get', message11.messageId], message11],
-    ['channel', true, ['channel', 'get', channel1.channelId], channel1],
-  ];
-
-  test.each(cases)(
-    'it should delete %s from cache when exact:%s',
-    (candidate, exact, cacheKey, expected) => {
-      pushToCache(cacheKey, expected);
-      const recieved = dropFromCache(cacheKey, exact);
-
-      expect(recieved).toBe(true);
-      expect(pullFromCache(cacheKey)).toBeUndefined();
-    },
-  );
-});

package/src/cache/api/tests/enableCache.test.ts

@@ -1,15 +0,0 @@
-import { connectClient, client, disconnectClient } from '~/utils/tests';
-
-import { enableCache } from '../enableCache';
-
-describe('enableCache', () => {
-  test('it should enable cache', async () => {
-    await connectClient();
-
-    enableCache();
-
-    expect(client.cache).toBeDefined();
-
-    disconnectClient();
-  });
-});

package/src/cache/api/tests/ingestInCache.test.ts

@@ -1,92 +0,0 @@
-import { prepareCommunityPayload } from '~/communityRepository/utils';
-import { PAYLOAD2MODEL, getResolver } from '~/core/model';
-
-import {
-  userPayload,
-  rolePayload,
-  channelPayload,
-  messagePayload,
-  communityPayload,
-  postPayload,
-  pollPayload,
-  followPayload,
-  feedPayload,
-  user11,
-} from '~/utils/tests';
-
-import { enableCache, disableCache, pullFromCache } from '..';
-import { ingestInCache } from '../ingestInCache';
-
-describe('ingestInCache', () => {
-  beforeAll(enableCache);
-  afterAll(disableCache);
-
-  const payloads: [keyof Amity.Models, Record<string, Amity.Model[]>][] = [
-    ['user', userPayload],
-    ['role', rolePayload],
-    ['channel', channelPayload],
-    ['message', messagePayload],
-    ['community', prepareCommunityPayload(communityPayload)],
-    ['post', postPayload],
-    // FIXME: add support for commentChildren in model
-    // ['comment', textCommentPayload],
-    ['poll', pollPayload],
-    // FIXME: correct reactions type in model
-    // ['reaction', reactionPayload],
-    ['follow', followPayload],
-    ['feed', feedPayload],
-  ];
-
-  test.each(payloads)('it should add %s payload to cache', (model, payload) => {
-    ingestInCache(payload);
-
-    Object.entries(payload).forEach(([k, v]) => {
-      const type = PAYLOAD2MODEL[k];
-      const resolver = getResolver(type);
-
-      expect(type).toBeDefined();
-
-      v.forEach(entity => {
-        const received = pullFromCache([type, 'get', resolver(entity)]);
-        return expect(received).toBeDefined();
-      });
-    });
-  });
-
-  test('it should not update cache if model invalid', () => {
-    const invalidPayload = {
-      invalids: [{ invalidId: 'invalidId' }],
-      users: [user11],
-    };
-
-    // @ts-ignore
-    ingestInCache(invalidPayload);
-
-    expect(pullFromCache(['invalid', 'get', 'invalidId'])).toBeUndefined();
-    expect(pullFromCache(['user', 'get', user11.userId])).toBeDefined();
-  });
-});
-
-describe('ingestInCache -> cachedAt', () => {
-  beforeAll(enableCache);
-  afterAll(disableCache);
-
-  test('it should update cache if cachedAt is valid', () => {
-    const now = Date.now();
-    ingestInCache(userPayload, { cachedAt: now });
-
-    const { data, cachedAt } = pullFromCache(['user', 'get', user11.userId])!;
-
-    expect(data).toBeDefined();
-    expect(cachedAt).toBe(now);
-  });
-
-  test('it should update cache if cachedAt is expired', () => {
-    ingestInCache(userPayload, { cachedAt: -1 });
-
-    const { data, cachedAt } = pullFromCache(['user', 'get', user11.userId])!;
-
-    expect(data).toBeDefined();
-    expect(cachedAt).toBe(-1);
-  });
-});

package/src/cache/api/tests/pullFromCache.test.ts

@@ -1,42 +0,0 @@
-import { connectClient, disconnectClient, post11, message11, channel1 } from '~/utils/tests';
-
-import { pullFromCache, enableCache, disableCache, pushToCache } from '..';
-
-describe('pullFromCache', () => {
-  beforeAll(connectClient);
-  afterAll(disconnectClient);
-
-  test('it should return undefined if entity not in cache', () => {
-    enableCache();
-
-    expect(pullFromCache(['post', 'get', 'non-existent-postId'])).toBeUndefined();
-
-    disableCache();
-  });
-
-  test('it should return undefined if cache disabled', () => {
-    disableCache();
-
-    expect(pullFromCache(['post', 'get', 'post-id'])).toBeUndefined();
-  });
-
-  const cases: [string, Amity.CacheKey, unknown][] = [
-    ['post', ['post', 'get', post11.postId], post11],
-    ['message', ['message', 'get', message11.messageId], message11],
-    ['channel', ['channel', 'get', channel1.channelId], channel1],
-  ];
-
-  test.each(cases)('it should return %s from cache', (type, cacheKey, expected) => {
-    enableCache();
-
-    pushToCache(cacheKey, expected);
-
-    const recieved = pullFromCache(cacheKey);
-
-    expect(recieved).toBeDefined();
-    expect(recieved?.data).toBeDefined();
-    expect(recieved?.data).toBe(expected);
-
-    disableCache();
-  });
-});

package/src/cache/api/tests/pushToCache.test.ts

@@ -1,57 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { connectClient, disconnectClient, user11 } from '~/utils/tests';
-
-import { pushToCache, enableCache, disableCache, pullFromCache } from '..';
-import { encodeKey } from '../../utils';
-
-describe('pushToCache', () => {
-  beforeAll(connectClient);
-  afterAll(disconnectClient);
-
-  describe('- cache enabled', () => {
-    beforeEach(enableCache);
-    afterEach(disableCache);
-
-    const cacheKey = ['user', 'get', user11.userId];
-
-    test('it should return true if data added to cache', () => {
-      const recieved = pushToCache(cacheKey, user11);
-
-      expect(recieved).toBe(true);
-    });
-
-    test('it should add data to cache', () => {
-      const returned = pushToCache(cacheKey, user11);
-      const recieved = pullFromCache(cacheKey)?.data;
-
-      expect(returned).toBe(true);
-      expect(recieved).toBe(user11);
-    });
-
-    test('it should persist data offline', () => {
-      const { cache } = getActiveClient();
-      const encodedKey = encodeKey(cacheKey);
-      const options = { offline: true, cachedAt: Date.now() };
-
-      const addedUser = pushToCache(cacheKey, user11, options);
-
-      const expected = {
-        key: cacheKey,
-        data: user11,
-        ...options,
-      };
-      const recieved = cache?.data[encodedKey];
-
-      expect(addedUser).toBe(true);
-      expect(recieved).toStrictEqual(expected);
-    });
-  });
-
-  describe('- no cache', () => {
-    test('it should return false if no cache', () => {
-      const recieved = pushToCache(['model', 'key', 'modleId'], {});
-
-      expect(recieved).toBe(false);
-    });
-  });
-});

package/src/cache/api/tests/upsertInCache.test.ts

@@ -1,60 +0,0 @@
-import { connectClient, disconnectClient, post11, message11, channel1 } from '~/utils/tests';
-
-import { upsertInCache, enableCache, disableCache, pullFromCache } from '..';
-
-describe('upsertInCache', () => {
-  beforeAll(connectClient);
-  afterAll(() => {
-    disableCache();
-    disconnectClient();
-  });
-
-  const cacheKey = ['post', 'get', 'test-candidate-id'];
-
-  test('it should add candidate to cache if non-existent', () => {
-    enableCache();
-
-    expect(upsertInCache(cacheKey, post11)).toBe(true);
-    expect(pullFromCache(cacheKey)?.data).toBe(post11);
-
-    disableCache();
-  });
-
-  test('it should return false if cache disabled', () => {
-    disableCache();
-
-    expect(upsertInCache(cacheKey, post11)).toBe(false);
-  });
-
-  test('it should update cachedAt value', () => {
-    enableCache();
-
-    const now = Date.now();
-
-    expect(upsertInCache(cacheKey, post11, { cachedAt: now })).toBe(true);
-    expect(pullFromCache(cacheKey)?.cachedAt).toBe(now);
-
-    disableCache();
-  });
-
-  // create table of tests for message, post, channel
-  const cases: [string, Amity.CacheKey, Record<string, unknown>][] = [
-    ['post', ['post', 'get', post11.postId], post11],
-    ['message', ['message', 'get', message11.messageId], message11],
-    ['channel', ['channel', 'get', channel1.channelId], channel1],
-    ['post', ['post', 'get', post11.postId], { ...post11, channelId: 'altered' }],
-    ['message', ['message', 'get', message11.messageId], { ...message11, userId: 'updated-user' }],
-    ['channel', ['channel', 'get', channel1.channelId], { ...channel1, displayName: 'updated' }],
-  ];
-
-  // cache is not disabled, so as to test update
-  test.each(cases)('it should update %s in cache', (type, cacheKey, expected) => {
-    enableCache();
-
-    const recieved = upsertInCache(cacheKey, expected);
-
-    expect(recieved).toBe(true);
-    expect(pullFromCache(cacheKey)?.data).toBeDefined();
-    expect(pullFromCache(cacheKey)?.data).toStrictEqual(expected);
-  });
-});