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

package/src/marker/events/onUserMarkerFetched.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onUserMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onUserMarkerFetched(userMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.UserMarker} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category UserMarker Events
+ */
+export const onUserMarkerFetched = (
+  callback: Amity.Listener<Amity.UserMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.userMarker.fetched']) => {
+    callback(payload.userMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'userMarker/onUserMarkerFetched',
+    'local.userMarker.fetched',
+    filter,
+  );
+};

package/src/message/api/createMessage.ts

@@ -68,7 +68,7 @@ export const createMessage = async <T extends Amity.MessageContentType>(
     referenceId,
   });
 
-  const data = prepareMessagePayload(payload);
+  const data = await prepareMessagePayload(payload);
   const { messages } = data;
 
   const cachedAt = client.cache && Date.now();

package/src/message/api/getMessage.ts

@@ -7,7 +7,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { isInTombstone } from '~/cache/api/isInTombstone';
 import { checkIfShouldGoesToTombstone } from '~/cache/utils';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
-import { convertResponseFromRaw } from '../utils';
+
+import { prepareMessagePayload } from '../utils';
 
 /* begin_public_function
   id: message.get
@@ -45,11 +46,11 @@ export const getMessage = async (
 
   try {
     // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const response = await client.http
-      .get<Amity.MessagePayload>(`/api/v5/messages/${encodeURIComponent(messageId)}`)
-      .then(convertResponseFromRaw);
+    const { data: payload } = await client.http.get<Amity.MessagePayload>(
+      `/api/v5/messages/${encodeURIComponent(messageId)}`,
+    );
 
-    data = response.data;
+    data = await prepareMessagePayload(payload);
   } catch (error) {
     if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
       pushToTombstone('message', messageId);

package/src/message/api/getMessages.ts

@@ -3,7 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { fireEvent } from '~/core/events';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertResponseFromRaw } from '../utils';
+
+import { prepareMessagePayload } from '../utils';
 
 /**
  * ```js
@@ -25,11 +26,11 @@ export const getMessages = async (
   const client = getActiveClient();
   client.log('message/getMessages', messageIds);
 
-  const { data } = await client.http
-    .get<Amity.MessagePayload>(`/api/v5/messages/list`, {
-      params: { messageIds: messageIds.map(encodeURIComponent) },
-    })
-    .then(convertResponseFromRaw);
+  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 });

package/src/message/api/index.ts

@@ -4,3 +4,4 @@ export * from './queryMessages';
 export * from './createMessage';
 export * from './updateMessage';
 export * from './deleteMessage';
+export * from './markAsDelivered';

package/src/message/api/markAsDelivered.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { markAsDelivered } from '@amityco/ts-sdk'
+ * const success = await markAsDelivered('subChannelId', 'messageId')
+ * ```
+ *
+ * Update `deliveredToSegment` in  {@link Amity.SubChannelMarker}
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} of message
+ * @param messageId the ID of the {@link Amity.Message} to mark delivered
+ * @returns A success boolean if the {@link Amity.SubChannel} was updated
+ *
+ * @category Message API
+ * @async
+ */
+export const markAsDelivered = async (
+  subChannelId: Amity.Message['subChannelId'],
+  messageId: Amity.Message['messageId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('message/markAsDelivered', subChannelId, messageId);
+
+  const { data } = await client.http.put<Amity.MarkDeliveredPayload>(
+    `/api/v1/markers/message-feeds/${subChannelId}/mark-delivering`,
+    { messageId },
+  );
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return true;
+};

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]);