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

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

@@ -0,0 +1,108 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { client, channelQueryResponse } from '~/utils/tests';
+
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+
+import { getChannel } from '../getChannel';
+
+const { channelId } = channelQueryResponse.data.channels[0];
+const channel = channelQueryResponse.data.channels[0];
+
+describe('getChannel', () => {
+  test('it should return a channel', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(channelQueryResponse);
+
+    const expected = channel;
+    const { data: received } = await getChannel(channelId);
+
+    expect(received).toStrictEqual(expected);
+  });
+
+  test('it should update cache after fetch from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+    await getChannel(channelId);
+
+    expect(getChannel.locally(channelId)).toBeDefined();
+
+    disableCache();
+  });
+
+  test('it should return an error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getChannel(channelId)).rejects.toThrow('error');
+  });
+
+  test('it should return an error if channel in cache but api throws not found', async () => {
+    enableCache();
+    pushToCache(['channel', 'get', channelId], channel, { cachedAt: Date.now() });
+
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getChannel(channelId)).rejects.toThrow();
+    expect(getChannel.locally(channelId)).toBeUndefined();
+
+    disableCache();
+  });
+});
+
+describe('getChannel locally', () => {
+  test('it should return data from cache', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelId], channel, { cachedAt });
+
+    const data = getChannel.locally(channelId);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+
+  test('should return undefined if channel not in cache', () => {
+    expect(getChannel.locally('non-existent-channel')).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    expect(getChannel.locally(channelId)).toBeUndefined();
+  });
+});
+
+describe('getChannel tombostone', () => {
+  test('it should add channel to tombostone if 404', async () => {
+    enableCache();
+    
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getChannel(channelId)).rejects.toThrow();
+    expect(() => {
+      isInTombstone('channel', channelId);
+    }).toThrow();
+
+    disableCache();
+  });
+
+  test('it should throw error if channel not found in tombostone', async () => {
+    enableCache();
+
+    pushToTombstone('channel', channelId);
+    await expect(getChannel(channelId)).rejects.toThrow();
+
+    disableCache();
+  });
+});

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,121 @@
+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 params do not match', () => {
+    enableCache();
+
+    const { data } = channelQueryResponse;
+    const { channels: expected, paging } = data;
+
+    ingestInCache(data as Amity.ChannelPayload);
+
+    pushToCache(cacheKey, { channels: expected.map(getResolver('channel')), paging });
+
+    const { data: received } = queryChannels.locally()!;
+    const received2 = queryChannels.locally({ displayName: 'test' })!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+    expect(received2).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/onChannelMemberAdded.ts

@@ -22,7 +22,7 @@ import { prepareChannelPayload } from '../utils';
  */
 export const onChannelMemberAdded = (
   callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
-) => {
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelMembershipPayload) => {

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();
+  });
+});

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

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

package/src/channel/observers/liveChannelMembers.ts

@@ -16,7 +16,12 @@ import {
   COLLECTION_DEFAULT_PAGINATION_LIMIT,
   ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
-import { onChannelMemberAdded, onChannelMemberRemoved } from '../events';
+import {
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+  onChannelMemberBanned,
+  onChannelMemberUnbanned,
+} from '../events';
 import { queryChannelMembers } from '../api';
 
 /**
@@ -67,7 +72,22 @@ export const liveChannelMembers = (
         .map(({ data }) => data) ?? [];
 
     channelMembers = filterByPropEquality(channelMembers, 'roles', params.roles);
-    channelMembers = filterByPropInclusion(channelMembers, 'membership', params.memberships);
+
+    if (params.memberships) {
+      /*
+       * even though membership includes muted as a possible value
+       * when querying the server.
+       * Muted is specified under seperarte property namely isMuted
+       * Hence why I've seperately checked for it's equality
+       */
+      if (params.memberships.some(m => ['member', 'banned'].includes(m))) {
+        channelMembers = filterByPropInclusion(channelMembers, 'membership', params.memberships);
+      }
+
+      if (params.memberships.includes('muted')) {
+        channelMembers = filterByPropEquality(channelMembers, 'isMuted', true);
+      }
+    }
 
     if (params.search) {
       const containsMatcher = new RegExp(params.search);
@@ -91,7 +111,7 @@ export const liveChannelMembers = (
 
   const realtimeRouter = (
     channelMember: Amity.Membership<'channel'>,
-    action: 'onMemberAdded' | 'onMemberRemoved',
+    action: Amity.ChannelMemberActionType,
   ) => {
     const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
     if (!collection) return;
@@ -103,7 +123,9 @@ export const liveChannelMembers = (
 
     if (action === 'onMemberAdded') {
       collection.data = [...new Set([channelMemberCacheId, ...collection.data])];
-    } else {
+    }
+
+    if (action === 'onMemberRemoved') {
       collection.data = collection.data.filter(m => m !== channelMemberCacheId);
     }
 
@@ -148,6 +170,8 @@ export const liveChannelMembers = (
   disposers.push(
     onChannelMemberAdded((_, member) => realtimeRouter(member, 'onMemberAdded')),
     onChannelMemberRemoved((_, member) => realtimeRouter(member, 'onMemberRemoved')),
+    onChannelMemberBanned((_, member) => realtimeRouter(member, 'onChannelMemberBanned')),
+    onChannelMemberUnbanned((_, member) => realtimeRouter(member, 'onChannelMemberUnbanned')),
   );
 
   onFetch();

package/src/channel/observers/liveChannels.ts

@@ -7,6 +7,7 @@ import {
   runQuery,
   queryOptions,
   filterByPropEquality,
+  filterByChannelMembership,
   sortByLastCreated,
   sortByDisplayName,
   sortByFirstCreated,
@@ -43,7 +44,7 @@ export const liveChannels = (
   callback: Amity.LiveCollectionCallback<Amity.Channel>,
   config?: Amity.LiveCollectionConfig,
 ) => {
-  const { log, cache } = getActiveClient();
+  const { log, cache, userId } = getActiveClient();
 
   if (!cache) {
     console.log(ENABLE_CACHE_MESSAGE);
@@ -82,6 +83,11 @@ export const liveChannels = (
       channels = channels.filter(c => !c.tags?.some(t => params.excludeTags?.includes(t)));
     }
 
+    // userId is required to be able to filter channel by current active user
+    if (params.membership && userId) {
+      channels = filterByChannelMembership(channels, params.membership, userId);
+    }
+
     const sortBy = params.sortBy || 'lastCreated';
 
     if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {