@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/@types/index.ts

@@ -8,25 +8,22 @@ import './core/events'; // sdk events definitions
 import './core/paging'; // createQuery, runQuery
 import './core/query'; // createQuery, runQuery
 import './core/cache'; // cache.pull('user', ...)
+import './core/live';
 
 // domains
 import './domains/client'; // client definition
 
 import './domains/user';
 import './domains/follow';
-import './domains/file';
 
 import './domains/partials'; // small model partials (CreatedAt, etc...)
-import './domains/content'; // content partial
 import './domains/reaction';
 
 import './domains/group';
 import './domains/channel';
-import './domains/message';
+import './domains/subChannel';
 
-import './domains/community';
 import './domains/category';
-import './domains/post';
 import './domains/comment';
 
 import './domains/stream';
@@ -34,3 +31,9 @@ import './domains/stream';
 import './domains/mention';
 
 import './domains/poll';
+
+export * from './domains/community';
+export * from './domains/content';
+export * from './domains/file';
+export * from './domains/message';
+export * from './domains/post';

package/src/cache/api/backupCache.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import AsyncStorage from '@react-native-async-storage/async-storage';
 
 import { getActiveClient } from '~/client/api/activeClient';

package/src/cache/api/index.ts

@@ -18,6 +18,7 @@ export * from './upsertInCache';
 export * from './dropFromCache';
 
 /*
- * ingestInCache and syncInCache are not exported ;
+ * ingestInCache and syncInCache and isInTombstone
+ * and pushToTombstone are not exported ;
  * we don't want it as part of the sdk's public api.
  */

package/src/cache/api/ingestInCache.ts

@@ -6,13 +6,13 @@ import { upsertInCache } from './upsertInCache';
  * Ingest a payload (v3) into the cache
  *
  * @param payload a "backend v3" payload object
- * @param order the order of the keys to process (in case of need)
+ * @param options caching options like cachedAt or offline
  *
  * @category Cache
  * @hidden
  */
 export const ingestInCache = (
-  payload: Record<string, Record<string, unknown>[]> = {},
+  payload: Record<keyof typeof PAYLOAD2MODEL, Amity.Model[]> = {},
   options?: Amity.CacheOptions,
 ) => {
   Object.entries(payload).forEach(([key, models]) => {
@@ -20,13 +20,10 @@ export const ingestInCache = (
     if (!type) return;
 
     const resolver = getResolver(type);
+    if (!resolver) return;
+
     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,
-      );
+      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/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/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);
+  });
+});

package/src/cache/utils/index.ts

@@ -1,3 +1,12 @@
+// 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
  *
@@ -72,3 +81,16 @@ export const partialMatch = (predicate: any, candidate: any): boolean => {
  */
 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/queryCategories.ts

@@ -6,6 +6,9 @@ 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'
@@ -20,21 +23,20 @@ import { getResolver } from '~/core/model';
  * @category Category API
  * @async
  * */
-export const queryCategories = async (query?: {
-  sortBy?: 'lastCreated' | 'firstCreated' | 'name';
-  isDeleted?: Amity.Category['isDeleted'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Category, Amity.Page>>> => {
+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 = { limit: 10 }, ...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,
+        isDeleted: includeDeleted === false ? false : undefined,
         options: {
           token: toToken(page, 'skiplimit'),
         },

package/src/category/observers/index.ts

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