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

package/src/cache/api/ingestInCache.ts

@@ -0,0 +1,29 @@
+import { PAYLOAD2MODEL, getResolver } from '~/core/model';
+
+import { upsertInCache } from './upsertInCache';
+
+/**
+ * Ingest a payload (v3) into the cache
+ *
+ * @param payload a "backend v3" payload object
+ * @param options caching options like cachedAt or offline
+ *
+ * @category Cache
+ * @hidden
+ */
+export const ingestInCache = (
+  payload: Record<keyof typeof PAYLOAD2MODEL, Amity.Model[]> = {},
+  options?: Amity.CacheOptions,
+) => {
+  Object.entries(payload).forEach(([key, models]) => {
+    const type = PAYLOAD2MODEL[key];
+    if (!type) return;
+
+    const resolver = getResolver(type);
+    if (!resolver) return;
+
+    models.forEach(model => {
+      upsertInCache([type, 'get', resolver(model)], model, options);
+    });
+  });
+};

package/src/cache/api/isInTombstone.ts

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

@@ -0,0 +1,43 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+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 };
+
+  pushToCache(key, newVal, options);
+  return true;
+};

package/src/cache/api/pullFromCache.ts

@@ -0,0 +1,31 @@
+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,42 @@
+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) {
+    // 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

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

@@ -0,0 +1,34 @@
+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,44 @@
+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 = '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,48 @@
+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

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

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

@@ -0,0 +1,92 @@
+import { prepareCommunityPayload } from '~/community/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

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

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

@@ -0,0 +1,60 @@
+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);
+  });
+});