@amityco/ts-sdk 6.17.3 → 6.18.0

package/src/messageRepository/api/editMessage.ts

@@ -5,6 +5,7 @@ import { pullFromCache, upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 
 import { convertParams, prepareMessagePayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: message.edit.text_message, message.edit.custom_message
@@ -48,7 +49,7 @@ export const editMessage = async (
   fireEvent('local.message.updated', { messages });
 
   return {
-    data: messages.find(message => message.messageId === messageId)!,
+    data: LinkedObject.message(messages.find(message => message.messageId === messageId)!),
     cachedAt,
   };
 };
@@ -78,12 +79,12 @@ editMessage.optimistically = (
 
   if (!client.cache) return;
 
-  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+  const message = pullFromCache<Amity.InternalMessage>(['message', 'get', messageId]);
 
   if (!message) return;
 
   const cachedAt = -1;
-  const edited: Amity.Message = {
+  const edited: Amity.InternalMessage = {
     ...message.data,
     ...patch,
     updatedAt: new Date().toISOString(),
@@ -93,7 +94,7 @@ editMessage.optimistically = (
   fireEvent('local.message.updated', { messages: [edited] });
 
   return {
-    data: edited,
+    data: LinkedObject.message(edited),
     cachedAt,
   };
 };

package/src/messageRepository/api/getMessage.ts

@@ -9,6 +9,7 @@ import { checkIfShouldGoesToTombstone } from '~/cache/utils';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 import { prepareMessagePayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -64,7 +65,7 @@ export const getMessage = async (
   fireEvent('local.message.fetched', { messages });
 
   return {
-    data: messages.find(message => message.messageId === messageId)!,
+    data: LinkedObject.message(messages.find(message => message.messageId === messageId)!),
     cachedAt,
   };
 };

package/src/messageRepository/api/getMessages.ts

@@ -5,6 +5,7 @@ import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareMessagePayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -40,7 +41,7 @@ export const getMessages = async (
   fireEvent('local.message.fetched', { messages });
 
   return {
-    data: messages,
+    data: messages.map(message => LinkedObject.message(message)),
     cachedAt,
   };
 };

package/src/messageRepository/api/markAsDelivered.ts

@@ -1,10 +1,6 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import {
-  convertChannelMarkerResponse,
-  convertSubChannelMarkerResponse,
-  convertUserMarkerResponse,
-} from '~/utils/marker';
+import { convertChannelMarkerResponse, convertSubChannelMarkerResponse } from '~/utils/marker';
 
 /**
  * ```js
@@ -40,7 +36,7 @@ export const markAsDelivered = async (
   if (client.cache)
     ingestInCache(
       {
-        userMarkers: convertUserMarkerResponse(userMarkers),
+        userMarkers,
         userEntityMarkers: convertChannelMarkerResponse(userEntityMarkers),
         userFeedMarkers: convertSubChannelMarkerResponse(userFeedMarkers),
         ...rest,

package/src/messageRepository/api/queryMessages.ts

@@ -6,6 +6,7 @@ import { pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 import { convertQueryParams, prepareMessagePayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -73,6 +74,12 @@ export const queryMessages = async (
   const nextPage = toPageRaw(paging.next);
   const prevPage = toPageRaw(paging.previous);
 
-  return { data: messages, cachedAt, prevPage, nextPage, paging };
+  return {
+    data: messages.map(message => LinkedObject.message(message)),
+    cachedAt,
+    prevPage,
+    nextPage,
+    paging,
+  };
 };
 /* end_public_function */

package/src/messageRepository/api/softDeleteMessage.ts

@@ -2,7 +2,8 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache, upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 
-import { getMessage } from './getMessage';
+import { getMessage } from '../internalApi/getMessage';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: message.soft_delete
@@ -36,7 +37,7 @@ export const softDeleteMessage = async (
 
   fireEvent('local.message.deleted', { messages: [deleted.data] });
 
-  return deleted.data;
+  return LinkedObject.message(deleted.data);
 };
 
 /**
@@ -58,12 +59,12 @@ softDeleteMessage.optimistically = (
   const client = getActiveClient();
   client.log('message/softDeleteMessage.optimistically', messageId);
 
-  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+  const message = pullFromCache<Amity.InternalMessage>(['message', 'get', messageId]);
 
   if (!message) return;
 
   const cachedAt = -1;
-  const deleted: Amity.Message = {
+  const deleted: Amity.InternalMessage = {
     ...message.data,
     isDeleted: true,
     updatedAt: new Date().toISOString(),
@@ -73,7 +74,7 @@ softDeleteMessage.optimistically = (
   fireEvent('local.message.deleted', { messages: [deleted] });
 
   return {
-    data: deleted,
+    data: LinkedObject.message(deleted),
     cachedAt,
   };
 };

package/src/messageRepository/api/updateMessage.ts

@@ -5,6 +5,7 @@ import { pullFromCache, upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 
 import { convertParams, prepareMessagePayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: message.edit
@@ -52,7 +53,7 @@ export const updateMessage = async (
   fireEvent('local.message.updated', { messages });
 
   return {
-    data: messages.find(message => message.messageId === messageId)!,
+    data: LinkedObject.message(messages.find(message => message.messageId === messageId)!),
     cachedAt,
   };
 };
@@ -82,12 +83,12 @@ updateMessage.optimistically = (
 
   if (!client.cache) return;
 
-  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+  const message = pullFromCache<Amity.InternalMessage>(['message', 'get', messageId]);
 
   if (!message) return;
 
   const cachedAt = -1;
-  const updated: Amity.Message = {
+  const updated: Amity.InternalMessage = {
     ...message.data,
     ...patch,
     updatedAt: new Date().toISOString(),
@@ -97,7 +98,7 @@ updateMessage.optimistically = (
   fireEvent('local.message.updated', { messages: [updated] });
 
   return {
-    data: updated,
+    data: LinkedObject.message(updated),
     cachedAt,
   };
 };

package/src/messageRepository/events/onMessageCreated.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { prepareMessagePayload } from '../utils';
+import { updateSubChannelUnreadFromMessage } from '~/marker/utils/updateSubChannelUnreadFromMessage';
+import { reCalculateChannelUnreadInfo } from '~/marker/utils/reCalculateChannelUnreadInfo';
 
 /**
  * ```js
@@ -20,13 +22,21 @@ import { prepareMessagePayload } from '../utils';
  * @category Message Events
  */
 export const onMessageCreatedMqtt = (
-  callback: Amity.Listener<Amity.Message>,
+  callback: Amity.Listener<Amity.InternalMessage>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = async (rawPayload: Amity.MessagePayload) => {
     const payload = await prepareMessagePayload(rawPayload);
 
+    // update unreadCountInfo in cache
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+      rawPayload.messages.forEach(message => {
+        updateSubChannelUnreadFromMessage(message);
+        reCalculateChannelUnreadInfo(message.channelId);
+      });
+    }
+
     // Update in cache
     ingestInCache(payload);
 
@@ -45,7 +55,7 @@ export const onMessageCreatedMqtt = (
 };
 
 export const onMessageCreatedLocal = (
-  callback: Amity.Listener<Amity.Message>,
+  callback: Amity.Listener<Amity.InternalMessage>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 

package/src/messageRepository/events/onMessageDeleted.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
@@ -19,7 +19,9 @@ import { prepareMessagePayload } from '../utils';
  *
  * @category Message Events
  */
-export const onMessageDeleted = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+export const onMessageDeleted = (
+  callback: Amity.Listener<Amity.InternalMessage>,
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = async (rawPayload: Amity.MessagePayload) => {

package/src/messageRepository/events/onMessageFetched.ts

@@ -18,7 +18,9 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  *
  * @category Message Events
  */
-export const onMessageFetched = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+export const onMessageFetched = (
+  callback: Amity.Listener<Amity.InternalMessage>,
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.Events['local.message.fetched']) => {

package/src/messageRepository/events/onMessageFlagCleared.ts

@@ -19,7 +19,7 @@ import { prepareMessagePayload } from '../utils';
  * @category Message Events
  */
 export const onMessageFlagCleared = (
-  callback: Amity.Listener<Amity.Message>,
+  callback: Amity.Listener<Amity.InternalMessage>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 

package/src/messageRepository/events/onMessageFlagged.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
@@ -19,7 +19,9 @@ import { prepareMessagePayload } from '../utils';
  *
  * @category Message Events
  */
-export const onMessageFlagged = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+export const onMessageFlagged = (
+  callback: Amity.Listener<Amity.InternalMessage>,
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = async (rawPayload: Amity.MessagePayload) => {

package/src/messageRepository/events/onMessageReactionAdded.ts

@@ -20,7 +20,7 @@ import { prepareMessagePayload } from '../utils';
  * @category Post Events
  */
 export const onMessageReactionAdded = (
-  callback: Amity.Listener<Amity.Message>,
+  callback: Amity.Listener<Amity.InternalMessage>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 

package/src/messageRepository/events/onMessageReactionRemoved.ts

@@ -20,7 +20,7 @@ import { prepareMessagePayload } from '../utils';
  * @category Post Events
  */
 export const onMessageReactionRemoved = (
-  callback: Amity.Listener<Amity.Message>,
+  callback: Amity.Listener<Amity.InternalMessage>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 

package/src/messageRepository/events/onMessageUnflagged.ts

@@ -18,7 +18,9 @@ import { prepareMessagePayload } from '../utils';
  *
  * @category Message Events
  */
-export const onMessageUnflagged = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+export const onMessageUnflagged = (
+  callback: Amity.Listener<Amity.InternalMessage>,
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = async (rawPayload: Amity.MessagePayload) => {

package/src/messageRepository/events/onMessageUpdated.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
@@ -20,7 +20,9 @@ import { prepareMessagePayload } from '../utils';
  *
  * @category Message Events
  */
-export const onMessageUpdated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+export const onMessageUpdated = (
+  callback: Amity.Listener<Amity.InternalMessage>,
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = async (rawPayload: Amity.MessagePayload) => {

package/src/messageRepository/events/tests/events.test.ts

@@ -16,7 +16,10 @@ describe('Message Events', () => {
   const message = convertFromRaw(rawMessage);
 
   const cases: Array<
-    [(callback: Amity.Listener<Amity.Message>) => Amity.Unsubscriber, keyof Amity.MqttMessageEvents]
+    [
+      (callback: Amity.Listener<Amity.InternalMessage>) => Amity.Unsubscriber,
+      keyof Amity.MqttMessageEvents,
+    ]
   > = [
     [onMessageCreatedMqtt, 'message.created'],
     [onMessageUpdated, 'message.updated'],

package/src/messageRepository/internalApi/getMessage.ts

@@ -0,0 +1,101 @@
+import { getActiveClient } from '~/client/api';
+
+import { fireEvent } from '~/core/events';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk'
+ * const message = await getMessage('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.InternalMessage} object
+ *
+ * @param messageId the ID of the {@link Amity.Message} to fetch
+ * @returns the associated {@link Amity.Message} object
+ *
+ * @category Message API
+ * @async
+ */
+export const getMessage = async (
+  messageId: Amity.Message['messageId'],
+  isLive = false,
+): Promise<Amity.Cached<Amity.InternalMessage>> => {
+  const client = getActiveClient();
+  client.log('message/getMessage', messageId);
+
+  if (!isLive) {
+    console.log(
+      'getMessage will be deprecated on 15th November 2022, please use liveMessage instead.',
+    );
+  }
+
+  isInTombstone('message', messageId);
+
+  let data: Amity.ProcessedMessagePayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data: payload } = await client.http.get<Amity.MessagePayload>(
+      `/api/v5/messages/${encodeURIComponent(messageId)}`,
+    );
+
+    data = await prepareMessagePayload(payload);
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('message', messageId);
+    }
+
+    throw error;
+  }
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { messages } = data;
+
+  fireEvent('local.message.fetched', { messages });
+
+  return {
+    data: messages.find(message => message.messageId === messageId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk'
+ * const message = getMessage.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Message} object
+ *
+ * @param messageId the ID of the {@link Amity.Message} to fetch
+ * @returns the associated {@link Amity.Message} object
+ *
+ * @category Message API
+ */
+getMessage.locally = (
+  messageId: Amity.Message['messageId'],
+): Amity.Cached<Amity.InternalMessage> | undefined => {
+  const client = getActiveClient();
+  client.log('message/getMessage.locally', messageId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.InternalMessage>(['message', 'get', messageId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/messageRepository/internalApi/getMessages.ts

@@ -0,0 +1,82 @@
+import { getActiveClient } from '~/client/api';
+
+import { fireEvent } from '~/core/events';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { getMessages } from '@amityco/ts-sdk'
+ * const messages = await getMessages(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Message} objects
+ *
+ * @param messageIds the IDs of the {@link Amity.Message} to fetch
+ * @returns the associated collection of {@link Amity.Message} objects
+ *
+ * @category Message API
+ * @async
+ */
+export const getMessages = async (
+  messageIds: Amity.Message['messageId'][],
+): Promise<Amity.Cached<Amity.InternalMessage[]>> => {
+  const client = getActiveClient();
+  client.log('message/getMessages', messageIds);
+
+  const { data: payload } = await client.http.get<Amity.MessagePayload>(`/api/v5/messages/list`, {
+    params: { messageIds: messageIds.map(encodeURIComponent) },
+  });
+
+  const data = await prepareMessagePayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { messages } = data;
+
+  fireEvent('local.message.fetched', { messages });
+
+  return {
+    data: messages,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getMessages } from '@amityco/ts-sdk'
+ * const messages = getMessages.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Message} objects from cache
+ *
+ * @param messageIds the IDs of the {@link Amity.Message} to fetch
+ * @returns the associated collection of {@link Amity.Message} objects
+ *
+ * @category Message API
+ */
+getMessages.locally = (
+  messageIds: Amity.Message['messageId'][],
+): Amity.Cached<Amity.InternalMessage[]> | undefined => {
+  const client = getActiveClient();
+  client.log('message/getMessages.locally', messageIds);
+
+  if (!client.cache) return;
+
+  const cached = messageIds
+    .map(messageId => pullFromCache<Amity.InternalMessage>(['message', 'get', messageId])!)
+    .filter(Boolean);
+
+  const messages = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  if (cached?.length < messageIds.length) return;
+
+  return {
+    data: messages,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/messageRepository/observers/getMessage.ts

@@ -1,7 +1,7 @@
 import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
 import { convertEventPayload } from '~/utils/event';
 import { liveObject } from '~/utils/liveObject';
-import { getMessage as _getMessage } from '../api/getMessage';
+import { getMessage as _getMessage } from '../internalApi/getMessage';
 import {
   onMessageUpdated,
   onMessageDeleted,
@@ -12,6 +12,8 @@ import {
   onMessageReactionRemoved,
 } from '../events';
 import { onMessageFetched } from '../events/onMessageFetched';
+import { LinkedObject } from '~/utils/linkedObject';
+import { date } from '~/utils/tests';
 
 /* begin_public_function
   id: message.get
@@ -39,7 +41,13 @@ export const getMessage = (
   messageId: Amity.Message['messageId'],
   callback: Amity.LiveObjectCallback<Amity.Message>,
 ): Amity.Unsubscriber => {
-  return liveObject(messageId, callback, 'messageId', _getMessage, [
+  const responder: Amity.LiveObjectCallback<Amity.InternalMessage> = (
+    snapshot: Amity.LiveObject<Amity.InternalMessage>,
+  ) => {
+    const { data } = snapshot;
+    callback({ ...snapshot, data: data ? LinkedObject.message(snapshot.data) : data });
+  };
+  return liveObject(messageId, responder, 'messageId', _getMessage, [
     onMessageFetched,
     onMessageUpdated,
     onMessageDeleted,

package/src/messageRepository/observers/getMessages/MessageLiveCollectionController.ts

@@ -17,6 +17,7 @@ import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionCo
 import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
 import { filterByPropEquality } from '~/core/query';
 import { prepareMessagePayload } from '~/messageRepository/utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 export class MessageLiveCollectionController extends LiveCollectionController<
   'message',
@@ -97,9 +98,10 @@ export class MessageLiveCollectionController extends LiveCollectionController<
 
     const data = this.applyFilter(
       collection.data
-        .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
+        .map(messageId => pullFromCache<Amity.InternalMessage>(['message', 'get', messageId])!)
         .filter(Boolean)
-        .map(({ data }) => data) ?? [],
+        .map(({ data }) => data)
+        .map(message => LinkedObject.message(message)) ?? [],
     );
 
     if (!this.shouldNotify(data) && origin === 'event') return;

package/src/messageRepository/observers/getMessages/MessageQueryStreamController.ts

@@ -69,7 +69,7 @@ export class MessageQueryStreamController extends QueryStreamController<
   }
 
   reactor(action: string) {
-    return (payload: Amity.Message) => {
+    return (payload: Amity.InternalMessage) => {
       if (action === 'onCreate') {
         const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
 
@@ -131,7 +131,7 @@ export class MessageQueryStreamController extends QueryStreamController<
 
   subscribeRTE(
     createSubscriber: {
-      fn: (reactor: Amity.Listener<Amity.Message>) => Amity.Unsubscriber;
+      fn: (reactor: Amity.Listener<Amity.InternalMessage>) => Amity.Unsubscriber;
       action: string;
     }[],
   ) {

package/src/messageRepository/observers/observeMessage.ts

@@ -7,6 +7,7 @@ import { convertEventPayload } from '~/utils/event';
 import { getMessage } from '../api/getMessage';
 
 import { onMessageUpdated, onMessageDeleted } from '../events';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -56,18 +57,26 @@ export const observeMessage = <Events extends ['onFetch', 'onUpdate', 'onDelete'
   const disposers: Amity.Unsubscriber[] = [];
 
   disposers.push(
-    onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
-    onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onMessageUpdated(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onUpdate'),
+    ),
+    onMessageDeleted(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onDelete'),
+    ),
     convertEventPayload(
       onMessageMarkerFetched,
       'contentId',
       'message',
-    )(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    )(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onUpdate'),
+    ),
     convertEventPayload(
       onMessageMarked,
       'contentId',
       'message',
-    )(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    )(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onUpdate'),
+    ),
   );
 
   if (policy !== 'no_fetch') {