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

package/src/client/api/connectClient.ts

@@ -1,6 +1,5 @@
 /* eslint-disable no-param-reassign */
 /* eslint-disable require-atomic-updates */
-import { disconnectClient } from '~/client/api/disconnectClient';
 import { getDeviceId } from '~/core/device';
 import { proxyWebsocketEvents } from '~/core/events';
 import {
@@ -14,6 +13,8 @@ import {
 
 import { onUserDeleted } from '~/user/events/onUserDeleted';
 
+import { disconnectClient } from './disconnectClient';
+
 import { getActiveClient } from './activeClient';
 import { terminateClient } from './terminateClient';
 import { setActiveUser, getActiveUser } from './activeUser';

package/src/client/api/index.ts

@@ -1,4 +1,5 @@
 export { getActiveClient } from './activeClient';
+export * from './activeUser';
 
 export * from './createClient';
 
@@ -10,3 +11,5 @@ export * from './isConnected';
 export * from './getFeedSettings';
 
 export * from './renewal';
+
+export * from './markerSync';

package/src/client/api/markerSync.ts

@@ -0,0 +1,42 @@
+import { fireEvent } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { getActiveClient } from './activeClient';
+
+/**
+ * ```js
+ * import { markerSync } from '@amityco/ts-sdk'
+ * const success = await markerSync()
+ * ```
+ *
+ * Make all markers synced
+ * * If response is empty means that the sync has ended.
+ * * If response is not empty, the sync has not ended. You must call markerSync
+ * again to continue syncing.
+ *
+ * @return {hasMore} A success boolean if the marker sync was ended.
+ *
+ * @category Marker API
+ * @async
+ * @private
+ */
+export const markerSync = async (): Promise<{ hasMore: boolean }> => {
+  const client = getActiveClient();
+  client.log('channel/markerSync');
+
+  const { data: payload } = await client.http.post<Amity.MarkerSyncPayload>(`/api/v1/markers/sync`);
+
+  const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.MarkerSyncPayload, { cachedAt });
+
+  feedMarkers.length && fireEvent('local.feedMarker.fetched', { feedMarkers });
+  userEntityMarkers.length && fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+  userFeedMarkers.length && fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+  userMarkers.length && fireEvent('local.userMarker.fetched', { userMarkers });
+
+  return {
+    hasMore: payload.feedMarkers.length > 0,
+  };
+};

package/src/client/observers/getTotalUnreadCount.ts

@@ -0,0 +1,52 @@
+import { ASCError } from '~/core/errors';
+import { getUserMarker } from '~/marker/api';
+import { onUserMarkerFetched } from '~/marker/events';
+import { liveObject } from '~/utils/liveObject';
+
+import { getActiveUser } from '../api';
+
+/**
+ * ```js
+ * import { getTotalUnreadCount } from '@amityco/ts-sdk';
+ *
+ * const unsubscribe = getTotalUnreadCount(response => {
+ *   totalUnreadCount = response.data;
+ * });
+ * ```
+ *
+ * Observe current user's unread count from {@link Amity.UserMarker}
+ *
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the events
+ *
+ * @category Message Live Object
+ */
+export const getTotalUnreadCount = (
+  callback: Amity.LiveObjectCallback<number>,
+): Amity.Unsubscriber => {
+  const { _id: userId } = getActiveUser();
+
+  if (!userId)
+    throw new ASCError(
+      'The _id has not been defined in ActiveUser',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.ERROR,
+    );
+
+  const callbackPayloadSelector = (data: Amity.UserMarker) => data?.unreadCount ?? 0;
+
+  // based on the mobile specs, unreadCount will not trigger observer when userMarker
+  // is re-fetched, so apply this filter to ensure the behavior is the same.
+  const callbackFilter = (newModel: Amity.UserMarker, oldModel: Amity.UserMarker) =>
+    newModel?.unreadCount !== oldModel?.unreadCount;
+
+  return liveObject(
+    userId,
+    callback,
+    'userId',
+    getUserMarker,
+    [onUserMarkerFetched],
+    callbackPayloadSelector,
+    callbackFilter,
+  );
+};

package/src/client/observers/index.ts

@@ -0,0 +1 @@
+export * from './getTotalUnreadCount';

package/src/client/observers/tests/getTotalUnreadCount.test.ts

@@ -0,0 +1,126 @@
+import { getActiveUser, setActiveUser } from '~/client/api/activeUser';
+import { getTotalUnreadCount } from '~/client/observers';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+import { pause, client, connectClient, disconnectClient, generateUserMarker } from '~/utils/tests';
+
+const refreshUpdateTime = <T extends ValueOf<Amity.Events>>(eventPayload: T): T => {
+  if (!eventPayload) return eventPayload;
+
+  // @ts-ignore
+  return Object.fromEntries(
+    Object.entries(eventPayload).map(([k, v]) => [
+      k,
+      v.map((model: Amity.Model) => ({
+        ...model,
+        updatedAt: Date.now(),
+      })),
+    ]),
+  );
+};
+
+const userId = 'user1';
+
+describe('getTotalUnreadCount', () => {
+  beforeAll(async () => {
+    await connectClient();
+
+    // overwrite active userId with test id
+    setActiveUser({ ...getActiveUser(), _id: userId });
+  });
+
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const events: [string, keyof Amity.Events, ValueOf<Amity.Events>, any][] = [
+    [
+      'it should return correct payload on `onUserMarkerFetched`',
+      'local.userMarker.fetched',
+      {
+        userMarkers: [generateUserMarker({ userId, unreadCount: 2 })],
+      },
+      {
+        origin: 'event',
+        loading: false,
+        data: 2,
+      },
+    ],
+  ];
+
+  test.each(events)('%s', async (test, event, eventPayload, expected) => {
+    const callback = jest.fn();
+
+    getTotalUnreadCount(callback);
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    // on initial, expect 0 unread count
+    expect(callback).toHaveBeenLastCalledWith({
+      origin: 'local',
+      loading: false,
+      error: undefined,
+      data: 0,
+    });
+
+    client.emitter.emit(event, refreshUpdateTime(eventPayload));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenLastCalledWith(expected);
+  });
+
+  test('it should trigger the initiate callback to align with the cache', async () => {
+    const callback = jest.fn();
+
+    pushToCache(
+      ['userMarker', 'get', getResolver('userMarker')({ userId })],
+      generateUserMarker({ userId, unreadCount: 1 }),
+      {
+        cachedAt: Date.now(),
+      },
+    );
+
+    getTotalUnreadCount(callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenLastCalledWith({
+      origin: 'local',
+      loading: false,
+      error: undefined,
+      data: 1,
+    });
+  });
+
+  test('it should filter out duplicated callback', async () => {
+    const callback = jest.fn();
+
+    const eventPayload = {
+      userMarkers: [generateUserMarker({ userId, unreadCount: 2 })],
+    };
+
+    getTotalUnreadCount(callback);
+
+    await pause();
+
+    // initial callback
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    client.emitter.emit('local.userMarker.fetched', refreshUpdateTime(eventPayload));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // emit duplicated event
+    client.emitter.emit('local.userMarker.fetched', refreshUpdateTime(eventPayload));
+
+    await pause();
+
+    // should not re-trigger
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+});

package/src/client/utils/index.ts

@@ -0,0 +1 @@
+export * from './markerSyncEngine';

package/src/client/utils/markerSyncEngine.ts

@@ -0,0 +1,179 @@
+import { onMessageCreated } from '~/message/events';
+import { onSubChannelCreated, onSubChannelDeleted } from '~/subChannel/events';
+import { isUnreadCountSupport } from '~/subChannel/utils';
+
+import { markerSync } from '../api';
+
+const FORCE_SYNC_INTERVAL_TIME = 8000;
+const SYNC_TRIGGER_INTERVAL_TIME = 2000;
+
+let clearSyncTrigger: Amity.Unsubscriber | undefined;
+let disposers: (() => void)[] = [];
+let isWaitingForResponse = false;
+
+/**
+ * list of conditions that make timer still trigger the syncing process.
+ * If it's empty, it means sync is stopped.
+ * if it's not empty, sync will resume.
+ */
+let events: Amity.MarkerSyncEvent[] = [];
+
+/**
+ * get current marker sync event list
+ * @private
+ */
+export const getMarkerSyncEvents = () => events;
+
+/**
+ * set marker sync events
+ * @private
+ */
+export const setMarkerSyncEvents = (newEvents: Amity.MarkerSyncEvent[]) => {
+  events = newEvents;
+};
+
+/**
+ * push new event to marker sync events
+ * @private
+ */
+export const pushMarkerSyncEvent = (event: Amity.MarkerSyncEvent) => events.push(event);
+
+/**
+ * interval task
+ * @private
+ */
+export const markerSyncTrigger = async (markerSync: () => Promise<{ hasMore: boolean }>) => {
+  if (isWaitingForResponse) {
+    // waiting for the response no need to make another API call
+    return;
+  }
+
+  if (events.length === 0) {
+    // no event that require to call marker sync API
+    return;
+  }
+
+  isWaitingForResponse = true;
+
+  // any past events are considered processed here.
+  // however during waiting for the response, RTE could add the new message event;
+  // which will make the engine trigger another call next round.
+  events = [];
+
+  const response = await markerSync();
+
+  if (response.hasMore) {
+    events.push(Amity.MarkerSyncEvent.HAS_MORE);
+  }
+
+  // eslint-disable-next-line require-atomic-updates
+  isWaitingForResponse = false;
+};
+
+/**
+ * the event callback when app is back to online
+ */
+const onOnline = () => {
+  // should add RESUME to the event to trigger marker syncing again
+  const callback = () => events.push(Amity.MarkerSyncEvent.RESUME);
+
+  window.addEventListener('online', callback);
+
+  return () => window.removeEventListener('online', callback);
+};
+
+const setIntervalTask = (handler: () => void, timeout: number) => {
+  const timer = setInterval(handler, timeout);
+  return () => clearInterval(timer);
+};
+
+const registerEventListeners = () => {
+  // based on the tech spec design, we designed a fetch marker in case of these events
+  // - new message
+  // - create channel
+  // - remove channel
+  // - app going to online again after offline
+  disposers.push(
+    onOnline(),
+
+    onMessageCreated(
+      message => {
+        // only conversation, community and broadcast types can sync
+        if (isUnreadCountSupport(message)) events.push(Amity.MarkerSyncEvent.NEW_MESSAGE);
+      },
+      // only trigger sync from remote events to prevent an unread count equal `-1`
+      // when an optimistic message creation is performed.
+      false,
+    ),
+
+    onSubChannelCreated(() => events.push(Amity.MarkerSyncEvent.SUB_CHANNEL_CREATED)),
+    onSubChannelDeleted(() => events.push(Amity.MarkerSyncEvent.SUBCHANNEL_IS_DELETED)),
+
+    // In real-world use, we've encountered some cases where BE returns empty result
+    // even if a marker changes in the database, causing the SDK to mistakenly believe that
+    // no changes have been made in the database and end the sync prematurely.
+    // Did miss update the unread count
+    //
+    // We found that some time BE loads were too high, causing the calculation
+    // marker not to finish within the sync time, so it returned an empty value.
+    //
+    // Therefore, solve this problem by creating a second interval loop that
+    // runs every 8 seconds regardless of whether an event occurs or not so that
+    // the unread count is always updated in case of an error like the above.
+    setIntervalTask(() => events.push(Amity.MarkerSyncEvent.FORCE_SYNC), FORCE_SYNC_INTERVAL_TIME),
+  );
+};
+
+const unRegisterEventListeners = () => {
+  disposers.forEach(fn => fn());
+  disposers = [];
+};
+
+/**
+ ```js
+ * import { startUnreadSync } from '@amityco/ts-sdk'
+ * startUnreadSync()
+ * ```
+ *
+ * start syncing to keep feed markers, channel markers and user makers cache
+ * update to the server.
+ *
+ * @category Marker API
+ */
+export const startUnreadSync = () => {
+  pushMarkerSyncEvent(Amity.MarkerSyncEvent.START_SYNCING);
+
+  if (!clearSyncTrigger) {
+    // it is possible to repeatedly call the API when multiple events occur at the same time.
+    // This is very burdensome to the BE Server, so we have an interval loop for
+    // grouping every event that occurs within 2 seconds into a single API call.
+    //
+    // interval loop is also useful for fetching large results. Because if the result
+    // is more than 20 records, the API will split the result into multiple pages
+    // and the SDK will need to fetch it repeatedly until all the results are available.
+    // So we need an interval loop for repeat fetch.
+    clearSyncTrigger = setIntervalTask(
+      () => markerSyncTrigger(markerSync),
+      SYNC_TRIGGER_INTERVAL_TIME,
+    );
+  }
+
+  registerEventListeners();
+};
+
+/**
+ ```js
+ * import { stopUnreadSyncing } from '@amityco/ts-sdk'
+ * stopUnreadSyncing()
+ * ```
+ *
+ * stop unread syncing
+ *
+ * @category Marker API
+ */
+export const stopUnreadSyncing = () => {
+  clearSyncTrigger?.();
+  clearSyncTrigger = undefined;
+  setMarkerSyncEvents([]);
+  unRegisterEventListeners();
+};

package/src/comment/api/getComments.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 /* begin_public_function
   id: comment.get_by_ids
@@ -28,10 +30,24 @@ export const getComments = async (
 
   const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId));
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.CommentPayload>(`/api/v3/comments/list`, {
-    params: { commentIds: encodedCommentIds },
-  });
+  let data: Amity.CommentPayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http.get<Amity.CommentPayload>(`/api/v3/comments/list`, {
+      params: { commentIds: encodedCommentIds },
+    });
+
+    data = response.data;
+  } catch (error) {
+    commentIds.forEach(commentId => {
+      if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+        pushToTombstone('comment', commentId);
+      }
+    });
+
+    throw error;
+  }
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/comment/api/tests/getComments.test.ts

@@ -1,5 +1,6 @@
 import { enableCache } from '~/cache/api';
-import { client, connectClient, disconnectClient, comment11, user11 } from '~/utils/tests';
+import { client, comment11, connectClient, disconnectClient, user11 } from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
 import { getComments } from '../getComments';
 
 const apiResponse = {
@@ -33,4 +34,14 @@ describe('getComments', () => {
 
     expect(comments?.data).toEqual(commentsListResponse.data);
   });
+
+  test('Should return Error: 400400 when getComments from invalid commentId', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getComments([comment11.commentId])).rejects.toThrow();
+  });
 });

package/src/comment/api/tests/queryComments.test.ts

@@ -1,5 +1,3 @@
-import { queryComments } from '../queryComments';
-
 import {
   client,
   connectClient,
@@ -18,6 +16,8 @@ import {
 } from '~/utils/tests';
 import { ASCApiError } from '~/core/errors';
 
+import { queryComments } from '../queryComments';
+
 type mockParamAndResponse = {
   query: Amity.QueryComments;
   response: Amity.Comment[];

package/src/core/model/idResolvers.ts

@@ -20,6 +20,13 @@ const idResolvers: Resolvers = {
   channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
   message: ({ messageId }) => messageId,
 
+  channelMarker: ({ entityId, userId }) => `${entityId}#${userId}`,
+  subChannelMarker: ({ entityId, feedId, userId }) => `${entityId}#${feedId}#${userId}`,
+  messageMarker: ({ feedId, contentId, creatorId }) => `${feedId}#${contentId}#${creatorId}`,
+  feedMarker: ({ feedId, entityId }) => `${feedId}#${entityId}`,
+
+  userMarker: ({ userId }) => userId,
+
   community: ({ communityId }) => communityId,
   category: ({ categoryId }) => categoryId,
   communityUsers: ({ communityId, userId }) => `${communityId}#${userId}`,

package/src/core/model/identifyModel.ts

@@ -6,7 +6,7 @@
  * @hidden
  */
 type Criterias<T extends Amity.Domain = Amity.Domain> = {
-  [K in T]: (keyof Amity.Models[K])[];
+  [K in T]?: (keyof Amity.Models[K])[];
 };
 
 /**

package/src/core/model/index.ts

@@ -15,6 +15,12 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   channelUsers: 'channelUsers',
   messages: 'message',
 
+  userEntityMarkers: 'channelMarker',
+  userFeedMarkers: 'subChannelMarker',
+  contentMarkers: 'messageMarker',
+  feedMarkers: 'feedMarker',
+  userMarkers: 'userMarker',
+
   communities: 'community',
   categories: 'category',
   communityUsers: 'communityUsers',

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

@@ -20,8 +20,10 @@ const post = { postId: posts.page1[0] };
 const deletingMsgId = 'deletingId';
 
 describe('Core/Query/runQuery', () => {
-  beforeEach(enableCache);
+  beforeAll(enableCache);
+  afterAll(disableCache);
 
+  beforeEach(enableCache);
   afterEach(disableCache);
 
   test('should call query with arguments', () => {

package/src/group/utils/withUser.ts

@@ -1,5 +1,5 @@
-import { pullFromCache } from '~/cache/api';
-import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getActiveClient } from '~/client/api/activeClient';
 
 /**
  * Attach user object to membership model

package/src/index.ts

@@ -10,6 +10,8 @@ export * from './cache/api';
 
 export * from './client/api';
 export * from './client/events';
+export * from './client/observers';
+export * from './client/utils';
 export { API_REGIONS } from './client/utils/endpoints';
 
 // asc core
@@ -37,11 +39,15 @@ export * from './channel/observers';
 export * from './subChannel/api';
 export * from './subChannel/events';
 export * from './subChannel/observers';
+export * from './subChannel/utils';
 
 export * from './message/api';
 export * from './message/events';
 export * from './message/observers';
 
+export * from './marker/api';
+export * from './marker/events';
+
 // // asc social
 export * from './community/api';
 export * from './community/events';

package/src/marker/api/getChannelMarkers.ts

@@ -0,0 +1,53 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getChannelMarker } from '@amityco/ts-sdk'
+ * const channelMarkers = await getChannelMarkers(['ch1', 'ch2'])
+ * ```
+ *
+ * Fetches a paginable list of {@link Amity.ChannelMarker} objects
+ *
+ * @param channelIds the IDs of the {@link Amity.RawChannel} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.ChannelMarker} objects
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+export const getChannelMarkers = async (
+  channelIds: Amity.Channel['channelId'][],
+  page: Amity.Page = { limit: 100 },
+): Promise<Amity.Cached<Amity.Paged<Amity.ChannelMarker>>> => {
+  const client = getActiveClient();
+  client.log('channel/getChannelMarkers', channelIds, page);
+
+  const { data: queryPayload } = await client.http.get<
+    Amity.ChannelMarkerPayload & Amity.Pagination
+  >(`/api/v1/markers/channels`, {
+    params: {
+      channelIds,
+      options: {
+        token: toToken(page, 'skiplimit'),
+      },
+    },
+  });
+
+  const { paging, ...payload } = queryPayload;
+  const { userEntityMarkers, userMarkers } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.ChannelMarkerPayload, { cachedAt });
+
+  userEntityMarkers.length && fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+  userMarkers.length && fireEvent('local.userMarker.fetched', { userMarkers });
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: userEntityMarkers, cachedAt, prevPage, nextPage };
+};