@amityco/ts-sdk 0.0.1-beta.42.2 → 0.0.1-beta.43

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

@@ -6,9 +6,11 @@ import {
   client,
   connectClient,
   disconnectClient,
+  pause,
   rawChannelUser,
   user11,
 } from '~/utils/tests';
+
 import { onChannelMemberRemoved } from '../onChannelMemberRemoved';
 
 describe('onChannelMemberRemoved event', () => {
@@ -31,12 +33,14 @@ describe('onChannelMemberRemoved event', () => {
     users: [user11],
   };
 
-  test('it should call callback when have someone remove member from channel', () => {
+  test('it should call callback when have someone remove member from channel', async () => {
     const callback = jest.fn();
 
     const unsub = onChannelMemberRemoved(callback);
     client.emitter.emit('channel.membersRemoved', channelPayload);
 
+    await pause();
+
     unsub();
 
     expect(callback).toHaveBeenCalled();

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

@@ -10,21 +10,16 @@ import {
   user11,
   user12,
   channelRaw1,
+  pause,
 } from '~/utils/tests';
 
 import { onChannelMemberUnbanned } from '../onChannelMemberUnbanned';
 
 describe('onChannelMemberBanned event', () => {
-  beforeAll(async () => {
-    await connectClient();
-  });
-
-  afterAll(async () => {
-    await disconnectClient();
-  });
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
 
   beforeEach(enableCache);
-
   afterEach(disableCache);
 
   const channelPayload: Amity.ChannelMembershipPayload = {
@@ -34,22 +29,27 @@ describe('onChannelMemberBanned event', () => {
     users: [user11, user12],
   };
 
-  test('it should call callback with channel and unbanned member', () => {
+  test('it should call callback with channel and unbanned member', async () => {
     const callback = jest.fn();
 
     const unsub = onChannelMemberUnbanned(callback);
     client.emitter.emit('channel.unbanned', channelPayload);
 
+    await pause();
+
     unsub();
 
     expect(callback).toHaveBeenCalled();
     expect(callback).toHaveBeenCalledWith(channel1, { ...rawChannelUser3, user: user12 });
   });
 
-  test('it should return an Unsubscriber', () => {
+  test('it should return an Unsubscriber', async () => {
     const callback = jest.fn();
 
     const unsub = onChannelMemberUnbanned(callback);
+
+    await pause();
+
     unsub();
 
     client.emitter.emit('channel.unbanned', channelPayload);

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

@@ -5,9 +5,11 @@ import {
   client,
   connectClient,
   disconnectClient,
+  pause,
   rawChannelUser,
   user11,
 } from '~/utils/tests';
+
 import { onChannelUpdated } from '../onChannelUpdated';
 
 describe('onChannelUpdated event', () => {
@@ -30,12 +32,14 @@ describe('onChannelUpdated event', () => {
     users: [user11],
   };
 
-  test('it should call callback when channel have updated', () => {
+  test('it should call callback when channel have updated', async () => {
     const callback = jest.fn();
 
     const unsub = onChannelUpdated(callback);
     client.emitter.emit('channel.updated', channelPayload);
 
+    await pause();
+
     unsub();
 
     expect(callback).toHaveBeenCalled();

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

@@ -12,6 +12,7 @@ import {
   channelUserWithRole,
   client,
   connectClient,
+  convertRawChannelPayload,
   disconnectClient,
   emptyChannelUserQueryResponse,
   mutedChannelUser,
@@ -25,7 +26,6 @@ import {
 } from '~/utils/tests';
 
 import { liveChannelMembers } from '../liveChannelMembers';
-import { prepareChannelPayload } from '../../utils';
 
 const getSnapshot = (params?: Record<string, any>) => {
   return {
@@ -37,16 +37,10 @@ const getSnapshot = (params?: Record<string, any>) => {
 };
 
 describe('liveChannelMembers', () => {
-  beforeAll(async () => {
-    await connectClient();
-  });
-
-  afterAll(async () => {
-    await disconnectClient();
-  });
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
 
   beforeEach(enableCache);
-
   afterEach(disableCache);
 
   const { channelId } = channel1;
@@ -117,8 +111,8 @@ describe('liveChannelMembers', () => {
     onNextPage();
     await pause();
 
-    const payload = prepareChannelPayload(channelUserQueryResponse.data);
-    const payload2 = prepareChannelPayload(channelUserQueryResponsePage2.data);
+    const payload = convertRawChannelPayload(channelUserQueryResponse.data);
+    const payload2 = convertRawChannelPayload(channelUserQueryResponsePage2.data);
 
     const snapshot = getSnapshot();
     snapshot.loading = false;

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

@@ -8,6 +8,7 @@ import {
   channelRaw2,
   client,
   connectClient,
+  convertRawChannelPayload,
   disconnectClient,
   generateRawChannel,
   generateRawMessage,
@@ -17,8 +18,10 @@ import {
   rawChannelUser2,
   user11,
 } from '~/utils/tests';
+
 import { liveChannels } from '../liveChannels';
-import { convertFromRaw, prepareChannelPayload } from '../../utils';
+import { convertFromRaw } from '../../utils';
+import * as getChannelMarkers from '../../../marker/api/getChannelMarkers';
 
 const getSnapshot = (params?: Record<string, any>) => {
   return {
@@ -29,24 +32,18 @@ const getSnapshot = (params?: Record<string, any>) => {
   };
 };
 
-const convertFromRawParams = {
-  defaultSubChannelHasUnreadMention: false,
-  defaultSubChannelUnreadCount: 0,
-  localLastMentionSegment: 0,
-  localReadToSegment: 0,
-};
-
 describe('liveChannels', () => {
   beforeAll(async () => {
     await connectClient();
-  });
 
-  afterAll(async () => {
-    await disconnectClient();
+    jest.spyOn(getChannelMarkers, 'getChannelMarkers').mockResolvedValue({
+      data: [],
+      cachedAt: undefined,
+    });
   });
 
+  afterAll(disconnectClient);
   beforeEach(enableCache);
-
   afterEach(disableCache);
 
   test('it should return channel collection', async () => {
@@ -62,7 +59,7 @@ describe('liveChannels', () => {
       2,
       expect.objectContaining(
         getSnapshot({
-          data: prepareChannelPayload(channelQueryResponse.data).channels,
+          data: convertRawChannelPayload(channelQueryResponse.data).channels,
           loading: false,
         }),
       ),
@@ -83,7 +80,7 @@ describe('liveChannels', () => {
       1,
       expect.objectContaining(
         getSnapshot({
-          data: prepareChannelPayload(channelQueryResponse.data).channels,
+          data: convertRawChannelPayload(channelQueryResponse.data).channels,
         }),
       ),
     );
@@ -91,7 +88,7 @@ describe('liveChannels', () => {
       2,
       expect.objectContaining(
         getSnapshot({
-          data: prepareChannelPayload(channelQueryResponse.data).channels,
+          data: convertRawChannelPayload(channelQueryResponse.data).channels,
           loading: false,
         }),
       ),
@@ -102,17 +99,17 @@ describe('liveChannels', () => {
     channelId: 'deleted-channel-id',
     isDeleted: true,
   });
-  const deletedChannel = convertFromRaw(rawDeletedChannel, convertFromRawParams);
+  const deletedChannel = convertFromRaw(rawDeletedChannel);
   const rawTaggedChannel = generateRawChannel({
     channelId: 'tagged-channel-id',
     tags: ['tag1', 'tag2'],
   });
-  const taggedChannel = convertFromRaw(rawTaggedChannel, convertFromRawParams);
+  const taggedChannel = convertFromRaw(rawTaggedChannel);
   const rawTaggedChannel2 = generateRawChannel({
     channelId: 'tagged-channel-id-2',
     tags: ['tag2'],
   });
-  const taggedChannel2 = convertFromRaw(rawTaggedChannel2, convertFromRawParams);
+  const taggedChannel2 = convertFromRaw(rawTaggedChannel2);
 
   const filters: [string, Amity.ChannelLiveCollection, Amity.Channel[]][] = [
     ['deleted', { isDeleted: false }, [channel1, taggedChannel, taggedChannel2]],
@@ -187,8 +184,8 @@ describe('liveChannels', () => {
         getSnapshot({
           loading: false,
           data: [
-            ...prepareChannelPayload(channelQueryResponsePage2.data).channels,
-            ...prepareChannelPayload(channelQueryResponse.data).channels,
+            ...convertRawChannelPayload(channelQueryResponsePage2.data).channels,
+            ...convertRawChannelPayload(channelQueryResponse.data).channels,
           ],
         }),
       ),
@@ -203,13 +200,13 @@ describe('liveChannels', () => {
         'it should add new channel to collection onCreate',
         'channel.created',
         rawNewChannel,
-        [convertFromRaw(rawNewChannel, convertFromRawParams), channel1, channel2],
+        [convertFromRaw(rawNewChannel), channel1, channel2],
       ],
       [
         'it should add new channel to collection onJoin',
         'channel.joined',
         rawNewChannel,
-        [convertFromRaw(rawNewChannel, convertFromRawParams), channel1, channel2],
+        [convertFromRaw(rawNewChannel), channel1, channel2],
       ],
       [
         'it should update channel in collection onUpdate',
@@ -423,7 +420,8 @@ describe('liveChannels', () => {
     });
   });
 
-  it('should increase the unread count once message is created', async () => {
+  // TODO: re-enable this after implement marker-sync service
+  xit('should increase the unread count once message is created', async () => {
     const callback = jest.fn();
     client.http.get = jest.fn().mockResolvedValue({
       data: {
@@ -457,7 +455,6 @@ describe('liveChannels', () => {
           data: [
             {
               ...channel1,
-              defaultSubChannelUnreadCount: 1,
               lastActivity: expect.anything(),
               messageCount: channel1.messageCount + 1,
               updatedAt: expect.anything(),

package/src/channel/utils/index.ts

@@ -1,57 +1 @@
-import { pullFromCache } from '~/cache/api';
-import { withUsers } from '~/group/utils';
-
-export function convertFromRaw(
-  { _id, ...rest }: Amity.RawChannel,
-  params: Pick<
-    Amity.Channel,
-    | 'defaultSubChannelHasUnreadMention'
-    | 'defaultSubChannelUnreadCount'
-    | 'localLastMentionSegment'
-    | 'localReadToSegment'
-  >,
-): Amity.Channel {
-  return {
-    ...rest,
-    ...params,
-    defaultSubChannelId: _id,
-  };
-}
-
-function getSegmentParams(rawChannel: Amity.RawChannel) {
-  let cached;
-
-  try {
-    cached = pullFromCache<Amity.Channel>(['channel', 'get', rawChannel.channelId]);
-    // eslint-disable-next-line no-empty
-  } catch {}
-
-  if (cached) {
-    return {
-      defaultSubChannelHasUnreadMention: cached.data.defaultSubChannelHasUnreadMention,
-      defaultSubChannelUnreadCount: cached.data.defaultSubChannelUnreadCount,
-      localReadToSegment: cached.data.localReadToSegment,
-      localLastMentionSegment: cached.data.localLastMentionSegment,
-    };
-  }
-
-  return {
-    defaultSubChannelHasUnreadMention: false,
-    defaultSubChannelUnreadCount: 0,
-    // @ts-ignore
-    localReadToSegment: rawChannel.messageCount > 0 ? rawChannel.messageCount - 1 : 0,
-    localLastMentionSegment: 0,
-  };
-}
-
-export const prepareChannelPayload = (
-  rawPayload: Amity.ChannelPayload,
-): Amity.ProcessedChannelPayload => {
-  const channels: Amity.Channel[] = rawPayload.channels.map(channel =>
-    convertFromRaw(channel, getSegmentParams(channel)),
-  );
-
-  const channelUsers: Amity.Membership<'channel'>[] = withUsers(rawPayload.channelUsers);
-
-  return { ...rawPayload, channels, channelUsers };
-};
+export * from './prepareChannelPayload';

package/src/channel/utils/prepareChannelPayload.ts

@@ -0,0 +1,91 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getActiveUser } from '~/client/api/activeUser';
+import { getResolver } from '~/core/model';
+import { withUsers } from '~/group/utils/withUser';
+import { getChannelMarkers } from '~/marker/api';
+
+export const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
+export const isUnreadCountSupport = ({ type }: Pick<Amity.RawChannel, 'type'>) =>
+  MARKER_INCLUDED_CHANNEL_TYPE.includes(type);
+
+const getCachedMarker = (entityId: string) => {
+  const key = {
+    entityId,
+    userId: getActiveUser()._id,
+  };
+
+  return pullFromCache<Amity.ChannelMarker>([
+    'channelMarker',
+    'get',
+    getResolver('channelMarker')(key),
+  ])?.data;
+};
+
+const getUnreadCount = (channel: Amity.RawChannel, marker?: Amity.ChannelMarker) => {
+  if (marker?.isDeleted) {
+    // NOTE: This is a temporary solution to handle the channel marker when the user is forced to
+    // leave the channel because currently backend can't handle this, so every time a user is banned
+    // from a channel or the channel is deleted the channel's unread count will reset to zero
+    return 0;
+  }
+
+  return marker?.unreadCount ?? getCachedMarker(channel.channelId)?.unreadCount ?? 0;
+};
+
+export function convertFromRaw(
+  channel: Amity.RawChannel,
+  marker?: Amity.ChannelMarker,
+): Amity.Channel {
+  return {
+    ...channel,
+    isUnreadCountSupport: isUnreadCountSupport(channel),
+    unreadCount: getUnreadCount(channel, marker),
+  };
+}
+
+export function updateChannelMarker(
+  channel: Amity.Channel,
+  marker?: Amity.ChannelMarker,
+): Amity.Channel {
+  return {
+    ...channel,
+    unreadCount: getUnreadCount(channel, marker),
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+export const prepareChannelPayload = async (
+  rawPayload: Amity.ChannelPayload,
+): Promise<Amity.ProcessedChannelPayload> => {
+  // make a fetch marker to prepare it for merging with the raw channel payload.
+  let markers: Amity.ChannelMarker[] = [];
+
+  const markerIds = rawPayload.channels
+    // filter channel by type. Only conversation, community and broadcast type are included.
+    .filter(isUnreadCountSupport)
+    .map(({ channelId }) => channelId);
+
+  if (markerIds.length > 0)
+    // from the spec, allow marker fetch to fail
+    try {
+      ({ data: markers } = await getChannelMarkers(markerIds));
+    } catch (e) {
+      // empty block
+    }
+
+  // attach marker to channel
+  const channels = rawPayload.channels.map(channel => {
+    const marker = markers?.find(({ entityId }) => entityId === channel.channelId);
+
+    return convertFromRaw(channel, marker);
+  });
+
+  // user marker to channel users
+  const channelUsers: Amity.Membership<'channel'>[] = withUsers(rawPayload.channelUsers);
+
+  return {
+    ...rawPayload,
+    channels,
+    channelUsers,
+  };
+};

package/src/channel/utils/tests/prepareChannelPayload.test.ts

@@ -1,120 +1,118 @@
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
 import {
+  generateChannelMarker,
   connectClient,
   disconnectClient,
-  channel1,
-  channel2,
-  channelRaw1,
-  channelRaw2,
-  rawChannelUser,
-  rawChannelUser2,
+  generateRawChannel,
+  generateRawChannelUser,
+  convertChannelUserFromRaw,
 } from '~/utils/tests';
 
-import { prepareChannelPayload } from '..';
+import * as getChannelMarkers from '../../../marker/api/getChannelMarkers';
+import { isUnreadCountSupport, MARKER_INCLUDED_CHANNEL_TYPE, prepareChannelPayload } from '..';
 
-beforeAll(async () => {
-  await connectClient();
+export const communityChannel: Amity.RawChannel = generateRawChannel({
+  channelId: 'ch1',
+  type: 'community',
 });
+export const liveChannel: Amity.RawChannel = generateRawChannel({
+  channelId: 'ch2',
+  type: 'live',
+});
+export const conversationChannel: Amity.RawChannel = generateRawChannel({
+  channelId: 'ch3',
+  type: 'conversation',
+});
+
+export const rawChannelUser = generateRawChannelUser();
+
+export const channelUser = convertChannelUserFromRaw(rawChannelUser, undefined);
 
-afterAll(async () => {
-  await disconnectClient();
+const channelMarker1 = generateChannelMarker({
+  entityId: communityChannel.channelId,
+  userId: 'user1',
 });
 
-const responseSchema = {
-  channels: [],
-  channelUsers: [],
+const channelMarker2 = generateChannelMarker({
+  entityId: conversationChannel.channelId,
+  userId: 'user1',
+});
+
+const resolvedChannelMarkers: Amity.Cached<Amity.Paged<Amity.ChannelMarker>> = {
+  data: [channelMarker1, channelMarker2],
+  cachedAt: Date.now(),
+};
+
+const channelPayload: Amity.ChannelPayload = {
+  channels: [communityChannel, liveChannel, conversationChannel],
+  channelUsers: [rawChannelUser],
+  users: [],
   files: [],
+};
+
+const convertedChannelPayload: Amity.ProcessedChannelPayload = {
+  channels: [
+    { ...communityChannel, isUnreadCountSupport: true, unreadCount: channelMarker1.unreadCount },
+    { ...liveChannel, isUnreadCountSupport: false, unreadCount: 0 },
+    { ...conversationChannel, isUnreadCountSupport: true, unreadCount: channelMarker2.unreadCount },
+  ],
+  channelUsers: [channelUser],
   users: [],
+  files: [],
 };
 
-const tests = [
-  {
-    id: 1,
-    desc: 'hasMention: false, unreadCount: 0, if channelUsers is empty',
-    before: {
-      ...responseSchema,
-      channels: [channelRaw1],
-    },
-    after: {
-      ...responseSchema,
-      channels: [channel1],
-    },
-  },
-  {
-    id: 2,
-    desc: 'hasMention: false, if channelUser.readToSegment >= channelUser.lastMentionedSegment',
-    before: {
-      ...responseSchema,
-      channels: [channelRaw1],
-      channelUsers: [rawChannelUser],
-    },
-    after: {
-      ...responseSchema,
-      channels: [channel1],
-      channelUsers: [rawChannelUser],
-    },
-  },
-  {
-    id: 3,
-    desc: 'unreadCount: 0, if channelUser.readToSegment = channel.messageCount',
-    before: {
-      ...responseSchema,
-      channels: [channelRaw1],
-      channelUsers: [rawChannelUser],
-    },
-    after: {
-      ...responseSchema,
-      channels: [channel1],
-      channelUsers: [rawChannelUser],
-    },
-  },
-  {
-    id: 4,
-    desc: 'hasMention: true, if channelUser.readToSegment < channelUser.lastMentionedSegment',
-    before: {
-      ...responseSchema,
-      channels: [channelRaw2],
-      channelUsers: [rawChannelUser2],
-    },
-    after: {
-      ...responseSchema,
-      channels: [channel2],
-      channelUsers: [rawChannelUser2],
-    },
-  },
-  {
-    id: 5,
-    desc: 'unreadCount: > 0, if channelUser.readToSegment < channel.messageCount',
-    before: {
-      ...responseSchema,
-      channels: [channelRaw2],
-      channelUsers: [rawChannelUser2],
-    },
-    after: {
-      ...responseSchema,
-      channels: [channel2],
-      channelUsers: [rawChannelUser2],
-    },
-  },
-  {
-    id: 4,
-    desc: 'hasMention: true, unreadCount: > 0, if 4 / 5 ',
-    before: {
-      ...responseSchema,
-      channels: [channelRaw2],
-      channelUsers: [rawChannelUser2],
-    },
-    after: {
-      ...responseSchema,
-      channels: [channel2],
-      channelUsers: [rawChannelUser2],
-    },
-  },
-];
-
-xdescribe('channel/utils/prepareChannelPayload', () => {
-  tests.forEach(({ id, desc, before, after }) => {
-    test(`${id} - ${desc}`, () => {
-      expect(prepareChannelPayload(before)).toEqual(after);
-    });
+describe('prepareChannelPayload', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  it('should map channel payload with marker correctly', async () => {
+    jest
+      .spyOn(getChannelMarkers, 'getChannelMarkers')
+      .mockResolvedValueOnce(resolvedChannelMarkers);
+
+    const { channels: received } = await prepareChannelPayload(channelPayload);
+
+    expect(received).toEqual(convertedChannelPayload.channels);
+  });
+
+  it('should map channel payload with marker cache correctly', async () => {
+    pushToCache(['channelMarker', 'get', channelMarker1.entityId], channelMarker1);
+    pushToCache(['channelMarker', 'get', channelMarker2.entityId], channelMarker2);
+
+    const { channels: received } = await prepareChannelPayload(channelPayload);
+
+    expect(received).toEqual(convertedChannelPayload.channels);
+  });
+
+  it('should map channel payload with `unreadCount: 0` on unable to fetch marker', async () => {
+    const { channels: received } = await prepareChannelPayload(channelPayload);
+
+    const expected = convertedChannelPayload.channels.map(c => ({ ...c, unreadCount: 0 }));
+
+    expect(received).toEqual(expected);
+  });
+
+  it(`should filter channels by ${MARKER_INCLUDED_CHANNEL_TYPE.join(', ')} type(s)`, async () => {
+    const mock = jest
+      .spyOn(getChannelMarkers, 'getChannelMarkers')
+      .mockResolvedValueOnce(resolvedChannelMarkers);
+
+    await prepareChannelPayload(channelPayload);
+
+    const expected = channelPayload.channels.filter(isUnreadCountSupport).map(c => c.channelId);
+
+    expect(mock).toHaveBeenCalledWith(expected);
+  });
+
+  it('should not throw an error on `getChannelMarkers` failed', async () => {
+    jest
+      .spyOn(getChannelMarkers, 'getChannelMarkers')
+      .mockRejectedValueOnce(new ASCApiError('error', 500, Amity.ErrorLevel.ERROR));
+
+    await expect(prepareChannelPayload(channelPayload)).resolves.not.toThrow();
   });
 });

package/src/client/api/activeUser.ts

@@ -1,6 +1,6 @@
 import { ASCError } from '~/core/errors';
 
-let activeUser: Pick<Amity.User, '_id' | 'userId' | 'path' | 'displayName'> | null = null;
+let activeUser: Amity.ActiveUser | null = null;
 
 /**
  * for internal use
@@ -17,7 +17,7 @@ export const getActiveUser = () => {
   return activeUser!;
 };
 
-export const setActiveUser = (user: Amity.User) => {
+export const setActiveUser = (user: Amity.ActiveUser) => {
   activeUser = {
     _id: user._id,
     userId: user.userId,