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

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/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,5 +1,4 @@
-import { convertFromRaw } from '~/message/utils';
-import { channel1, file11, user11 } from '.';
+import { channel1, user11, file11 } from '.';
 
 export function generateRawMessage(params?: Partial<Amity.RawMessage>): Amity.RawMessage {
   return {
@@ -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/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":""}

package/src/channel/api/startReading.ts

@@ -1,57 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { synchronousWSCall } from '~/core/transports';
-import { pullFromCache, pushToCache } from '~/cache/api';
-
-/* begin_public_function
-  id: channel.start_reading
-*/
-/**
- * ```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 const startReading = async (subChannelId: string, userId = getActiveClient().userId) => {
-  const client = getActiveClient();
-  client.log('message/startReading', { subChannelId });
-
-  const subChannel = pullFromCache<Amity.SubChannel>(['subChannel', 'get', subChannelId]);
-
-  if (!subChannel) {
-    return;
-  }
-
-  const { channelId } = subChannel.data;
-  const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId]);
-
-  if (!channel || channel.data.defaultSubChannelId !== subChannelId) {
-    return;
-  }
-
-  const update: Amity.Channel = {
-    ...channel.data,
-    // @ts-ignore
-    localReading: true,
-    defaultSubChannelUnreadCount: 0,
-    defaultSubChannelHasUnreadMention: false,
-  };
-
-  pushToCache(['channel', 'get', channelId], update);
-  client.emitter.emit('local.channel.updated', { channels: [update] });
-
-  const result = await synchronousWSCall<Record<never, never>>(client, 'channel.startReading', {
-    channelId,
-  });
-
-  return !!result;
-};
-/* end_public_function */

package/src/channel/api/stopReading.ts

@@ -1,53 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { synchronousWSCall } from '~/core/transports';
-import { pullFromCache, pushToCache } from '~/cache/api';
-
-/* begin_public_function
-  id: channel.stop_reading
-*/
-/**
- * ```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 const stopReading = async (subChannelId: string) => {
-  const client = getActiveClient();
-  client.log('message/stopReading', { subChannelId });
-
-  const subChannel = pullFromCache<Amity.SubChannel>(['subChannel', 'get', subChannelId]);
-
-  if (!subChannel) {
-    return;
-  }
-
-  const { channelId } = subChannel.data;
-  const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId]);
-
-  if (!channel || channel.data.defaultSubChannelId !== subChannelId) {
-    return;
-  }
-
-  const update: Amity.Channel = {
-    ...channel.data,
-    // @ts-ignore
-    localReading: false,
-  };
-
-  pushToCache(['channel', 'get', channelId], update);
-
-  const result = await synchronousWSCall<Record<never, never>>(client, 'channel.stopReading', {
-    channelId,
-  });
-
-  return !!result;
-};
-/* end_public_function */

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

@@ -1,25 +0,0 @@
-import { channel1, client } from '~/utils/tests';
-
-import { startReading } from '../startReading';
-
-const resolvedSuccessValue = { status: 'success', data: {} };
-const resolvedErrorValue = { status: 'error', message: 'error', code: 500000 };
-
-// FIXME: wait for marker service
-xdescribe('startReading', () => {
-  test('should resolves true value', async () => {
-    client.ws.emit = jest
-      .fn()
-      .mockImplementationOnce((event, data, callback) => callback(resolvedSuccessValue));
-
-    await expect(startReading(channel1.channelId)).resolves.toEqual(true);
-  });
-
-  test('should throw an error if request fails', async () => {
-    client.ws.emit = jest
-      .fn()
-      .mockImplementationOnce((event, data, callback) => callback(resolvedErrorValue));
-
-    await expect(startReading(channel1.channelId)).rejects.toThrow(resolvedErrorValue.message);
-  });
-});

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

@@ -1,25 +0,0 @@
-import { channel1, client } from '~/utils/tests';
-
-import { stopReading } from '../stopReading';
-
-const resolvedSuccessValue = { status: 'success', data: {} };
-const resolvedErrorValue = { status: 'error', message: 'error', code: 500000 };
-
-// FIXME: wait for marker service
-xdescribe('stopReading', () => {
-  test('should resolves true value', async () => {
-    client.ws.emit = jest
-      .fn()
-      .mockImplementationOnce((event, data, callback) => callback(resolvedSuccessValue));
-
-    await expect(stopReading(channel1.channelId)).resolves.toEqual(true);
-  });
-
-  test('should throw an error if request fails', async () => {
-    client.ws.emit = jest
-      .fn()
-      .mockImplementationOnce((event, data, callback) => callback(resolvedErrorValue));
-
-    await expect(stopReading(channel1.channelId)).rejects.toThrow(resolvedErrorValue.message);
-  });
-});