@amityco/ts-sdk 6.17.3 → 6.18.0

package/src/client/observers/getUserUnread.ts

@@ -9,6 +9,9 @@ import {
   UNSYNCED_OBJECT_CACHED_AT_VALUE,
 } from '~/utils/constants';
 
+import { isEqual } from '~/utils/isEqual';
+import { convertGetterPropsToStatic } from '~/utils/object';
+
 /**
  *
  * ```js
@@ -27,7 +30,7 @@ import {
  * @category Message Live Object
  */
 export const getUserUnread = (
-  callback: Amity.LiveObjectCallback<Amity.UserUnread>,
+  callback: Amity.LiveObjectCallback<Amity.UserUnread | undefined>,
 ): Amity.Unsubscriber => {
   const { _id: userId } = getActiveUser();
 
@@ -51,14 +54,25 @@ export const getUserUnread = (
 
   let isUnsyncedModel = false; // for messages
 
-  const dispatcher = (data: Amity.LiveObject<Amity.UserMarker>) => {
-    const userUnread = data.data;
+  let model: Omit<Amity.UserUnread, 'hasMentioned'> | undefined;
+
+  const dispatcher = (data: Amity.LiveObject<Amity.UserMarker | undefined>) => {
+    const { data: userUnread } = data;
+
+    const callbackModel = userUnread
+      ? {
+          unreadCount: userUnread.unreadCount,
+          isMentioned: userUnread.isMentioned,
+        }
+      : undefined;
+
+    model = callbackModel ? convertGetterPropsToStatic(callbackModel) : callbackModel;
 
     callback({
-      data: {
-        hasMentioned: userUnread.hasMentioned,
-        unreadCount: userUnread.unreadCount,
-      },
+      data: callbackModel
+        ? { ...callbackModel, hasMentioned: callbackModel.isMentioned }
+        : callbackModel,
+
       loading: data.loading,
       error: data.error,
     });
@@ -78,25 +92,36 @@ export const getUserUnread = (
       return currentMaxUserMarker;
     }, null as Amity.UserMarker | null);
 
+    const eventModel = {
+      unreadCount: latestUserMarker?.unreadCount ?? 0,
+      isMentioned: filterUserMarkers.some(userMarker => !!userMarker.isMentioned),
+    } as Amity.UserMarker;
+
+    if (isEqual(model, eventModel)) return;
+
     dispatcher({
       loading: false,
-      data: {
-        unreadCount: latestUserMarker?.unreadCount ?? 0,
-        hasMentioned: filterUserMarkers.some(userMarker => !!userMarker.hasMentioned),
-      } as Amity.UserMarker,
+      data: eventModel,
     });
   };
 
   function isAmityUserMarkerData(data: unknown): data is Amity.UserMarker {
+    /**
+     * The `data` return from runQuery is Amity.UserMarker | undefined.
+     * It's not located inside data field
+     */
     if (data == null) return false;
-    return (data as { data: Amity.UserMarker })?.data != null;
+    return (data as { data: Amity.UserMarker }) != null;
   }
 
   const onFetch = () => {
     const query = createQuery(getUserMarker);
 
     runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
-      if (!isAmityUserMarkerData(data)) return;
+      if (!isAmityUserMarkerData(data)) {
+        dispatcher({ loading, data: undefined, origin, error });
+        return;
+      }
       if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
         dispatcher({
           data,

package/src/client/utils/ReadReceiptSync/readReceiptSyncEngine.ts

@@ -0,0 +1,259 @@
+import { pullFromCache, pushToCache, queryCache } from '~/cache/api';
+import { getActiveClient } from '../../api/activeClient';
+import { markAsReadBySegment } from '~/subChannelRepository/api/markAsReadBySegment';
+import { reCalculateChannelUnreadInfo } from '~/marker/utils/reCalculateChannelUnreadInfo';
+
+export class MessageReadReceiptSyncEngine {
+  private client: Amity.Client;
+
+  private isActive = true;
+
+  private MAX_RETRY = 3;
+
+  private JOB_QUEUE_SIZE = 120;
+
+  private jobQueue: Amity.ReadReceiptSyncJob[] = [];
+
+  private timer: NodeJS.Timer | undefined;
+
+  // Interval for message read receipt sync in seconds
+  private RECEIPT_SYNC_INTERVAL = 1;
+
+  constructor() {
+    this.client = getActiveClient();
+    // Get remaining unsync read receipts from cache
+    this.getUnsyncJobs();
+  }
+
+  //  Call this when client call client.login
+  startSyncReadReceipt() {
+    // Start timer when start receipt sync
+    this.timer = setInterval(() => {
+      this.syncReadReceipts();
+    }, this.RECEIPT_SYNC_INTERVAL * 1000);
+  }
+
+  // Read receipt observer handling
+  syncReadReceipts(): void {
+    if (this.jobQueue.length === 0 || this.isActive === false) return;
+
+    const readReceipt = this.getReadReceipt();
+    if (readReceipt) {
+      this.markReadApi(readReceipt);
+    }
+  }
+
+  private getUnsyncJobs(): void {
+    // Get all read receipts that has latestSyncSegment < latestSegment
+    const readReceipts = queryCache<Amity.ReadReceipt>(['readReceipt'])?.filter(({ data }) => {
+      return data.latestSyncSegment < data.latestSegment;
+    });
+
+    // Enqueue unsync read receipts to the job queue
+    readReceipts?.forEach(({ data: readReceipt }) => {
+      this.enqueueReadReceipt(readReceipt.subChannelId, readReceipt.latestSegment);
+    });
+  }
+
+  private getReadReceipt(): Amity.ReadReceiptSyncJob | undefined {
+    // Get first read receipt in queue
+    const syncJob = this.jobQueue[0];
+
+    if (!syncJob) return;
+    // Skip when it's syncing
+    if (syncJob.syncState === Amity.ReadReceiptSyncState.SYNCING) return;
+
+    // Get readReceipt from cache by subChannelId
+    const readReceipt = pullFromCache<Amity.ReadReceipt>([
+      'readReceipt',
+      syncJob.subChannelId,
+    ])?.data;
+
+    if (!readReceipt) return;
+
+    if (readReceipt?.latestSegment > readReceipt?.latestSyncSegment) {
+      syncJob.segment = readReceipt.latestSegment;
+      return syncJob;
+    }
+    // Clear all synced job in job queue
+    this.removeSynedReceipt(readReceipt.subChannelId, readReceipt.latestSegment);
+
+    // Recursion getReadReceipt() until get unsync read receipt or job queue is empty
+    return this.getReadReceipt();
+  }
+
+  private async markReadApi(syncJob: Amity.ReadReceiptSyncJob): Promise<void> {
+    const newSyncJob = syncJob;
+    newSyncJob.syncState = Amity.ReadReceiptSyncState.SYNCING;
+
+    const { subChannelId, segment } = newSyncJob;
+
+    const response = await markAsReadBySegment({ subChannelId, readToSegment: segment });
+
+    if (response) {
+      this.removeSynedReceipt(syncJob.subChannelId, syncJob.segment);
+
+      const readReceiptCache = pullFromCache<Amity.ReadReceipt>([
+        'readReceipt',
+        subChannelId,
+      ])?.data;
+
+      pushToCache(['readReceipt', subChannelId], {
+        ...readReceiptCache,
+        latestSyncSegment: segment,
+      });
+    } else if (!response) {
+      if (newSyncJob.retryCount > this.MAX_RETRY) {
+        this.removeJobFromQueue(newSyncJob);
+      } else {
+        newSyncJob.retryCount += 1;
+        newSyncJob.syncState = Amity.ReadReceiptSyncState.CREATED;
+      }
+    }
+  }
+
+  private removeSynedReceipt(subChannelId: string, segment: number) {
+    const syncJobs = this.jobQueue;
+
+    syncJobs.forEach(job => {
+      if (job.subChannelId === subChannelId && job.segment <= segment) {
+        this.removeJobFromQueue(job);
+      }
+    });
+  }
+
+  private startObservingReadReceiptQueue(): void {
+    if (this.client.isUnreadCountEnabled) {
+      this.isActive = true;
+      this.startSyncReadReceipt();
+    }
+  }
+
+  private stopObservingReadReceiptQueue(): void {
+    this.isActive = false;
+
+    const syncJobs = this.jobQueue;
+    syncJobs.map(job => {
+      if (job.syncState === Amity.ReadReceiptSyncState.SYNCING) {
+        return { ...job, syncState: Amity.ReadReceiptSyncState.CREATED };
+      }
+
+      return job;
+    });
+
+    if (this.timer) clearInterval(this.timer);
+  }
+
+  // Session Management
+  onSessionEstablished(): void {
+    this.startObservingReadReceiptQueue();
+  }
+
+  onSessionDestroyed(): void {
+    this.stopObservingReadReceiptQueue();
+    this.jobQueue = [];
+  }
+
+  onTokenExpired(): void {
+    this.stopObservingReadReceiptQueue();
+  }
+
+  // Network Connection Management
+  onNetworkOffline(): void {
+    // Stop observing to the read receipt queue.
+    this.stopObservingReadReceiptQueue();
+  }
+
+  onNetworkOnline(): void {
+    // Resume observing to the read receipt queue.
+    this.startObservingReadReceiptQueue();
+  }
+
+  markRead(subChannelId: string, segment: number): void {
+    // Step 1: Optimistic update of subChannelUnreadInfo.readToSegment to message.segment
+    const cacheKey = ['subChannelUnreadInfo', 'get', subChannelId];
+    const subChannelUnreadInfo = pullFromCache<Amity.SubChannelUnreadInfo>(cacheKey)?.data;
+
+    if (subChannelUnreadInfo && segment > subChannelUnreadInfo.readToSegment) {
+      subChannelUnreadInfo.readToSegment = segment;
+      subChannelUnreadInfo.unreadCount = Math.max(subChannelUnreadInfo.lastSegment - segment, 0);
+
+      reCalculateChannelUnreadInfo(subChannelUnreadInfo.channelId);
+    }
+
+    pushToCache(cacheKey, subChannelUnreadInfo);
+
+    // Step 2: Enqueue the read receipt
+    this.enqueueReadReceipt(subChannelId, segment);
+  }
+
+  private enqueueReadReceipt(subChannelId: string, segment: number): void {
+    const readReceipt = pullFromCache<Amity.ReadReceipt>(['readReceipt', subChannelId])?.data;
+
+    // Create new read receipt if it's not exists and add job to queue
+    if (!readReceipt) {
+      const readReceiptSubChannel: Amity.ReadReceipt = {
+        subChannelId,
+        latestSegment: segment,
+        latestSyncSegment: 0,
+      };
+
+      pushToCache(['readReceipt', subChannelId], readReceiptSubChannel);
+    } else if (readReceipt.latestSegment < segment) {
+      pushToCache(['readReceipt', subChannelId], { ...readReceipt, latestSegment: segment });
+    } else if (readReceipt.latestSyncSegment >= segment) {
+      // Skip the job when lastSyncSegment > = segment
+      return;
+    }
+
+    let syncJob: Amity.ReadReceiptSyncJob | null = this.getSyncJob(subChannelId);
+
+    if (syncJob === null || syncJob.syncState === Amity.ReadReceiptSyncState.SYNCING) {
+      syncJob = {
+        subChannelId,
+        segment,
+        syncState: Amity.ReadReceiptSyncState.CREATED,
+        retryCount: 0,
+      };
+
+      this.enqueueJob(syncJob);
+    } else if (syncJob.segment < segment) {
+      syncJob.segment = segment;
+    }
+  }
+
+  private getSyncJob(subChannelId: string): Amity.ReadReceiptSyncJob | null {
+    const syncJobs = this.jobQueue;
+
+    const targetJob = syncJobs.find(job => job.subChannelId === subChannelId);
+
+    return targetJob || null;
+  }
+
+  private enqueueJob(syncJob: Amity.ReadReceiptSyncJob) {
+    if (this.jobQueue.length < this.JOB_QUEUE_SIZE) {
+      this.jobQueue.push(syncJob);
+    } else {
+      // Remove oldest job when queue reach maximum capacity
+      this.jobQueue.shift();
+      this.jobQueue.push(syncJob);
+    }
+  }
+
+  private removeJobFromQueue(item: Amity.ReadReceiptSyncJob) {
+    const index = this.jobQueue.indexOf(item);
+    if (index > -1) {
+      this.jobQueue.splice(index, 1);
+    }
+  }
+}
+
+let instance: MessageReadReceiptSyncEngine | null = null;
+
+export default {
+  getInstance: () => {
+    if (!instance) instance = new MessageReadReceiptSyncEngine();
+
+    return instance;
+  },
+};

package/src/client/utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler.ts

@@ -0,0 +1,21 @@
+import { onSessionStateChange } from '~/client/events/onSessionStateChange';
+import ReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/readReceiptSyncEngine';
+
+export default () => {
+  const readReceiptSyncEngine = ReadReceiptSyncEngine.getInstance();
+  readReceiptSyncEngine.startSyncReadReceipt();
+
+  onSessionStateChange(state => {
+    if (state === Amity.SessionStates.ESTABLISHED) {
+      readReceiptSyncEngine.onSessionEstablished();
+    } else if (state === Amity.SessionStates.TOKEN_EXPIRED) {
+      readReceiptSyncEngine.onTokenExpired();
+    } else {
+      readReceiptSyncEngine.onSessionDestroyed();
+    }
+  });
+
+  return () => {
+    readReceiptSyncEngine.onSessionDestroyed();
+  };
+};

package/src/client/utils/markerSyncEngine.ts

@@ -6,14 +6,18 @@ import {
 } from '~/channelRepository/events';
 import { onUserMarkerSync } from '~/marker/events/onUserMarkerSync';
 import { setIntervalTask } from '~/utils/timer';
-import { getUserMarker } from '~/marker/api';
-import { onFeedMarkerUpdated } from '~/marker/events';
-import { onMessageCreatedMqtt } from '~/messageRepository/events';
-import { onSubChannelCreated, onSubChannelDeleted } from '~/subChannelRepository/events';
+import { getUserMarker } from '~/marker/api/getUserMarker';
+import { onFeedMarkerUpdated } from '~/marker/events/onFeedlMarkerUpdated';
+import { onMessageCreatedMqtt } from '~/messageRepository/events/onMessageCreated';
+import { onSubChannelCreated } from '~/subChannelRepository/events/onSubChannelCreated';
+import { onSubChannelDeleted } from '~/subChannelRepository/events/onSubChannelDeleted';
 import { isUnreadCountSupport } from '~/subChannelRepository/utils';
 
-import { markerSync } from '../api';
+import { markerSync } from '../api/markerSync';
+import { enableUnreadCount } from '../api/enableUnreadCount';
+
 import { onOnline } from './onOnline';
+import { onUserFeedMarkerUpdated } from '~/marker/events/onUserFeedMarkerUpdated';
 
 const SYNC_TRIGGER_INTERVAL_TIME = 2000;
 const ON_SUB_CHANNEL_DELETE_SYNC_TRIGGER_DELAY = 2000;
@@ -22,6 +26,7 @@ let isSyncRunning = false;
 let disposers: (() => void)[] = [];
 let isWaitingForResponse = false;
 
+let isConsistentMode = true;
 let deviceLastSyncAt: Date | null = null;
 
 const getDeviceLastSyncAt = () => {
@@ -161,6 +166,7 @@ const registerEventListeners = () => {
     ),
     onFeedMarkerUpdated(() => events.push(Amity.MarkerSyncEvent.MARKER_UPDATED)),
     onUserMarkerSync(() => events.push(Amity.MarkerSyncEvent.MARKER_UPDATED)),
+    onUserFeedMarkerUpdated(() => events.push(Amity.MarkerSyncEvent.MARKER_UPDATED)),
   );
 };
 
@@ -169,6 +175,18 @@ const unRegisterEventListeners = () => {
   disposers = [];
 };
 
+export const startMarkerSync = async () => {
+  await fetchDeviceLastSyncAt();
+  pushMarkerSyncEvent(Amity.MarkerSyncEvent.START_SYNCING);
+
+  isConsistentMode = true;
+  isSyncRunning = true;
+
+  registerEventListeners();
+
+  return unRegisterEventListeners;
+};
+
 /**
  ```js
  * import { startUnreadSync } from '@amityco/ts-sdk'
@@ -183,7 +201,12 @@ const unRegisterEventListeners = () => {
 export const startUnreadSync = async () => {
   await fetchDeviceLastSyncAt();
   pushMarkerSyncEvent(Amity.MarkerSyncEvent.START_SYNCING);
+
+  enableUnreadCount();
+
+  isConsistentMode = false;
   isSyncRunning = true;
+
   registerEventListeners();
 };
 
@@ -217,3 +240,5 @@ setIntervalTask(async () => {
 
   await markerSyncTrigger();
 }, SYNC_TRIGGER_INTERVAL_TIME);
+
+export const getMarkerSyncConsistentMode = () => isConsistentMode;

package/src/client/utils/setClientToken.ts

@@ -19,8 +19,6 @@ export const setClientToken = async (params: Parameters<typeof getToken>[0]) =>
   // begin establishing session
   setSessionState(Amity.SessionStates.ESTABLISHING);
 
-  // @ts-ignore: in that particular case, typing can be
-  // ignored since we enforce default values just before.
   const { accessToken, users, expiresAt, issuedAt, refreshToken } = await getToken(params);
 
   // manually setup the token for http transport

package/src/client/utils/subscribeGlobalTopic.ts

@@ -1,5 +1,6 @@
 import { getActiveUser } from '~/client/api/activeUser';
 import {
+  getMarkerUserFeedTopic,
   getNetworkTopic,
   getSmartFeedChannelTopic,
   getSmartFeedMessageTopic,
@@ -17,6 +18,7 @@ export const subscribeGlobalTopic = () => {
 
     // subscribing to user topic is necessary to handle ban event
     subscribeTopic(getUserTopic(getActiveUser())),
+    subscribeTopic(getMarkerUserFeedTopic()),
   ];
 
   return () => disposers.forEach(fn => fn());

package/src/commentRepository/api/deleteComment.ts

@@ -7,6 +7,7 @@ import { getPost } from '~/postRepository/api/getPost';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
 import { scheduleTask } from '~/core/microtasks';
 
+import { getStoryByStoryId } from '~/storyRepository/internalApi/getStoryByStoryId';
 import { getComment } from './getComment';
 
 /* begin_public_function
@@ -48,20 +49,36 @@ export const deleteComment = async (
   // to support hard deletion
   const deleted = { ...comment.data, isDeleted: true };
 
-  const post = await getPost(comment.data.referenceId);
+  if (comment.data.referenceType === 'story') {
+    const story = await getStoryByStoryId(comment.data.referenceId);
 
-  fireEvent('post.updated', {
-    posts: [post.data],
-    categories: [],
-    comments: [],
-    communities: [],
-    communityUsers: [],
-    feeds: [],
-    files: [],
-    postChildren: [],
-    users: [],
-  });
+    fireEvent('local.story.updated', {
+      stories: [story.data],
+      categories: [],
+      comments: [],
+      communities: [],
+      communityUsers: [],
+      files: [],
+      users: [],
+    });
+  } else {
+    const post = await getPost(comment.data.referenceId);
+
+    // @TODO: Need to separate Local / MQTT later
+    fireEvent('post.updated', {
+      posts: [post.data],
+      categories: [],
+      comments: [],
+      communities: [],
+      communityUsers: [],
+      feeds: [],
+      files: [],
+      postChildren: [],
+      users: [],
+    });
+  }
 
+  // @TODO: Need to separate Local / MQTT later
   fireEvent('comment.deleted', {
     comments: [deleted],
     commentChildren: [],

package/src/commentRepository/api/queryComments.ts

@@ -4,6 +4,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
 import { inferIsDeleted } from '~/utils/inferIsDeleted';
+import { convertToInternalComment } from '../utils/convertToInternalComment';
 
 /**
  * ```js
@@ -52,12 +53,13 @@ export const queryComments = async (
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, comments } = unwrapPayload(data)
   const { paging, ...payload } = data;
-  const { comments } = payload;
+  const processedData = convertToInternalComment(payload);
+  const { comments } = processedData;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.CommentPayload, { cachedAt });
+    ingestInCache(processedData as Amity.CommentPayload, { cachedAt });
 
     const cacheKey = ['comment', 'query', { ...params, options: { limit } } as Amity.Serializable];
 

package/src/commentRepository/events/utils.ts

@@ -44,8 +44,7 @@ export const createCommentEventSubscriber = (
           }
 
           const queries = queryCache<Amity.InternalComment[]>(['comment', 'query'])?.filter(
-            ({ key }) =>
-              (key[2] as Amity.QueryComments)?.referenceId === comment.data.referenceId,
+            ({ key }) => (key[2] as Amity.QueryComments)?.referenceId === comment.data.referenceId,
           );
 
           queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));

package/src/commentRepository/internalApi/queryComments.ts

@@ -2,8 +2,8 @@ import { getActiveClient } from '~/client/api';
 import { pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
-
 import { inferIsDeleted } from '~/utils/inferIsDeleted';
+import { convertToInternalComment } from '../utils/convertToInternalComment';
 
 export const queryComments = async (
   query: Amity.QueryComments,
@@ -38,12 +38,13 @@ export const queryComments = async (
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, comments } = unwrapPayload(data)
   const { paging, ...payload } = data;
-  const { comments } = payload;
+  const processedData = convertToInternalComment(payload);
+  const { comments } = processedData;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.CommentPayload, { cachedAt });
+    ingestInCache(processedData as Amity.CommentPayload, { cachedAt });
 
     const cacheKey = ['comment', 'query', { ...params, options: { limit } } as Amity.Serializable];
     pushToCache(cacheKey, { comments: comments.map(getResolver('comment')), paging });

package/src/commentRepository/utils/convertToInternalComment.ts

@@ -0,0 +1,17 @@
+export const convertToInternalComment = (commentPayload: Amity.CommentPayload) => {
+  const { comments } = commentPayload;
+
+  return {
+    ...commentPayload,
+    comments: comments.map(comment => {
+      if (comment.hasOwnProperty('myReactions')) return comment;
+
+      // Sometimes `myReactions` field will not come with BE response because that field is empty
+      // We need to put it with an empty array manually to make it show up in client side
+      return {
+        myReactions: [],
+        ...comment,
+      };
+    }),
+  };
+};

package/src/core/model/idResolvers.ts

@@ -23,6 +23,9 @@ const idResolvers: Resolvers = {
   messagePreviewChannel: ({ channelId }) => `${channelId}`,
   messagePreviewSubChannel: ({ subChannelId }) => `${subChannelId}`,
 
+  channelUnreadInfo: ({ channelId }) => channelId,
+  subChannelUnreadInfo: ({ subChannelId }) => subChannelId,
+
   channelMarker: ({ entityId, userId }) => `${entityId}#${userId}`,
   subChannelMarker: ({ entityId, feedId, userId }) => `${entityId}#${feedId}#${userId}`,
   messageMarker: ({ feedId, contentId, creatorId }) => `${feedId}#${contentId}#${creatorId}`,

package/src/core/model/index.ts

@@ -20,6 +20,9 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   messagePreviewChannel: 'messagePreviewChannel',
   messagePreviewSubChannel: 'messagePreviewSubChannel',
 
+  channelUnreadInfo: 'channelUnreadInfo',
+  subChannelUnreadInfo: 'subChannelUnreadInfo',
+
   userEntityMarkers: 'channelMarker',
   userFeedMarkers: 'subChannelMarker',
   contentMarkers: 'messageMarker',

package/src/core/query/sorting.ts

@@ -45,6 +45,14 @@ export const sortByFirstCreated: SortingFunc<{ createdAt: Date | number | string
   { createdAt: b },
 ) => new Date(a).valueOf() - new Date(b).valueOf();
 
+/**
+ * Sorting a story-collection by its localSortingDate
+ */
+export const sortByLocalSortingDate: SortingFunc<{
+  localSortingDate: Date | number | string;
+}> = ({ localSortingDate: a }, { localSortingDate: b }) =>
+  new Date(b).getTime() - new Date(a).getTime();
+
 /**
  * Sorting a collection by its newest items
  */

package/src/core/subscription.ts

@@ -106,6 +106,12 @@ export const getMarkedMessageTopic = ({
   return `${getNetworkId(user)}/marker/channel/${channelId}/message/${subChannelId}`;
 };
 
+export const getMarkerUserFeedTopic = () => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/marker/user/${user._id}`;
+};
+
 /**
  * @hidden
  *