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

package/src/message/api/queryMessages.ts

@@ -5,7 +5,7 @@ import { toPageRaw } from '~/core/query';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
-import { convertQueryParams, convertResponseFromRaw } from '../utils';
+import { convertQueryParams, prepareMessagePayload } from '../utils';
 
 /* begin_public_function
   id: message.query
@@ -36,19 +36,21 @@ export const queryMessages = async (
   // API-FIX: backend should answer Amity.Response (2)
   // API-FIX: pagination should not be indexed on channelSegment (3)
   // const { data } = await client.http.get<Amity.Response<Amity.Paged<Amity.MessagePayload>>>(
-  const response = await client.http
-    .get<Amity.MessagePayload & Amity.Pagination>(`/api/v5/messages`, { params })
-    .then(convertResponseFromRaw);
+  const { data: queryPayload } = await client.http.get<Amity.MessagePayload & Amity.Pagination>(
+    `/api/v5/messages`,
+    { params },
+  );
 
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, messages } = unwrapPayload(data)
-  const { paging, ...data } = response.data;
+  const { paging, ...payload } = queryPayload;
+  const data = await prepareMessagePayload(payload);
   const { messages } = data;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(data as Amity.ProcessedMessagePayload, { cachedAt });
+    ingestInCache(data, { cachedAt });
 
     const cacheKey = ['message', 'query', params as Amity.Serializable];
     pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });

package/src/message/api/tests/createMessage.test.ts

@@ -2,18 +2,28 @@ import { ASCApiError } from '~/core/errors';
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 
-import { client, generateRawMessage, pause } from '~/utils/tests';
-
+import { client, convertRawMessage, generateRawMessage, pause } from '~/utils/tests';
 import { createQuery, runQuery } from '~/core/query';
+
 import { convertFromRaw } from '../../utils';
 import { onMessageCreated } from '../../events';
 import { createMessage } from '../createMessage';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
 
 const rawMessageToCreate = generateRawMessage();
-const messageToCreate = convertFromRaw(rawMessageToCreate);
+const messageToCreate = convertRawMessage(rawMessageToCreate);
 const { messageId, uniqueId, ...messageWithoutId } = messageToCreate;
 
 describe('createMessage', () => {
+  beforeAll(() => {
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
   const bundle = {
     data: messageToCreate.data,
     dataType: messageToCreate.dataType,
@@ -26,7 +36,6 @@ describe('createMessage', () => {
   };
 
   beforeEach(enableCache);
-
   afterEach(disableCache);
 
   // integration_test_id: 9691969d-6ba8-4af6-93d6-dfe9134e9796

package/src/message/api/tests/getMessage.test.ts

@@ -2,14 +2,14 @@ import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/a
 import { isInTombstone } from '~/cache/api/isInTombstone';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
 import { ASCApiError } from '~/core/errors';
-import { client, generateRawMessage } from '~/utils/tests';
+import { client, convertRawMessage, generateRawMessage } from '~/utils/tests';
 
 import { getMessage } from '../getMessage';
 import { onMessageFetched } from '../../events/onMessageFetched';
-import { convertFromRaw } from '../../utils';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
 
 const rawMessageToGet = generateRawMessage();
-const messageToGet = convertFromRaw(rawMessageToGet);
+const messageToGet = convertRawMessage(rawMessageToGet);
 const { messageId } = messageToGet;
 
 const getResolvedMessageValue = () => ({
@@ -21,6 +21,15 @@ const getResolvedMessageValue = () => ({
 });
 
 describe('getMessage', () => {
+  beforeAll(() => {
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
   // integration_test_id: bc048747-17ea-43fe-9f97-7b2bf008c476
   test('should return fetched message', async () => {
     client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());

package/src/message/api/tests/getMessages.test.ts

@@ -1,13 +1,13 @@
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 import { ASCApiError } from '~/core/errors';
-import { client, generateRawMessage } from '~/utils/tests';
+import { client, convertRawMessage, generateRawMessage } from '~/utils/tests';
 
 import { getMessages } from '../getMessages';
 import { onMessageFetched } from '../../events/onMessageFetched';
-import { convertFromRaw } from '../../utils';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
 
 const rawMessagesToGet = [generateRawMessage(), generateRawMessage({ messageId: 'message-id-2' })];
-const messagesToGet = rawMessagesToGet.map(convertFromRaw);
+const messagesToGet = rawMessagesToGet.map(convertRawMessage);
 const messageIds = messagesToGet.map(x => x.messageId);
 
 const getResolvedMessageValue = () => ({
@@ -19,6 +19,15 @@ const getResolvedMessageValue = () => ({
 });
 
 describe('getMessages', () => {
+  beforeAll(() => {
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
   test('should return fetched messages', async () => {
     client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
 
@@ -67,8 +76,8 @@ describe('getMessages tombostone', () => {
 });
 
 describe('getMessages.locally', () => {
-  beforeEach(() => enableCache());
-  afterEach(() => disableCache());
+  beforeEach(enableCache);
+  afterEach(enableCache);
 
   test('should return cached messages', () => {
     messagesToGet.forEach(message => pushToCache(['message', 'get', message.messageId], message));

package/src/message/api/tests/markAsDelivered.test.ts

@@ -0,0 +1,83 @@
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  generateFeedMarker,
+  generateUserMarker,
+  generateChannelMarker,
+  generateSubChannelMarker,
+  activeUser,
+} from '~/utils/tests';
+
+import { markAsDelivered } from '../markAsDelivered';
+
+const { userId } = activeUser;
+const entityId = 'feed1';
+const feedId = 'sub-ch1';
+const messageId = 'message1';
+
+const expectedUserMarker = generateUserMarker({ userId });
+const expectedChannelMarker = generateChannelMarker({ userId, entityId });
+const expectedSubChannelMarker = generateSubChannelMarker({ userId, feedId, entityId });
+const expectedFeedMarker = generateFeedMarker({ feedId, entityId });
+
+const resolvedPutValue = {
+  data: {
+    userMarkers: [expectedUserMarker],
+    userEntityMarkers: [expectedChannelMarker],
+    userFeedMarkers: [expectedSubChannelMarker],
+    feedMarkers: [expectedFeedMarker],
+  } as Amity.MarkDeliveredPayload,
+};
+
+describe('markAsDelivered', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should return `true`', async () => {
+    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
+
+    const recieved = await markAsDelivered(feedId, messageId);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache', async () => {
+    expect.assertions(4);
+    enableCache();
+
+    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
+
+    await markAsDelivered(feedId, messageId);
+
+    const recievedUserMarkerCache = pullFromCache(['userMarker', 'get', userId]);
+
+    const recievedChannelMarkerCache = pullFromCache([
+      'channelMarker',
+      'get',
+      getResolver('channelMarker')({ entityId, userId }),
+    ]);
+
+    const recievedSubChannelMarkerCache = pullFromCache([
+      'subChannelMarker',
+      'get',
+      getResolver('subChannelMarker')({ entityId, feedId, userId }),
+    ]);
+
+    const recievedFeedMarkerCache = pullFromCache([
+      'feedMarker',
+      'get',
+      getResolver('feedMarker')({ entityId, feedId }),
+    ]);
+
+    expect(recievedUserMarkerCache?.data).toStrictEqual(expectedUserMarker);
+    expect(recievedChannelMarkerCache?.data).toStrictEqual(expectedChannelMarker);
+    expect(recievedSubChannelMarkerCache?.data).toStrictEqual(expectedSubChannelMarker);
+    expect(recievedFeedMarkerCache?.data).toStrictEqual(expectedFeedMarker);
+
+    disableCache();
+  });
+});

package/src/message/api/tests/queryMessages.test.ts

@@ -1,15 +1,17 @@
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
-import { client, generateRawMessage } from '~/utils/tests';
+import { client, convertRawMessage, generateRawMessage } from '~/utils/tests';
 
-import { convertFromRaw, convertQueryParams } from '../../utils';
+import { convertQueryParams } from '../../utils';
 import { queryMessages } from '../queryMessages';
 import { onMessageFetched } from '../../events/onMessageFetched';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
 
 const rawMessagesToQuery = [
   generateRawMessage(),
   generateRawMessage({ messageId: 'message-id-2' }),
 ];
-const messagesToQuery = rawMessagesToQuery.map(convertFromRaw);
+
+const messagesToQuery = rawMessagesToQuery.map(convertRawMessage);
 const messageIds = messagesToQuery.map(x => x.messageId);
 const queryCriteriaWithoutPage = { subChannelId: messagesToQuery[0].subChannelId };
 const queryCriteria = { ...queryCriteriaWithoutPage, page: { limit: 10 } };
@@ -28,6 +30,15 @@ const getResolvedMessageValue = () => ({
 });
 
 describe('queryMessages', () => {
+  beforeAll(() => {
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
   test('should return fetched messages with correct paging', async () => {
     client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
 

package/src/message/api/updateMessage.ts

@@ -3,7 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { pullFromCache, upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
-import { convertParams, convertResponseFromRaw } from '../utils';
+
+import { convertParams, prepareMessagePayload } from '../utils';
 
 /* begin_public_function
   id: message.edit
@@ -32,12 +33,12 @@ export const updateMessage = async (
   const client = getActiveClient();
   client.log('message/updateMessage', patch);
 
-  const { data } = await client.http
-    .put<Amity.MessagePayload>(
-      `/api/v5/messages/${encodeURIComponent(messageId)}`,
-      convertParams(patch),
-    )
-    .then(convertResponseFromRaw);
+  const { data: payload } = await client.http.put<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(messageId)}`,
+    convertParams(patch),
+  );
+
+  const data = await prepareMessagePayload(payload);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/message/events/index.ts

@@ -8,3 +8,5 @@ export * from './onMessageFlagCleared';
 
 export * from './onMessageReactionAdded';
 export * from './onMessageReactionRemoved';
+
+export * from './onMessageFetched';

package/src/message/events/onMessageCreated.ts

@@ -1,9 +1,7 @@
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
-
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { hasMention } from '~/utils';
+
 import { prepareMessagePayload } from '../utils';
 
 /**
@@ -17,48 +15,20 @@ import { prepareMessagePayload } from '../utils';
  * Fired when an {@link Amity.Message} has been created
  *
  * @param callback The function to call when the event was fired
+ * @param local Trigger when an event occurs from a local event or not
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Message Events
  */
