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

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') {

package/src/channel/observers/tests/liveChannelMembers.test.ts

@@ -6,6 +6,7 @@ import {
   channelUser1,
   channelUser4,
   channelUserQueryResponse,
+  channelUserQueryResponsePage3,
   channelUserQueryResponsePage2,
   channel11,
   pause,
@@ -57,24 +58,34 @@ describe('liveChannelMembers', () => {
   const filters: [string, Amity.ChannelMembersLiveCollection, Amity.Membership<'channel'>[]][] = [
     [
       'roles',
-      { channelId, roles: channelUserQueryResponse.data.channelUsers[1].roles },
-      [channelUserQueryResponse.data.channelUsers[1]],
+      { channelId, roles: channelUserQueryResponsePage3.data.channelUsers[0].roles },
+      [channelUserQueryResponsePage3.data.channelUsers[0]],
     ],
     [
       'searched term',
       { channelId, search: 'use' },
-      [channelUserQueryResponse.data.channelUsers[1]],
+      [channelUserQueryResponsePage3.data.channelUsers[0]],
     ],
     [
-      'memberships',
+      'member',
       { channelId, memberships: ['member'] },
-      [channelUserQueryResponse.data.channelUsers[0]],
+      [channelUserQueryResponsePage3.data.channelUsers[0]],
+    ],
+    [
+      'muted members',
+      { channelId, memberships: ['muted'] },
+      [channelUserQueryResponsePage3.data.channelUsers[1]],
+    ],
+    [
+      'banned members',
+      { channelId, memberships: ['banned'] },
+      [channelUserQueryResponsePage3.data.channelUsers[1]],
     ],
   ];
 
   test.each(filters)('it should filter channelUsers by %s', async (filter, params, expected) => {
     const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponsePage3);
 
     liveChannelMembers(params, callback);
     await pause();
@@ -131,6 +142,16 @@ describe('liveChannelMembers', () => {
       'v3.channel.didRemoveUsers',
       channelUser1,
     ],
+    [
+      'it should update channel memeber membership on onChannelMemberBanned',
+      'v3.channel.didBan',
+      { ...channelUser1, membership: 'banned', isBanned: true },
+    ],
+    [
+      'it should update channel memeber membership on onChannelMemberUnbanned',
+      'v3.channel.didUnban',
+      { ...channelUser1, membership: 'none', isBanned: false },
+    ],
   ];
 
   test.each(events)('%s', async (test, event, channelUser) => {
@@ -153,11 +174,32 @@ describe('liveChannelMembers', () => {
 
     snapshot.loading = false;
     // get data based on event
-    if (event === 'v3.channel.didAddUsers') {
-      snapshot.data = [channelUser, ...payload.channelUsers];
-    } else {
-      const deletePayload = payload.channelUsers.filter(u => u.userId !== channelUser.userId);
-      snapshot.data = deletePayload;
+    switch (event) {
+      case 'v3.channel.didAddUsers':
+        snapshot.data = [channelUser, ...payload.channelUsers];
+        break;
+
+      case 'v3.channel.didBan': {
+        const bannedUserIdx = payload.channelUsers.findIndex(u => u.userId === channelUser.userId);
+        payload.channelUsers[bannedUserIdx] = channelUser;
+
+        snapshot.data = payload.channelUsers;
+        break;
+      }
+
+      case 'v3.channel.didUnban': {
+        const unbannedUserIdx = payload.channelUsers.findIndex(
+          u => u.userId === channelUser.userId,
+        );
+        payload.channelUsers[unbannedUserIdx] = channelUser;
+
+        snapshot.data = payload.channelUsers;
+        break;
+      }
+
+      default:
+        // delete payload
+        snapshot.data = payload.channelUsers.filter(u => u.userId !== channelUser.userId);
     }
 
     expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));

package/src/channel/observers/tests/liveChannels.test.ts

@@ -1,4 +1,5 @@
-import { disableCache, enableCache } from '~/cache/api';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
 
 import { liveChannels } from '../liveChannels';
 import { queryChannels } from '~/channel/api';
@@ -6,6 +7,7 @@ import { prepareChannelPayload } from '../../utils/prepareChannelPayload';
 
 import {
   client,
+  pause,
   connectClient,
   disconnectClient,
   channel11,
@@ -49,7 +51,7 @@ describe('liveChannels', () => {
     // check if cache data returned (should be empty)
     expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
 
-    await expect(queryChannels()).resolves.toBeTruthy();
+    await pause();
 
     expect(callback).toHaveBeenCalledTimes(2);
 
@@ -63,33 +65,61 @@ describe('liveChannels', () => {
   });
 
   // table for channel filters
-  const filters: [string, Amity.ChannelLiveCollection][] = [
+  const filters: [string, Amity.ChannelLiveCollection, number?][] = [
     ['deleted', { isDeleted: false }],
     ['tagged', { tags: ['tag2'] }],
     ['out excluded tags', { excludeTags: ['tag1'] }],
+    ['member', { membership: 'member' }],
+    ['not member', { membership: 'notMember' }, 1],
+    ['all membership', { membership: 'all' }],
   ];
 
-  test.each(filters)('it should filter %s channels', async (filter, params) => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+  test.each(filters)(
+    'it should filter by %s channels',
+    async (filter, params, expectedChannelIdx = 0) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
 
-    liveChannels(params, callback);
+      const payload = prepareChannelPayload(channelQueryResponse.data);
+      let snapshotData = [payload.channels[expectedChannelIdx]];
 
-    expect(callback).toHaveBeenCalledTimes(1);
+      // add channel users to cache for testing membership filter
+      if (params.membership) {
+        pushToCache(
+          [
+            'channelUsers',
+            'get',
+            getResolver('channelUsers')({
+              channelId: channelQueryResponse.data.channels[0].channelId,
+              userId: channelUser1.userId,
+            }),
+          ],
+          channelUser1,
+        );
 
-    const snapshot = getSnapshot();
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+        if (params.membership === 'all') {
+          snapshotData = payload.channels;
+        }
+      }
 
-    await expect(queryChannels()).resolves.toBeTruthy();
+      liveChannels(params, callback);
 
-    expect(callback).toHaveBeenCalledTimes(2);
+      expect(callback).toHaveBeenCalledTimes(1);
 
-    snapshot.loading = false;
-    snapshot.data = [channelQueryResponse.data.channels[0]];
+      const snapshot = getSnapshot();
+      // check if cache data returned (should be empty)
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
 
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-  });
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(2);
+
+      snapshot.loading = false;
+      snapshot.data = snapshotData;
+
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+    },
+  );
 
   test('it should return method to fetch next page', async () => {
     const callback = jest.fn();
@@ -102,7 +132,7 @@ describe('liveChannels', () => {
 
     expect(callback).toHaveBeenCalled();
 
-    await expect(queryChannels()).resolves.toBeTruthy();
+    await pause();
 
     expect(callback.mock.lastCall).toHaveLength(1);
 
@@ -113,7 +143,7 @@ describe('liveChannels', () => {
 
     onNextPage();
 
-    await expect(queryChannels()).resolves.toBeTruthy();
+    await pause();
 
     // 4 -> becuase 1 local & server call each per call (2)
     expect(callback).toHaveBeenCalledTimes(4);
@@ -146,7 +176,7 @@ describe('liveChannels', () => {
 
     liveChannels({}, callback);
 
-    await expect(queryChannels()).resolves.toBeTruthy();
+    await pause();
     expect(callback).toHaveBeenCalledTimes(2);
 
     client.emitter.emit(event, {

package/src/channel/{tests/utils → utils/tests}/prepareChannelPayload.test.ts

@@ -9,7 +9,7 @@ import {
   channelUser2,
 } from '~/utils/tests';
 
-import { prepareChannelPayload } from '../../utils';
+import { prepareChannelPayload } from '../prepareChannelPayload';
 
 beforeAll(async () => {
   await connectClient();

package/src/core/events.ts

@@ -23,6 +23,7 @@ const WS_EVENTS = [
   'v3.channel.didBan',
   'v3.channel.didUnban',
 
+  'v3.message.didFetch',
   'v3.message.didCreate',
   'v3.message.didUpdate',
   'v3.message.didDelete',

package/src/core/query/filtering.ts

@@ -1,3 +1,5 @@
+import { getResolver } from '~/core/model';
+import { pullFromCache } from '~/cache/api';
 // Note:
 // this file should contain a suite of filtering utilities to help the
 // local version of the query functions.
@@ -23,3 +25,50 @@ export const filterByPropInclusion = <T = Record<string, unknown>>(
   key: keyof T,
   value: any[] | undefined,
 ) => (value !== undefined ? collection.filter(item => value.includes(item[key])) : collection);
+
+/**
+ * Filter a channel collection by membership of the userId
+ *
+ * @param collection the channel collection to filter
+ * @param membership the membership to be filtered by
+ * @param userId user id to be filtered by
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+export const filterByChannelMembership = (
+  collection: Amity.Channel[],
+  membership: Amity.ChannelLiveCollection['membership'],
+  userId: Amity.Membership<'channel'>['userId'],
+): Amity.Channel[] => {
+  if (membership === 'all') {
+    return collection;
+  }
+
+  return collection.filter(c => {
+    // get resolver for the channel by user
+    const channelUserCacheKey = getResolver('channelUsers')({
+      channelId: c.channelId,
+      userId,
+    });
+
+    const channelUser = pullFromCache<Amity.Membership<'channel'>>([
+      'channelUsers',
+      'get',
+      channelUserCacheKey,
+    ])?.data;
+
+    // if channel user is defined for user, user is a member
+    if (membership === 'member' && channelUser) {
+      return true;
+    }
+
+    // if channel user by user id not found, user is not a member of that
+    // channel
+    if (membership === 'notMember' && !channelUser) {
+      return true;
+    }
+
+    return false;
+  });
+};

package/src/core/query/query.ts

@@ -2,6 +2,8 @@
 import { isPaged } from './paging';
 import { identifyModelKey } from '~/core/model';
 
+import { CACHE_LIFESPAN } from '~/cache/utils';
+
 /**
  * Type guard to check and cast that a given async function is has the ".locally" property
  *
@@ -71,7 +73,7 @@ export const isLocal = (model?: any): model is Amity.Local => {
  *
  * @hidden
  */
-export const isFresh = (model?: Amity.Cachable, lifeSpan = 0) => {
+export const isFresh = (model?: Amity.Cachable, lifeSpan = CACHE_LIFESPAN) => {
   return Date.now() - (model?.cachedAt ?? 0) <= lifeSpan;
 };
 
@@ -111,12 +113,11 @@ export const createQuery = <Args extends any[], Returned extends any>(
  */
 export const queryOptions = (
   policy: Amity.QueryPolicy,
-  lifeSpan: number = 2 * 60 * 1000, // 2mn
+  lifeSpan: number = CACHE_LIFESPAN, // 1mn
 ): Amity.QueryOptions => {
   if (policy === 'cache_only') return { lifeSpan: Infinity };
-  if (policy === 'server_only') return { lifeSpan: 0 };
 
-  return { lifeSpan };
+  return { lifeSpan: lifeSpan < CACHE_LIFESPAN ? CACHE_LIFESPAN : lifeSpan };
 };
 
 /**
@@ -168,8 +169,10 @@ export const runQuery = <Args extends any[], Returned extends any>(
 ) => {
   let local: Returned | undefined;
 
+  const { lifeSpan } = queryOptions('cache_then_server', options.lifeSpan);
+
   // offline first
-  if (isOffline(func) && options.lifeSpan !== 0) {
+  if (isOffline(func)) {
     try {
       local = isMutator(func) ? func.optimistically(...args) : func.locally(...args);
     } catch (error) {
@@ -182,7 +185,7 @@ export const runQuery = <Args extends any[], Returned extends any>(
       );
     }
 
-    const shouldAbort = isCachable(local) && isFresh(local, options.lifeSpan);
+    const shouldAbort = isCachable(local) && isFresh(local, lifeSpan);
 
     callback?.(
       createSnapshot<Returned>(local, {

package/src/core/tests/query/query.test.ts

@@ -7,6 +7,7 @@ import {
   isFresh,
   queryOptions,
 } from '~/core/query';
+import { CACHE_LIFESPAN } from '~/cache/utils';
 
 describe('Core/Query', () => {
   type isFetcherMockType = jest.Mock<any, any> & {
@@ -90,8 +91,17 @@ describe('Core/Query', () => {
   });
 
   describe('queryOptions', () => {
-    test('should return lifespan 0 if server only', () => {
-      expect(queryOptions('server_only').lifeSpan).toBe(0);
+    test('should return minimum lifeSpan', () => {
+      expect(queryOptions('cache_then_server').lifeSpan).toBe(CACHE_LIFESPAN);
+    });
+
+    test('should return minimum lifeSpan if provided lifeSpan is less than cache lifeSpan', () => {
+      expect(queryOptions('cache_then_server', 0).lifeSpan).toBe(CACHE_LIFESPAN);
+    });
+
+    test('should return provided lifeSpan if provided lifeSpan is more than cache lifeSpan', () => {
+      const value = CACHE_LIFESPAN * 2;
+      expect(queryOptions('cache_then_server', value).lifeSpan).toBe(value);
     });
 
     test('should return lifespan Infinity if cache only', () => {

package/src/message/api/createMessage.ts

@@ -1,9 +1,9 @@
+import { uuid } from '~/core/uuid';
+import { fireEvent } from '~/core/events';
 import { getActiveClient } from '~/client/api';
-
-import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { fireEvent } from '~/core/events';
-import { uuid } from '~/core/uuid';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 
 /**
  * ```js
@@ -25,8 +25,11 @@ import { uuid } from '~/core/uuid';
 export const createMessage = async <T extends Amity.MessageContentType>(
   bundle: Pick<
     Amity.Message<T>,
-    'channelId' | 'parentId' | 'type' | 'data' | 'tags' | 'metadata' | 'mentionees'
-  >,
+    'channelId' | 'parentId' | 'type' | 'tags' | 'metadata' | 'mentionees'
+  > & {
+    data?: Amity.Message<T>['data'];
+    fileId?: Amity.Message<T>['fileId'];
+  },
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
 
@@ -36,10 +39,11 @@ export const createMessage = async <T extends Amity.MessageContentType>(
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
-  // no need for event, fired by server
 
   const { messages } = data;
 
+  fireEvent('v3.message.didCreate', { messages });
+
   return {
     data: messages[0],
     cachedAt,
@@ -102,11 +106,13 @@ createMessage.optimistically = (
     ...bundleWithMessageId,
   } as Amity.Message;
 
-  pushToCache(['message', 'get', message.messageId], message, { cachedAt: -1 });
+  const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
+
+  pushToCache(['message', 'get', message.messageId], message, { cachedAt });
   fireEvent('v3.message.didCreate', { messages: [message] });
 
   return {
+    cachedAt,
     data: message,
-    cachedAt: -1,
   };
 };

package/src/message/api/deleteMessage.ts

@@ -31,7 +31,8 @@ export const deleteMessage = async (
   );
 
   const deleted = await getMessage(messageId);
-  // no need for event, fired by server
+
+  fireEvent('v3.message.didDelete', { messages: [deleted.data] });
 
   return deleted.data;
 };

package/src/message/api/getMessage.ts

@@ -1,8 +1,13 @@
 import { getActiveClient } from '~/client/api';
 
+import { fireEvent } from '~/core/events';
 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';
+
 /**
  * ```js
  * import { getMessage } from '@amityco/ts-sdk'
@@ -19,20 +24,43 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const getMessage = async (
   messageId: Amity.Message['messageId'],
+  isLive = false,
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
   client.log('message/getMessage', messageId);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.MessagePayload>(
-    `/api/v3/messages/${encodeURIComponent(messageId)}`,
-  );
+  if (!isLive) {
+    console.log(
+      'getMessage will be deprecated on 15th November 2022, please use liveMessage instead.',
+    );
+  }
+
+  isInTombstone('message', messageId);
+
+  let data: Amity.MessagePayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http.get<Amity.MessagePayload>(
+      `/api/v3/messages/${encodeURIComponent(messageId)}`,
+    );
+
+    data = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('message', messageId);
+    }
+
+    throw error;
+  }
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
   const { messages } = data;
 
+  fireEvent('v3.message.didFetch', { messages });
+
   return {
     data: messages.find(message => message.messageId === messageId)!,
     cachedAt,