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

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/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/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/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/queryChannelMembers.test.ts

@@ -0,0 +1,115 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '~/channel/utils';
+import { client, channelUserQueryResponse } from '~/utils/tests';
+
+import { queryChannelMembers } from '../queryChannelMembers';
+
+describe('queryChannelMembers', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+
+  test('it should return channel members', async () => {
+    const expected = channelUserQueryResponse.data.channelUsers;
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    const { data } = await queryChannelMembers({ channelId });
+
+    expect(data).toEqual(expected);
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryChannelMembers({ channelId })).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    const { data: got } = await queryChannelMembers({ channelId });
+    const { data } = queryChannelMembers.locally({ channelId })!;
+
+    expect(data).toBeDefined();
+    expect(got).toEqual(data);
+
+    disableCache();
+  });
+});
+
+describe('queryChannelMembers.locally', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const cacheKey = [
+    'channelUsers',
+    'query',
+    { channelId, options: { limit: 10, after: undefined } },
+  ];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelUserQueryResponse.data;
+    const data = prepareChannelPayload(payload);
+    const { channelUsers } = data;
+
+    ingestInCache(data as Amity.ChannelMembershipPayload);
+
+    pushToCache(cacheKey, {
+      channelUsers: channelUsers.map(({ channelId, userId }) =>
+        getResolver('channelUsers')({ channelId, userId }),
+      ),
+      paging,
+    });
+
+    const { data: got } = queryChannelMembers.locally({ channelId })!;
+
+    expect(got).toBeDefined();
+    expect(got).toEqual(channelUsers);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelUserQueryResponse.data;
+    const data = prepareChannelPayload(payload);
+    const { channelUsers } = data;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...data,
+      channelUsers: [data.channelUsers[0]],
+    } as Amity.ChannelMembershipPayload);
+
+    pushToCache(cacheKey, {
+      channelUsers: channelUsers.map(({ channelId, userId }) =>
+        getResolver('channelUsers')({ channelId, userId }),
+      ),
+      paging,
+    });
+
+    const got = queryChannelMembers.locally({ channelId })!;
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const got = queryChannelMembers.locally({ channelId });
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryChannelMembers.locally({ channelId })).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,101 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '~/channel/utils';
+import { client, channelQueryResponse } from '~/utils/tests';
+
+import { queryChannels } from '../queryChannels';
+
+describe('queryChannels', () => {
+  test('it should return channels', async () => {
+    const expected = prepareChannelPayload(channelQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    const { data } = await queryChannels();
+
+    expect(data).toEqual(expected);
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryChannels()).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    const { data: got } = await queryChannels();
+    const { data } = queryChannels.locally()!;
+
+    expect(data).toBeDefined();
+    expect(got).toEqual(data);
+
+    disableCache();
+  });
+});
+
+describe('queryChannels.locally', () => {
+  const cacheKey = ['channel', 'query', { options: { limit: 10, after: undefined } }];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelQueryResponse.data;
+    const data = prepareChannelPayload(payload);
+    const { channels } = data;
+
+    ingestInCache(data as Amity.ChannelMembershipPayload);
+
+    pushToCache(cacheKey, { channels: channels.map(getResolver('channel')), paging });
+
+    const { data: got } = queryChannels.locally()!;
+
+    expect(got).toBeDefined();
+    expect(got).toEqual(channels);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelQueryResponse.data;
+    const data = prepareChannelPayload(payload);
+    const { channels } = data;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...data,
+      channels: [data.channels[0]],
+    } as Amity.ChannelPayload);
+
+    pushToCache(cacheKey, {
+      channels: channels.map(getResolver('channel')),
+      paging,
+    });
+
+    const got = queryChannels.locally()!;
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const got = queryChannels.locally();
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryChannels.locally()).toBeUndefined();
+  });
+});

package/src/channel/events/index.ts

@@ -1,7 +1,12 @@
 export * from './onChannelCreated';
 export * from './onChannelUpdated';
 export * from './onChannelDeleted';
+
 export * from './onChannelJoined';
 export * from './onChannelLeft';
+
 export * from './onChannelMemberAdded';
 export * from './onChannelMemberRemoved';
+
+export * from './onChannelMemberBanned';
+export * from './onChannelMemberUnbanned';

package/src/channel/events/onChannelMemberBanned.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberBanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberBanned((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been banned from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberBanned = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0], data.channelUsers.find(cu => cu.membership === 'banned')!);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberBanned', 'v3.channel.didBan', filter);
+};

package/src/channel/events/onChannelMemberUnbanned.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberUnbanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberUnbanned((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been unbanned from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberUnbanned = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0], data.channelUsers.find(cu => cu.membership === 'none')!);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberBanned', 'v3.channel.didUnban', filter);
+};

package/src/channel/events/tests/onChannelMemberBanned.test.ts

@@ -0,0 +1,58 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  channelUser5,
+} from '~/utils/tests';
+
+import { onChannelMemberBanned } from '../onChannelMemberBanned';
+
+describe('onChannelMemberBanned event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [channelUser1, channelUser5],
+    channels: [channel11],
+    files: [],
+    users: [],
+  };
+
+  test('it should call callback with channel and banned member', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberBanned(callback);
+    client.emitter.emit('v3.channel.didBan', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11, channelUser5);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberBanned(callback);
+    unsub();
+
+    client.emitter.emit('v3.channel.didBan', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});