-export const onMessageCreated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+export const onMessageCreated = (
+  callback: Amity.Listener<Amity.Message>,
+  local = true,
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.MessagePayload) => {
-    const payload = prepareMessagePayload(rawPayload);
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
     const message = payload.messages[0];
-    const cached = pullFromCache<Amity.Channel>(['channel', 'get', message.channelId]);
-
-    if (cached && cached.data.defaultSubChannelId === message.subChannelId) {
-      let update: Amity.Channel;
-
-      // @ts-ignore
-      if (cached.data.localReading) {
-        update = {
-          ...cached.data,
-          localReadToSegment: message.channelSegment,
-          localLastMentionSegment: hasMention(message, client.userId!)
-            ? message.channelSegment
-            : cached.data.localLastMentionSegment,
-          messageCount: message.channelSegment,
-          lastActivity: message.createdAt,
-          updatedAt: message.createdAt,
-        };
-      } else {
-        update = {
-          ...cached.data,
-          defaultSubChannelHasUnreadMention:
-            hasMention(message, client.userId!) || cached.data.defaultSubChannelHasUnreadMention,
-          defaultSubChannelUnreadCount: message.channelSegment - cached.data.localReadToSegment,
-          lastActivity: message.createdAt,
-          messageCount: message.channelSegment,
-          updatedAt: message.createdAt,
-        };
-      }
-
-      pushToCache(['channel', 'get', message.channelId], update);
-      client.emitter.emit('local.channel.updated', { channels: [update] });
-    }
 
     ingestInCache(payload);
     callback(message);
@@ -66,11 +36,14 @@ export const onMessageCreated = (callback: Amity.Listener<Amity.Message>): Amity
 
   const disposers = [
     createEventSubscriber(client, 'message/onMessageCreated', 'message.created', filter),
-    createEventSubscriber(client, 'local.message.created', 'local.message.created', payload =>
-      callback(payload.messages[0]),
-    ),
   ];
 
+  if (local) {
+    createEventSubscriber(client, 'message/onMessageCreated', 'local.message.created', payload =>
+      callback(payload.messages[0]),
+    );
+  }
+
   return () => {
     disposers.forEach(fn => fn());
   };

package/src/message/events/onMessageDeleted.ts

@@ -22,8 +22,8 @@ import { prepareMessagePayload } from '../utils';
 export const onMessageDeleted = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.MessagePayload) => {
-    const payload = prepareMessagePayload(rawPayload);
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);
     callback(payload.messages[0]);

