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

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

package/src/utils/liveObject.ts

@@ -8,12 +8,18 @@ import { hasUpdates } from '~/core/model';
 import { createQuery, runQuery } from '~/core/query';
 import { ASCApiError } from '~/core/errors';
 
-export const liveObject = <T extends Amity.Models[Amity.Domain], K extends keyof T>(
+export const liveObject = <
+  T extends Amity.Models[Amity.Domain],
+  K extends keyof T,
+  CallbackData extends any = any,
+>(
   id: T[K],
-  callback: Amity.LiveObjectCallback<T>,
+  callback: Amity.LiveObjectCallback<CallbackData>,
   key: K,
   fetcher: (id: T[K]) => Promise<Amity.Cached<T>>,
   eventHandlers: Array<(callback: Amity.Listener<T>) => Amity.Unsubscriber>,
+  callbackDataSelector: (data: T) => CallbackData = data => <CallbackData>data,
+  callbackFilter?: (currentModel: T, previousModel: T) => boolean,
 ): Amity.Unsubscriber => {
   const { cache } = getActiveClient();
 
@@ -26,8 +32,13 @@ export const liveObject = <T extends Amity.Models[Amity.Domain], K extends keyof
   const disposers: Amity.Unsubscriber[] = [];
 
   const dispatcher = (data: Amity.LiveObject<T>) => {
-    model = data.data;
-    callback(data);
+    const { data: newModel, ...rest } = data;
+
+    if (!callbackFilter || callbackFilter(newModel, model)) {
+      callback({ data: callbackDataSelector(newModel), ...rest });
+    }
+
+    model = newModel;
   };
 
   const realtimeRouter = (eventModel: T) => {

package/src/utils/tests/client.ts

@@ -6,6 +6,8 @@ import {
 
 import { user11 } from './dummy';
 
+export const activeUser = user11;
+
 const sessionHandler: Amity.SessionHandler = {
   sessionWillRenewAccessToken(_) {
     // do nothing
@@ -28,7 +30,7 @@ export const connectClient = async () => {
     data: {
       accessToken: 'accessToken',
       refreshToken: 'refreshToken',
-      users: [user11],
+      users: [activeUser],
       expiresAt: nextMonth.toISOString(),
       issuedAt: now.toISOString(),
     },

package/src/utils/tests/dummy/channel.ts

@@ -1,6 +1,26 @@
+import { withUsers } from '~/group/utils';
 import { convertFromRaw } from '~/channel/utils';
+import { activeUser } from '~/utils/tests';
+import * as activeUserModule from '~/client/api/activeUser';
+
 import { date, user11, user12, user13, user14, file11 } from '.';
 
+export const convertChannelFromRaw = (
+  channel: Amity.RawChannel,
+  marker?: Amity.ChannelMarker,
+): Amity.Channel => {
+  jest.spyOn(activeUserModule, 'getActiveUser').mockReturnValue(activeUser);
+  return convertFromRaw(channel, marker);
+};
+
+export const convertRawChannelPayload = (
+  rawPayload: Amity.ChannelPayload,
+): Amity.ProcessedChannelPayload => ({
+  ...rawPayload,
+  channels: rawPayload.channels.map(channel => convertChannelFromRaw(channel)),
+  channelUsers: withUsers(rawPayload.channelUsers),
+});
+
 export function generateRawChannel(params?: Partial<Amity.RawChannel>): Amity.RawChannel {
   const channelId = params?.channelId ?? 'channelId11';
 
@@ -19,7 +39,7 @@ export function generateRawChannel(params?: Partial<Amity.RawChannel>): Amity.Ra
   };
 }
 
-function generateRawChannelUser(
+export function generateRawChannelUser(
   params?: Partial<Amity.RawMembership<'channel'>>,
 ): Amity.RawMembership<'channel'> {
   return {
@@ -38,15 +58,14 @@ function generateRawChannelUser(
     ...params,
   };
 }
-function convertChannelUserFromRaw(
+
+export const convertChannelUserFromRaw = (
   member: Amity.RawMembership<'channel'>,
-  user: Amity.User,
-): Amity.Membership<'channel'> {
-  return {
-    ...member,
-    user,
-  };
-}
+  user: Amity.User | undefined,
+): Amity.Membership<'channel'> => ({
+  ...member,
+  user,
+});
 
 export const mockPage = {
   paging: {
@@ -73,19 +92,17 @@ export const channelRaw3: Amity.RawChannel = generateRawChannel({
   channelId: 'channelId21',
 });
 
-export const channel1: Amity.Channel = convertFromRaw(channelRaw1, {
-  defaultSubChannelHasUnreadMention: false,
-  defaultSubChannelUnreadCount: 0,
-  localLastMentionSegment: 0,
-  localReadToSegment: 0,
-});
+export const channel1: Amity.Channel = {
+  ...channelRaw1,
+  isUnreadCountSupport: true,
+  unreadCount: 0,
+};
 
-export const channel2: Amity.Channel = convertFromRaw(channelRaw2, {
-  defaultSubChannelHasUnreadMention: false,
-  defaultSubChannelUnreadCount: 0,
-  localLastMentionSegment: 0,
-  localReadToSegment: 0,
-});
+export const channel2: Amity.Channel = {
+  ...channelRaw2,
+  isUnreadCountSupport: true,
+  unreadCount: 0,
+};
 
 export const rawChannelUser = generateRawChannelUser();
 export const channelUser = convertChannelUserFromRaw(rawChannelUser, user11);

package/src/utils/tests/dummy/comment.ts

@@ -1,6 +1,6 @@
-import { createComment, queryComments } from '~/comment/api';
+import { createComment } from '~/comment/api';
 import { file11 } from './file';
-import { post11, post12 } from './post';
+import { post11 } from './post';
 import { user11, user12 } from './user';
 
 export function generateComment(params?: Partial<Amity.Comment>): Amity.Comment {

package/src/utils/tests/dummy/index.ts

@@ -14,6 +14,7 @@ export * from './reaction';
 
 export * from './channel';
 export * from './subChannel';
+export * from './marker';
 
 export * from './message';
 export * from './token';

package/src/utils/tests/dummy/marker.ts

@@ -0,0 +1,68 @@
+import { activeUser } from '../client';
+import { date } from '.';
+
+export const generateChannelMarker = ({
+  entityId,
+  ...params
+}: MakeRequired<Amity.ChannelMarker, 'entityId'>): Amity.ChannelMarker => ({
+  entityId,
+  userId: activeUser.userId,
+  unreadCount: 0,
+  isDeleted: false,
+  createdAt: date,
+  updatedAt: date,
+  ...params,
+});
+
+export const generateSubChannelMarker = ({
+  feedId,
+  entityId,
+  ...params
+}: MakeRequired<Amity.SubChannelMarker, 'feedId' | 'entityId'>): Amity.SubChannelMarker => ({
+  feedId,
+  entityId,
+  userId: activeUser.userId,
+  readToSegment: 0,
+  deliveredToSegment: 0,
+  unreadCount: 0,
+  createdAt: date,
+  updatedAt: date,
+  ...params,
+});
+
+export const generateMessageMarker = ({
+  feedId,
+  contentId,
+  ...params
+}: MakeRequired<Amity.MessageMarker, 'feedId' | 'contentId'>): Amity.MessageMarker => ({
+  feedId,
+  contentId,
+  creatorId: activeUser.userId,
+  readCount: 0,
+  deliveredCount: 0,
+  createdAt: date,
+  updatedAt: date,
+  ...params,
+});
+export const generateFeedMarker = ({
+  feedId,
+  entityId,
+  ...params
+}: MakeRequired<Amity.FeedMarker, 'feedId' | 'entityId'>): Amity.FeedMarker => ({
+  feedId,
+  entityId,
+  lastSegment: 0,
+  isDeleted: false,
+  createdAt: date,
+  updatedAt: date,
+  ...params,
+});
+
+export const generateUserMarker = (params?: Partial<Amity.UserMarker>): Amity.UserMarker => ({
+  lastSyncAt: date,
+  userId: activeUser.userId,
+  unreadCount: 0,
+  createdAt: date,
+  updatedAt: date,
+  ...params,
+});

package/src/utils/tests/dummy/message.ts

@@ -1,4 +1,3 @@
-import { convertFromRaw } from '~/message/utils';
 import { channel1, user11, file11 } from '.';
 
 export function generateRawMessage(params?: Partial<Amity.RawMessage>): Amity.RawMessage {
@@ -28,7 +27,48 @@ export function generateRawMessage(params?: Partial<Amity.RawMessage>): Amity.Ra
   };
 }
 
-export const message11: Amity.Message = convertFromRaw(
+export const convertRawMessage = ({
+  channelPublicId,
+  childCount,
+  creatorPublicId,
+  mentionedUsers,
+  messageFeedId,
+  reactionCount,
+  reactions,
+  referenceId,
+  segment,
+  messageId,
+  myReactions,
+  ...rest
+}: Amity.RawMessage): Amity.Message => ({
+  ...rest,
+  messageId,
+  channelId: channelPublicId,
+  channelSegment: segment,
+  childrenNumber: childCount,
+  creatorId: creatorPublicId,
+  mentionees: mentionedUsers?.map(mention => {
+    if (mention.type === 'channel') return mention;
+
+    return { type: 'user', userIds: mention.userPublicIds };
+  }),
+  reactions: reactions ?? {},
+  reactionsCount: reactionCount,
+  subChannelId: messageFeedId,
+  uniqueId: messageId,
+  myReactions: [],
+  readCount: 0,
+  deliveredCount: 0,
+});
+
+export const convertRawMessagePayload = (
+  rawPayload: Amity.MessagePayload,
+): Amity.ProcessedMessagePayload => ({
+  ...rawPayload,
+  messages: rawPayload.messages.map(convertRawMessage),
+});
+
+export const message11: Amity.Message = convertRawMessage(
   generateRawMessage({
     channelPublicId: channel1.channelId,
     creatorPublicId: user11.userId,

package/src/utils/tests/dummy/post.ts

@@ -1,4 +1,4 @@
-import { user11, user12, file11, communityUser11, date, feed11 } from '.';
+import { date, feed11, user11 } from '.';
 
 import { encodeJson } from '..';
 

package/src/utils/tests/dummy/subChannel.ts

@@ -1,11 +1,14 @@
+import * as activeUserModule from '~/client/api/activeUser';
 import { convertFromRaw } from '~/subChannel/utils';
-import { channel1, date, user11 } from '.';
+import { activeUser } from '~/utils/tests';
+
+import { channelRaw1, date, user11 } from '.';
 
 export function generateRawSubChannel(params?: Partial<Amity.RawSubChannel>): Amity.RawSubChannel {
   return {
     channelId: 'private-channel-id',
-    channelPublicId: channel1.channelId,
-    channelType: channel1.type,
+    channelPublicId: channelRaw1.channelId,
+    channelType: channelRaw1.type,
     childCount: 0,
     createdAt: date,
     creatorId: 'private-user-id',
@@ -13,7 +16,7 @@ export function generateRawSubChannel(params?: Partial<Amity.RawSubChannel>): Am
     isDeleted: false,
     lastMessageId: 'xxx',
     lastMessageTimestamp: date,
-    messageFeedId: `${channel1.channelId}--sub-channel-id`,
+    messageFeedId: `${channelRaw1.channelId}--sub-channel-id`,
     name: 'sub channel name',
     path: 'sub-channel-path',
     updatedAt: date,
@@ -21,9 +24,17 @@ export function generateRawSubChannel(params?: Partial<Amity.RawSubChannel>): Am
   };
 }
 
+export const convertSubChannelFromRaw = (
+  subChannel: Amity.RawSubChannel,
+  marker?: Amity.SubChannelMarker,
+): Amity.SubChannel => {
+  jest.spyOn(activeUserModule, 'getActiveUser').mockReturnValue(activeUser);
+  return convertFromRaw(subChannel, marker);
+};
+
 export function generateSubChannel(params?: Record<string, any>): Amity.SubChannel {
   return {
-    ...convertFromRaw(generateRawSubChannel()),
+    ...convertSubChannelFromRaw(generateRawSubChannel()),
     ...params,
   };
 }

package/src/utils/tests/utils.ts

@@ -6,8 +6,11 @@ export const encodeJson = (value: Record<string, any>) => encode(JSON.stringify(
  * Used instead of asserting an async request is completed, when the async
  * request is not the API being tested. This util makes tests readable by moving
  * all assertions to the end of the test
+ *
+ * Use 500ms by default on MacBook Pro Core-i5 2020. Lower than this is not enough
+ * to wait for async task before assertions.
  */
-export const pause = (ms = 50) =>
+export const pause = (ms = 500) =>
   new Promise(resolve => {
     setTimeout(resolve, ms);
   });

package/dist/channel/api/startReading.d.ts

@@ -1,17 +0,0 @@
-/**
- * ```js
- * import { startReading } from '@amityco/ts-sdk'
- * const success = await startReading('foo')
- * ```
- *
- * Mark all messages as read and start reading message inside channel
- *
- * @param subChannelId - The channel ID to start reading.
- * @param userId - The user ID of channel member.
- * @return A success boolean if the channel reading of the sub channel had begun.
- *
- * @category Message API
- * @async
- */
-export declare const startReading: (subChannelId: string, userId?: string | undefined) => Promise<boolean | undefined>;
-//# sourceMappingURL=startReading.d.ts.map

package/dist/channel/api/startReading.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"startReading.d.ts","sourceRoot":"","sources":["../../../src/channel/api/startReading.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,iBAAwB,MAAM,8DAiCtD,CAAC"}

package/dist/channel/api/stopReading.d.ts

@@ -1,16 +0,0 @@
-/**
- * ```js
- * import { stopReading } from '@amityco/ts-sdk'
- * const success = await stopReading('foo')
- * ```
- *
- * Stop reading message inside channel
- *
- * @param subChannelId - The channel ID to stop reading.
- * @return A success boolean if the sub channel reading was halted.
- *
- * @category Message API
- * @async
- */
-export declare const stopReading: (subChannelId: string) => Promise<boolean | undefined>;
-//# sourceMappingURL=stopReading.d.ts.map

package/dist/channel/api/stopReading.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stopReading.d.ts","sourceRoot":"","sources":["../../../src/channel/api/stopReading.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,iBAAwB,MAAM,iCA8BrD,CAAC"}

package/dist/channel/api/tests/startReading.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=startReading.test.d.ts.map

package/dist/channel/api/tests/startReading.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"startReading.test.d.ts","sourceRoot":"","sources":["../../../../src/channel/api/tests/startReading.test.ts"],"names":[],"mappings":""}

package/dist/channel/api/tests/stopReading.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=stopReading.test.d.ts.map

package/dist/channel/api/tests/stopReading.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stopReading.test.d.ts","sourceRoot":"","sources":["../../../../src/channel/api/tests/stopReading.test.ts"],"names":[],"mappings":""}