@amityco/ts-sdk 0.0.1-beta.30 → 0.0.1-beta.32

package/src/@types/core/live.ts

@@ -2,12 +2,18 @@ export {};
 
 declare global {
   namespace Amity {
-    type LiveCollection<T extends any> = {
-      data: T[];
-      onNextPage: () => void;
-      hasNextPage: boolean;
+    type LiveObject<T extends any> = {
+      data: T;
       error?: any;
       loading: boolean;
+      origin?: 'local' | 'server' | 'event';
+    };
+
+    type LiveObjectCallback<T extends any> = Amity.Listener<LiveObject<T>>;
+
+    type LiveCollection<T extends any> = LiveObject<T[]> & {
+      onNextPage: () => void;
+      hasNextPage: boolean;
     };
 
     type LiveCollectionCallback<T extends any> = Amity.Listener<LiveCollection<T>>;

package/src/@types/core/query.ts

@@ -33,7 +33,7 @@ declare global {
       args: Args;
     };
 
-    type QueryPolicy = 'server_only' | 'cache_only' | 'cache_then_server' | 'no_fetch';
+    type QueryPolicy = 'cache_only' | 'cache_then_server' | 'no_fetch';
 
     type QueryOptions = {
       lifeSpan: number;

package/src/@types/domains/channel.ts

@@ -4,6 +4,12 @@ declare global {
   namespace Amity {
     type ChannelType = 'broadcast' | 'conversation' | 'community' | 'live';
 
+    type ChannelMemberActionType =
+      | 'onMemberAdded'
+      | 'onMemberRemoved'
+      | 'onChannelMemberBanned'
+      | 'onChannelMemberUnbanned';
+
     type ChannelActionType =
       | 'onFetch'
       | 'onCreate'

package/src/@types/domains/message.ts

@@ -1,18 +1,21 @@
-export {};
+export const MessageContentType = Object.freeze({
+  TEXT: 'text',
+  IMAGE: 'image',
+  FILE: 'file',
+  VIDEO: 'video',
+  AUDIO: 'audio',
+  CUSTOM: 'custom',
+});
 
 declare global {
   namespace Amity {
-    type MessageContentType = 'text' | 'file' | 'image' | 'video' | 'audio' | 'custom';
+    type MessageContentType = ValueOf<typeof MessageContentType>;
 
-    type MessageContent<T extends Amity.MessageContentType = any> = T extends
-      | 'file'
-      | 'image'
-      | 'video'
-      | 'audio'
-      ? { fileId: string }
-      : unknown;
+    type MessageContent<T extends Amity.MessageContentType = any> = {
+      fileId: T extends 'file' | 'image' | 'video' | 'audio' ? string : null;
+    };
 
-    type MessageActionType = 'onCreate' | 'onUpdate' | 'onDelete';
+    type MessageActionType = 'onCreate' | 'onUpdate' | 'onDelete' | 'onFetch';
 
     type Message<T extends Amity.MessageContentType = any> = {
       messageId: string;

package/src/@types/domains/post.ts

@@ -1,11 +1,18 @@
-export {};
+export const PostContentType = Object.freeze({
+  TEXT: 'text',
+  IMAGE: 'image',
+  FILE: 'file',
+  VIDEO: 'video',
+  LIVESTREAM: 'liveStream',
+  POLL: 'poll',
+});
 
 declare global {
   namespace Amity {
     // bad hack until we get proper feed objects in backend
     type PostTargetType = Amity.FeedType | 'content';
 
-    type PostContentType = 'text' | 'image' | 'file' | 'video' | 'liveStream' | 'poll';
+    type PostContentType = ValueOf<typeof PostContentType>;
 
     type PostActionType =
       | 'onFetch'
@@ -46,7 +53,7 @@ declare global {
       targetId: string;
       targetType: Amity.Post['targetType'];
       sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
-      dataType?: string;
+      dataType?: Exclude<Amity.PostContentType, 'text'>;
       isDeleted?: Amity.Post['isDeleted'];
       hasFlag?: boolean;
       feedType?: 'reviewing' | 'published';

package/src/@types/domains/user.ts

@@ -2,6 +2,14 @@ export {};
 
 declare global {
   namespace Amity {
+    type UserActionType =
+      | 'onFetch'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onFlagCleared';
+
     type User = {
       _id: string;
       userId: string;

package/src/@types/index.ts

@@ -21,10 +21,8 @@ import './domains/reaction';
 
 import './domains/group';
 import './domains/channel';
-import './domains/message';
 
 import './domains/category';
-import './domains/post';
 import './domains/comment';
 
 import './domains/stream';
@@ -36,3 +34,5 @@ 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/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/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/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/channel/api/addChannelMembers.ts

@@ -36,7 +36,15 @@ export const addChannelMembers = async (
 
   if (client.cache) ingestInCache(data);
 
-  fireEvent('v3.channel.didAddUsers', data);
+  /*
+   * should fire event for each user that was added
+   */
+  userIds.forEach(id =>
+    fireEvent('v3.channel.didAddUsers', {
+      ...data,
+      channelUsers: data.channelUsers.filter(u => u.userId === id),
+    }),
+  );
 
   const { channelUsers } = data;
   return !!channelUsers.find(

package/src/channel/api/getChannel.ts

@@ -3,6 +3,10 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
 import { prepareChannelPayload } from '../utils';
 
 /**
@@ -25,12 +29,23 @@ export const getChannel = async (
   const client = getActiveClient();
   client.log('channel/getChannel', channelId);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data: payload } = await client.http.get<Amity.ChannelPayload>(
-    `/api/v3/channels/${encodeURIComponent(channelId)}`,
-  );
+  isInTombstone('channel', channelId);
+
+  let data: Amity.ChannelPayload<any, Amity.Channel>;
+
+  try {
+    const { data: payload } = await client.http.get<Amity.ChannelPayload>(
+      `/api/v3/channels/${encodeURIComponent(channelId)}`,
+    );
+
+    data = prepareChannelPayload(payload);
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('channel', channelId);
+    }
 
-  const data = prepareChannelPayload(payload);
+    throw error;
+  }
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/channel/api/queryChannelMembers.ts

@@ -1,6 +1,9 @@
 import { getActiveClient } from '~/client/api';
 
 import { toPage, toToken } from '~/core/query';
+import { getResolver } from '~/core/model';
+
+import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
@@ -25,11 +28,11 @@ export const queryChannelMembers = async (
   const client = getActiveClient();
   client.log('channel/queryChannelMembers', query);
 
-  const { page, channelId, ...params } = query ?? {};
+  const { page = { limit: 10 }, ...params } = query ?? {};
 
   const { data: queryPayload } = await client.http.get<
     Amity.ChannelMembershipPayload & Amity.Pagination
-  >(`/api/v4/channels/${encodeURIComponent(channelId)}/users`, {
+  >(`/api/v4/channels/${encodeURIComponent(params.channelId)}/users`, {
     params: {
       ...params,
       options: {
@@ -47,6 +50,19 @@ export const queryChannelMembers = async (
   const cachedAt = client.cache && Date.now();
   if (client.cache) {
     ingestInCache(data as Amity.ChannelMembershipPayload);
+
+    const cacheKey = [
+      'channelUsers',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+
+    pushToCache(cacheKey, {
+      channelUsers: channelUsers.map(({ channelId, userId }) =>
+        getResolver('channelUsers')({ channelId, userId }),
+      ),
+      paging,
+    });
   }
 
   const nextPage = toPage(paging.next);
@@ -68,9 +84,41 @@ export const queryChannelMembers = async (
  *
  * @category Post API
  */
-queryChannelMembers.locally = (query: Parameters<typeof queryChannelMembers>[0]) => {
+queryChannelMembers.locally = (
+  query: Parameters<typeof queryChannelMembers>[0],
+): Amity.Cached<Amity.Paged<Amity.Membership<'channel'>>> | undefined => {
   const client = getActiveClient();
-  client.log('channel/queryChannelMembers', query);
+  client.log('channel/queryChannelMembers.locally', query);
+
+  if (!client.cache) return;
+
+  const { page = { limit: 10 }, ...params } = query;
+
+  const cacheKey = [
+    'channelUsers',
+    'query',
+    { ...params, options: { ...page } } as Amity.Serializable,
+  ];
+
+  const { data, cachedAt } =
+    pullFromCache<
+      {
+        channelUsers: Pick<Amity.Membership<'channel'>, 'channelId' | 'userId'>[];
+      } & Amity.Pagination
+    >(cacheKey) ?? {};
+
+  if (!data?.channelUsers.length) return;
+
+  const channelUsers: Amity.Membership<'channel'>[] = data.channelUsers
+    // ck -> cacheKey, abbrevated to avoid confusion from the above cache key
+    .map(ck => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', ck])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
 
-  // TODO
+  return channelUsers.length === data?.channelUsers?.length
+    ? { data: channelUsers, cachedAt, prevPage, nextPage }
+    : undefined;
 };

package/src/channel/api/queryChannels.ts

@@ -1,10 +1,11 @@
 import { getActiveClient } from '~/client/api';
 
 import { toPage, toToken } from '~/core/query';
-import { pushToCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
 import { prepareChannelPayload } from '../utils';
 
 /**
@@ -86,9 +87,35 @@ export const queryChannels = async (
  *
  * @category Channel API
  */
-queryChannels.locally = (query: Parameters<typeof queryChannels>[0]) => {
+queryChannels.locally = (
+  query?: Parameters<typeof queryChannels>[0],
+): Amity.Cached<Amity.Paged<Amity.Channel>> | undefined => {
   const client = getActiveClient();
   client.log('channel/queryChannels.locally', query);
 
-  // TODO
+  const { page = { limit: 10 }, ...params } = query ?? {};
+
+  const cacheKey = ['channel', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+
+  const { data, cachedAt } =
+    pullFromCache<
+      {
+        channels: Pick<Amity.Channel, 'channelId'>[];
+      } & Amity.Pagination
+    >(cacheKey) ?? {};
+
+  if (!data?.channels.length) return;
+
+  const channels: Amity.Channel[] = data.channels
+    // ck -> cacheKey, abbrevated to avoid confusion from the above cache key
+    .map(ck => pullFromCache<Amity.Channel>(['channel', 'get', ck])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return channels.length === data?.channels?.length
+    ? { data: channels, cachedAt, prevPage, nextPage }
+    : undefined;
 };

package/src/channel/api/tests/addChannelMembers.test.ts

@@ -0,0 +1,95 @@
+import { getResolver } from '~/core/model';
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  channelUserQueryResponse,
+  channelUser1,
+  channelUser3,
+  channel11,
+} from '~/utils/tests';
+
+import { onChannelMemberAdded } from '~/channel/events';
+import { addChannelMembers } from '../addChannelMembers';
+
+describe('addChannelMembers', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const { userId } = channelUser1;
+
+  test('it should add channel members in channel', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await addChannelMembers(channelId, [userId]);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache with channel members', async () => {
+    enableCache();
+
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const channelUserCacheKey = getResolver('channelUsers')({
+      channelId,
+      userId,
+    });
+
+    const recieved = await addChannelMembers(channelId, [userId]);
+    const channelUser = pullFromCache<Amity.Membership<'channel'>>([
+      'channelUsers',
+      'get',
+      channelUserCacheKey,
+    ])?.data;
+
+    expect(recieved).toBe(true);
+    expect(channelUser).toBeDefined();
+    expect(channelUser).toBe(channelUser1);
+
+    disableCache();
+  });
+
+  test('it should fire event when new members added', async () => {
+    expect.assertions(1);
+
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+    let dispose;
+
+    const callback = new Promise(resolve => {
+      dispose = onChannelMemberAdded(resolve);
+    }).finally(dispose);
+
+    await addChannelMembers(channelId, [userId]);
+
+    return expect(callback).resolves.not.toThrow();
+  });
+
+  test('it should fire event with all new members', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const callback = jest.fn();
+    const { userId: userId2 } = channelUser3;
+    const unsub = onChannelMemberAdded(callback);
+
+    const recieved = await addChannelMembers(channelId, [userId, userId2]);
+
+    expect(recieved).toBe(true);
+
+    await pause();
+
+    /*
+     * Assertion below is required to check if the event handler is called with the right
+     * params. It's not enough to check if the handler does not throw
+     */
+    expect(callback).toHaveBeenNthCalledWith(1, { ...channel11 }, { ...channelUser1 });
+    expect(callback).toHaveBeenNthCalledWith(2, { ...channel11 }, { ...channelUser3 });
+
+    unsub();
+  });
+
+  test('it should return an error', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(addChannelMembers('channelId', [])).rejects.toThrow('error');
+  });
+});