package/src/message/events/onMessageFlagCleared.ts

@@ -23,8 +23,8 @@ export const onMessageFlagCleared = (
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.MessagePayload) => {
-    const payload = prepareMessagePayload(rawPayload);
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);
     callback(payload.messages[0]);

package/src/message/events/onMessageFlagged.ts

@@ -22,8 +22,8 @@ import { prepareMessagePayload } from '../utils';
 export const onMessageFlagged = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.MessagePayload) => {
-    const payload = prepareMessagePayload(rawPayload);
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);
     callback(payload.messages[0]);

package/src/message/events/onMessageReactionAdded.ts

@@ -24,8 +24,8 @@ export const onMessageReactionAdded = (
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.MessagePayload) => {
-    const payload = prepareMessagePayload(rawPayload);
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);
     callback(payload.messages[0]);

package/src/message/events/onMessageReactionRemoved.ts

@@ -24,8 +24,8 @@ export const onMessageReactionRemoved = (
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.MessagePayload) => {
-    const payload = prepareMessagePayload(rawPayload);
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);
     callback(payload.messages[0]);

package/src/message/events/onMessageUnflagged.ts

@@ -21,8 +21,8 @@ import { prepareMessagePayload } from '../utils';
 export const onMessageUnflagged = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.MessagePayload) => {
-    const payload = prepareMessagePayload(rawPayload);
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);
     callback(payload.messages[0]);

