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

package/src/subChannel/api/tests/getSubChannel.test.ts

@@ -1,8 +1,8 @@
-import { getSubChannel } from '../getSubChannel';
-import { client, generateRawSubChannel } from '~/utils/tests';
-
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { ASCApiError } from '~/core/errors';
+
+import { getSubChannel } from '../getSubChannel';
 import { onSubChannelFetched } from '../../events/onSubChannelFetched';
 
 const subChannelId = 'channelId11--sub-channel-id';
@@ -13,8 +13,10 @@ const subChannelPayload = {
 };
 
 describe('createSubChannel', () => {
-  beforeEach(enableCache);
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
 
+  beforeEach(enableCache);
   afterEach(disableCache);
 
   // integration_test_id: 6f019056-921e-43e2-a426-dd5a96f2fdcf

package/src/subChannel/api/tests/getSubChannels.test.ts

@@ -1,8 +1,9 @@
-import { getSubChannels } from '../getSubChannels';
-import { client, generateRawSubChannel } from '~/utils/tests';
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
 
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { ASCApiError } from '~/core/errors';
+
+import { getSubChannels } from '../getSubChannels';
 import { onSubChannelFetched } from '../../events/onSubChannelFetched';
 
 const subChannelId = 'channelId11--sub-channel-id';
@@ -13,8 +14,10 @@ const subChannelPayload = {
 };
 
 describe('createSubChannel', () => {
-  beforeEach(enableCache);
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
 
+  beforeEach(enableCache);
   afterEach(disableCache);
 
   // integration_test_id: dc771f42-14b9-420e-999d-858151e8ce41

package/src/subChannel/api/tests/updateSubChannel.test.ts

@@ -1,11 +1,12 @@
-import { updateSubChannel } from '../updateSubChannel';
-import { client, generateRawSubChannel } from '~/utils/tests';
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
 
 import { onSubChannelUpdated } from '~/subChannel/events';
 
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { ASCApiError } from '~/core/errors';
 
+import { updateSubChannel } from '../updateSubChannel';
+
 const subChannelId = 'channelId11--sub-channel-id';
 
 const subChannelPayload = {
@@ -14,8 +15,10 @@ const subChannelPayload = {
 };
 
 describe('createSubChannel', () => {
-  beforeEach(enableCache);
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
 
+  beforeEach(enableCache);
   afterEach(disableCache);
 
   // integration_test_id: 9f50fa02-c26c-4666-8e8b-2d9076a3edd3

package/src/subChannel/api/updateSubChannel.ts

@@ -32,7 +32,7 @@ export const updateSubChannel = async (
     `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
     { name: patch.displayName },
   );
-  const data = prepareSubChannelPayload(response.data);
+  const data = await prepareSubChannelPayload(response.data);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/subChannel/events/onSubChannelCreated.ts

@@ -21,8 +21,8 @@ import { prepareSubChannelPayload } from '../utils';
 export const onSubChannelCreated = (callback: Amity.Listener<Amity.SubChannel>) => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.SubChannelPayload) => {
-    const payload = prepareSubChannelPayload(rawPayload);
+  const filter = async (rawPayload: Amity.SubChannelPayload) => {
+    const payload = await prepareSubChannelPayload(rawPayload);
 
     ingestInCache(payload);
     callback(payload.messageFeeds[0]);

package/src/subChannel/events/onSubChannelDeleted.ts

@@ -21,8 +21,8 @@ import { prepareSubChannelPayload } from '../utils';
 export const onSubChannelDeleted = (callback: Amity.Listener<Amity.SubChannel>) => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.SubChannelPayload) => {
-    const payload = prepareSubChannelPayload(rawPayload);
+  const filter = async (rawPayload: Amity.SubChannelPayload) => {
+    const payload = await prepareSubChannelPayload(rawPayload);
 
     ingestInCache(payload);
     callback(payload.messageFeeds[0]);

package/src/subChannel/events/onSubChannelUpdated.ts

@@ -1,7 +1,9 @@
+import { pullFromCache, upsertInCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
-import { prepareSubChannelPayload } from '../utils';
+
+import { prepareSubChannelPayload, updateSubChannelMarker } from '../utils';
 
 /**
  * ```js
@@ -21,12 +23,49 @@ import { prepareSubChannelPayload } from '../utils';
 export const onSubChannelUpdated = (callback: Amity.Listener<Amity.SubChannel>) => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.SubChannelPayload) => {
-    const payload = prepareSubChannelPayload(rawPayload);
+  const subChannelChangeHandler = async (rawPayload: Amity.SubChannelPayload) => {
+    const payload = await prepareSubChannelPayload(rawPayload);
 
     ingestInCache(payload);
     callback(payload.messageFeeds[0]);
   };
 
-  return createEventSubscriber(client, 'onSubChannelUpdated', 'message-feed.updated', filter);
+  const subChannelMarkerChangeHandler = async (
+    rawPayload: MakeRequired<Amity.SubChannelMarkerPayload, 'userFeedMarkers'>,
+  ) => {
+    const marker = rawPayload.userFeedMarkers[0];
+    const cacheKey = ['subChannel', 'get', marker.feedId];
+    const subChannel = pullFromCache<Amity.SubChannel>(cacheKey)?.data;
+
+    if (!subChannel) return;
+
+    const updated = updateSubChannelMarker(subChannel, marker);
+    upsertInCache(cacheKey, updated);
+    callback(updated);
+  };
+
+  const disposers = [
+    createEventSubscriber(
+      client,
+      'onSubChannelUpdated',
+      'message-feed.updated',
+      subChannelChangeHandler,
+    ),
+    createEventSubscriber(
+      client,
+      'onSubChannelUpdated',
+      'local.subChannelMarker.fetched',
+      subChannelMarkerChangeHandler,
+    ),
+    createEventSubscriber(
+      client,
+      'onSubChannelUpdated',
+      'local.subChannelMarker.updated',
+      subChannelMarkerChangeHandler,
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
 };

package/src/subChannel/observers/liveSubChannel.ts

@@ -1,4 +1,6 @@
+import {onSubChannelMarkerFetched, onSubChannelMarkerUpdated} from '~/marker/events';
 import { liveObject } from '~/utils/liveObject';
+
 import { getSubChannel } from '../api';
 import { onSubChannelDeleted, onSubChannelUpdated } from '../events';
 import { onSubChannelFetched } from '../events/onSubChannelFetched';

package/src/subChannel/observers/tests/liveSubChannel.test.ts

@@ -5,28 +5,33 @@ import {
   connectClient,
   disconnectClient,
   generateRawSubChannel,
+  convertSubChannelFromRaw,
 } from '~/utils/tests';
 import { createQuery, runQuery } from '~/core/query';
 import { deleteSubChannel, getSubChannel, updateSubChannel } from '~/subChannel/api';
 import { getFutureDate } from '~/core/model';
+
 import { liveSubChannel } from '../liveSubChannel';
-import { convertFromRaw } from '../../utils';
+import * as getSubChannelMarkers from '../../../marker/api/getSubChannelMarkers';
 
 describe('liveSubChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
   const rawSubChannel = generateRawSubChannel();
-  const subChannel = convertFromRaw(rawSubChannel);
+  const subChannel = convertSubChannelFromRaw(rawSubChannel);
   const response = { data: { messageFeeds: [rawSubChannel] } };
 
   beforeAll(async () => {
-    await connectClient();
-  });
+    await connectClient;
 
-  afterAll(async () => {
-    await disconnectClient();
+    jest
+      .spyOn(getSubChannelMarkers, 'getSubChannelMarkers')
+      .mockResolvedValue({ data: [], cachedAt: undefined });
   });
 
+  afterAll(disconnectClient);
   beforeEach(enableCache);
-
   afterEach(disableCache);
 
   const events: [string, keyof Amity.Events][] = [
@@ -52,7 +57,7 @@ describe('liveSubChannel', () => {
     expect(callback).toHaveBeenNthCalledWith(
       3,
       expect.objectContaining({
-        data: convertFromRaw(update),
+        data: convertSubChannelFromRaw(update),
         loading: false,
       }),
     );
@@ -81,7 +86,7 @@ describe('liveSubChannel', () => {
       expect(callback).toHaveBeenNthCalledWith(
         3,
         expect.objectContaining({
-          data: convertFromRaw(update),
+          data: convertSubChannelFromRaw(update),
           loading: false,
         }),
       );
@@ -101,7 +106,7 @@ describe('liveSubChannel', () => {
       expect(callback).toHaveBeenNthCalledWith(
         3,
         expect.objectContaining({
-          data: convertFromRaw(update),
+          data: convertSubChannelFromRaw(update),
           loading: false,
         }),
       );

package/src/subChannel/observers/tests/liveSubChannels.test.ts

@@ -5,12 +5,17 @@ import {
   disconnectClient,
   pause,
   generateRawSubChannel,
+  convertSubChannelFromRaw,
 } from '~/utils/tests';
-import { convertFromRaw } from '~/subChannel/utils';
 import { getFutureDate, getPastDate } from '~/core/model';
+
 import { liveSubChannels } from '../liveSubChannels';
+import * as getSubChannelMarkers from '../../../marker/api/getSubChannelMarkers';
 
 describe('liveSubChannels', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
   const rawSubChannel = generateRawSubChannel();
   const response = {
     data: {
@@ -20,15 +25,15 @@ describe('liveSubChannels', () => {
   };
 
   beforeAll(async () => {
-    await connectClient();
-  });
+    await connectClient;
 
-  afterAll(async () => {
-    await disconnectClient();
+    jest
+      .spyOn(getSubChannelMarkers, 'getSubChannelMarkers')
+      .mockResolvedValue({ data: [], cachedAt: undefined });
   });
 
+  afterAll(disconnectClient);
   beforeEach(enableCache);
-
   afterEach(disableCache);
 
   test('should get sub channels', async () => {
@@ -49,7 +54,7 @@ describe('liveSubChannels', () => {
     expect(callback).toHaveBeenNthCalledWith(
       2,
       expect.objectContaining({
-        data: [convertFromRaw(rawSubChannel)],
+        data: [convertSubChannelFromRaw(rawSubChannel)],
         loading: false,
       }),
     );
@@ -75,7 +80,7 @@ describe('liveSubChannels', () => {
     expect(callback).toHaveBeenNthCalledWith(
       2,
       expect.objectContaining({
-        data: [convertFromRaw(rawSubChannels[1])],
+        data: [convertSubChannelFromRaw(rawSubChannels[1])],
         loading: false,
       }),
     );
@@ -124,7 +129,7 @@ describe('liveSubChannels', () => {
     expect(callback).toHaveBeenNthCalledWith(
       4,
       expect.objectContaining({
-        data: [rawSubChannel, rawSubChannel2].map(convertFromRaw),
+        data: [rawSubChannel, rawSubChannel2].map(data => convertSubChannelFromRaw(data)),
         loading: false,
       }),
     );
@@ -151,7 +156,7 @@ describe('liveSubChannels', () => {
         'should add new sub channel to collection onCreate',
         'message-feed.created',
         newRawSubChannel,
-        [newRawSubChannel, rawSubChannel].map(convertFromRaw),
+        [newRawSubChannel, rawSubChannel].map(data => convertSubChannelFromRaw(data)),
       ],
       [
         'should remove sub channel from collection onDelete',
@@ -163,13 +168,13 @@ describe('liveSubChannels', () => {
         'should update sub channel in collection onUpdate',
         'message-feed.updated',
         updatedRawSubChannel,
-        [updatedRawSubChannel].map(convertFromRaw),
+        [updatedRawSubChannel].map(data => convertSubChannelFromRaw(data)),
       ],
       [
         'should update sub channel in collection onFetch',
         'local.message-feed.fetched',
         updatedRawSubChannel,
-        [updatedRawSubChannel].map(convertFromRaw),
+        [updatedRawSubChannel].map(data => convertSubChannelFromRaw(data)),
       ],
     ];
 
@@ -186,9 +191,11 @@ describe('liveSubChannels', () => {
       if (event === 'local.message-feed.fetched') {
         pushToCache(
           ['subChannel', 'get', rawEventSubChannel.messageFeedId],
-          convertFromRaw(rawEventSubChannel),
+          convertSubChannelFromRaw(rawEventSubChannel),
         );
-        client.emitter.emit(event, { messageFeeds: [convertFromRaw(rawEventSubChannel)] });
+        client.emitter.emit(event, {
+          messageFeeds: [convertSubChannelFromRaw(rawEventSubChannel)],
+        });
       } else {
         client.emitter.emit(event, { messageFeeds: [rawEventSubChannel] });
       }

package/src/subChannel/utils/index.ts

@@ -1,50 +1,2 @@
-export function convertFromRaw({
-  channelId,
-  channelPublicId,
-  channelType,
-  childCount,
-  creatorId,
-  creatorPublicId,
-  lastMessageId,
-  lastMessageTimestamp,
-  messageFeedId,
-  name,
-  ...rest
-}: Amity.RawSubChannel): Amity.SubChannel {
-  return {
-    ...rest,
-    channelId: channelPublicId,
-    creatorId: creatorPublicId,
-    displayName: name,
-    lastActivity: lastMessageTimestamp,
-    latestMessageId: lastMessageId,
-    messageCount: childCount,
-    subChannelId: messageFeedId,
-  };
-}
-
-export const prepareSubChannelPayload = (
-  payload: Amity.SubChannelPayload,
-): Amity.ProcessedSubChannelPayload => {
-  return {
-    ...payload,
-    messageFeeds: payload.messageFeeds.map(convertFromRaw),
-  };
-};
-
-type RawQuerySubChannels = Omit<Amity.QuerySubChannels, 'excludeDefaultSubChannel'> & {
-  excludeDefaultMessageFeed?: Amity.QuerySubChannels['excludeDefaultSubChannel'];
-};
-
-export function convertQueryParams({
-  excludeDefaultSubChannel,
-  ...rest
-}: Amity.QuerySubChannels): RawQuerySubChannels {
-  const out: RawQuerySubChannels = { ...rest };
-
-  if (excludeDefaultSubChannel !== undefined) {
-    out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
-  }
-
-  return out;
-}
+export * from './prepareSubChannelPayload';
+export * from './markReadEngine';

package/src/subChannel/utils/markReadEngine.ts

@@ -0,0 +1,117 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient, getActiveUser } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { getResolver } from '~/core/model';
+import { onMessageCreated } from '~/message/events';
+
+import { startReadingAPI } from '../api/startReadingAPI';
+import { stopReadingAPI } from '../api/stopReadingAPI';
+
+let disposers: (() => void)[] = [];
+const isReadingMap: Record<string, boolean> = {};
+
+const updateReadToSegment = (message: Amity.Message) => {
+  if (!isReadingMap[message.subChannelId]) return;
+
+  const client = getActiveClient();
+
+  if (!client.cache) return;
+
+  const key = {
+    entityId: message.channelId,
+    feedId: message.subChannelId,
+    userId: getActiveUser()._id,
+  };
+
+  const currentValue = pullFromCache<Amity.SubChannelMarker>([
+    'subChannelMarker',
+    'get',
+    getResolver('subChannelMarker')(key),
+  ])?.data;
+
+  if (!currentValue) return;
+
+  const userFeedMarkers = [{ ...currentValue, readToSegment: message.channelSegment }];
+  fireEvent('local.subChannelMarker.updated', { userFeedMarkers });
+};
+
+/**
+ * the event callback when app is back to online
+ */
+const onOnline = () => {
+  const callback = () => {
+    // Start reading the reading subChannel again when resume from offline state
+    Object.entries(isReadingMap).forEach(([subChannelId, isReading]) => {
+      if (isReading) startReadingAPI(subChannelId);
+    });
+  };
+
+  window.addEventListener('online', callback);
+
+  return () => window.removeEventListener('online', callback);
+};
+
+const registerEventListeners = () => {
+  disposers.push(onOnline(), onMessageCreated(updateReadToSegment));
+};
+
+const unRegisterEventListeners = () => {
+  disposers.forEach(fn => fn());
+  disposers = [];
+};
+
+/* begin_public_function
+  id: channel.start_reading
+*/
+
+/**
+ * ```js
+ * import { startReading } from '@amityco/ts-sdk'
+ * const success = await startReading('foo')
+ * ```
+ *
+ * Set local reading state of channel to `true` and then call mark all
+ * messages as read API.
+ *
+ * @param subChannelId - The sub channel ID to start reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ */
+export const startReading = (subChannelId: Amity.SubChannel['subChannelId']) => {
+  isReadingMap[subChannelId] = true;
+
+  if (disposers.length === 0) {
+    registerEventListeners();
+  }
+
+  return startReadingAPI(subChannelId);
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: channel.stop_reading
+*/
+
+/**
+ * ```js
+ * import { stopReading } from '@amityco/ts-sdk'
+ * const success = await stopReading('foo')
+ * ```
+ *
+ * Set local reading state of channel to `false` and then call mark all
+ * messages as unread API.
+ *
+ * @param subChannelId - The sub channel ID to stop reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ */
+export const stopReading = (subChannelId: Amity.SubChannel['subChannelId']) => {
+  isReadingMap[subChannelId] = false;
+  unRegisterEventListeners();
+  return stopReadingAPI(subChannelId);
+};
+/* end_public_function */

package/src/subChannel/utils/prepareSubChannelPayload.ts

@@ -0,0 +1,132 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveUser } from '~/client/api';
+import { getResolver } from '~/core/model';
+import { getSubChannelMarkers } from '~/marker/api';
+
+export const MARKER_INCLUDED_SUB_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
+
+/**
+ * Filter sub channel by type. Only conversation, community and broadcast type are included.
+ */
+export const isUnreadCountSupport = ({ channelType }: Pick<Amity.RawSubChannel, 'channelType'>) =>
+  MARKER_INCLUDED_SUB_CHANNEL_TYPE.includes(channelType);
+
+export function getUnreadCount(
+  channelId: string,
+  subChannelId: string,
+  marker?: Amity.SubChannelMarker,
+) {
+  // Look for `unreadCount` in the marker param first
+  if (marker) {
+    return marker.unreadCount;
+  }
+
+  const key = {
+    entityId: channelId,
+    feedId: subChannelId,
+    userId: getActiveUser()._id,
+  };
+
+  // If the marker param is not set, look in the cache
+  const cachedMarker = pullFromCache<Amity.SubChannelMarker>([
+    'subChannelMarker',
+    'get',
+    getResolver('subChannelMarker')(key),
+  ])?.data;
+
+  if (cachedMarker) {
+    return cachedMarker.unreadCount;
+  }
+
+  // and if not found in cache use default value `0`
+  return 0;
+}
+
+export function convertFromRaw(
+  {
+    channelId,
+    channelPublicId,
+    channelType,
+    childCount,
+    creatorId,
+    creatorPublicId,
+    lastMessageId,
+    lastMessageTimestamp,
+    messageFeedId,
+    name,
+    ...rest
+  }: Amity.RawSubChannel,
+  marker?: Amity.SubChannelMarker,
+): Amity.SubChannel {
+  return {
+    ...rest,
+    channelId: channelPublicId,
+    creatorId: creatorPublicId,
+    displayName: name,
+    lastActivity: lastMessageTimestamp,
+    latestMessageId: lastMessageId,
+    messageCount: childCount,
+    subChannelId: messageFeedId,
+    isUnreadCountSupport: isUnreadCountSupport({ channelType }),
+    unreadCount: getUnreadCount(channelId, messageFeedId, marker),
+  };
+}
+
+export function updateSubChannelMarker(
+  subChannel: Amity.SubChannel,
+  marker?: Amity.SubChannelMarker,
+): Amity.SubChannel {
+  return {
+    ...subChannel,
+    unreadCount: getUnreadCount(subChannel.channelId, subChannel.subChannelId, marker),
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+export const prepareSubChannelPayload = async (
+  rawPayload: Amity.SubChannelPayload,
+): Promise<Amity.ProcessedSubChannelPayload> => {
+  // make a fetch marker to prepare it for merging with the raw channel payload.
+  let markers: Amity.SubChannelMarker[] = [];
+
+  const markerIds = rawPayload.messageFeeds
+    .filter(isUnreadCountSupport)
+    .map(({ messageFeedId }) => messageFeedId);
+
+  if (markerIds.length > 0)
+    // from the spec, allow marker fetch to fail
+    try {
+      ({ data: markers } = await getSubChannelMarkers(markerIds));
+    } catch (e) {
+      // empty block
+    }
+
+  // attach marker to sub channel
+  const messageFeeds = rawPayload.messageFeeds.map(messageFeed => {
+    const marker = markers?.find(({ feedId }) => feedId === messageFeed.messageFeedId);
+
+    return convertFromRaw(messageFeed, marker);
+  });
+
+  return {
+    ...rawPayload,
+    messageFeeds,
+  };
+};
+
+type RawQuerySubChannels = Omit<Amity.QuerySubChannels, 'excludeDefaultSubChannel'> & {
+  excludeDefaultMessageFeed?: Amity.QuerySubChannels['excludeDefaultSubChannel'];
+};
+
+export function convertQueryParams({
+  excludeDefaultSubChannel,
+  ...rest
+}: Amity.QuerySubChannels): RawQuerySubChannels {
+  const out: RawQuerySubChannels = { ...rest };
+
+  if (excludeDefaultSubChannel !== undefined) {
+    out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
+  }
+
+  return out;
+}