package/src/message/events/onMessageUpdated.ts

@@ -1,8 +1,10 @@
+import { pullFromCache, upsertInCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { prepareMessagePayload } from '../utils';
+
+import { prepareMessagePayload, updateMessageMarker } from '../utils';
 
 /**
  * ```js
@@ -22,18 +24,38 @@ import { prepareMessagePayload } from '../utils';
 export const onMessageUpdated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.MessagePayload) => {
-    const payload = prepareMessagePayload(rawPayload);
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);
     callback(payload.messages[0]);
   };
 
+  const messageMarkerChangeHandler = async (
+    rawPayload: MakeRequired<Amity.MessageMarkerPayload, 'contentMarkers'>,
+  ) => {
+    const marker = rawPayload.contentMarkers[0];
+    const cacheKey = ['message', 'get', marker.contentId];
+    const message = pullFromCache<Amity.Message>(cacheKey)?.data;
+
+    if (!message) return;
+
+    const updated = updateMessageMarker(message, marker);
+    upsertInCache(cacheKey, updated);
+    callback(updated);
+  };
+
   const disposers = [
-    createEventSubscriber(client, 'message/onMessageUpdated', 'message.updated', filter),
-    createEventSubscriber(client, 'local.message.updated', 'local.message.updated', payload =>
+    createEventSubscriber(client, 'onMessageUpdated', 'message.updated', filter),
+    createEventSubscriber(client, 'onMessageUpdated', 'local.message.updated', payload =>
       callback(payload.messages[0]),
     ),
+    createEventSubscriber(
+      client,
+      'onMessageUpdated',
+      'local.messageMarker.fetched',
+      messageMarkerChangeHandler,
+    ),
   ];
 
   return () => {

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

@@ -1,4 +1,4 @@
-import { client, generateRawMessage } from '~/utils/tests';
+import { client, generateRawMessage, pause } from '~/utils/tests';
 import { convertFromRaw } from '~/message/utils';
 import {
   onMessageCreated,
@@ -29,7 +29,7 @@ describe('Message Events', () => {
   ];
 
   cases.forEach(([onEvent, event]) => {
-    test(`should call '${onEvent.name}' callback if '${event}' event is dispatched`, () => {
+    test(`should call '${onEvent.name}' callback if '${event}' event is dispatched`, async () => {
       const callback = jest.fn();
       const unsubscribe = onEvent(callback);
       client.emitter.emit(event, {
@@ -38,6 +38,8 @@ describe('Message Events', () => {
         users: [],
       });
 
+      await pause();
+
       unsubscribe();
 
       expect(callback).toHaveBeenCalled();

package/src/message/tests/observers/liveMessage.test.ts

@@ -1,15 +1,22 @@
 import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache } from '~/cache/api';
 import { UNSYNCED_OBJECT_CACHED_AT_MESSAGE } from '~/utils/constants';
-import { pause, client, connectClient, disconnectClient, generateRawMessage } from '~/utils/tests';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  generateRawMessage,
+  convertRawMessage,
+} from '~/utils/tests';
 import { getFutureDate } from '~/core/model';
 
-import { convertFromRaw } from '../../utils';
 import { liveMessage } from '../../observers/liveMessage';
 import { createMessage } from '../../api';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
 
 const rawMessage = generateRawMessage();
-const message = convertFromRaw(rawMessage);
+const message = convertRawMessage(rawMessage);
 const messageQueryResponseRaw = {
   data: { messages: [rawMessage] },
 };
@@ -23,16 +30,20 @@ const getSnapshot = () => {
 };
 
 describe('liveMessage', () => {
-  beforeAll(async () => {
-    await connectClient();
+  beforeAll(() => {
+    connectClient();
+
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
   });
 
-  afterAll(async () => {
-    await disconnectClient();
-  });
+  afterAll(disconnectClient);
 
   beforeEach(enableCache);
-
   afterEach(disableCache);
 
   const events: [string, keyof Amity.Events][] = [
@@ -47,6 +58,7 @@ describe('liveMessage', () => {
   ];
 
   test.each(events)('%s', async (test, event) => {
+    await disableCache();
     const snapshot = getSnapshot();
 
     // mock response of queryMessages and validate
@@ -64,7 +76,7 @@ describe('liveMessage', () => {
       data: { text: event },
       updatedAt: getFutureDate(rawMessage.updatedAt),
     };
-    const updatedMessage = convertFromRaw(rawUpdatedMessage);
+    const updatedMessage = convertRawMessage(rawUpdatedMessage);
     if (event === 'local.message.fetched') {
       client.emitter.emit('local.message.fetched', { messages: [updatedMessage] });
     } else {