@amityco/ts-sdk 0.0.1-beta.32 → 0.0.1-beta.36

package/src/message/api/createMessage.ts

@@ -3,15 +3,24 @@ import { fireEvent } from '~/core/events';
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
-import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
+import { upsertInCache, pullFromCache, pushToCache, dropFromCache } from '~/cache/api';
+import { convertParams, convertResponseFromRaw } from '../utils';
+
+// FIXME: temp solution
+let uniqueId: string | undefined;
 
 /**
  * ```js
- * import { createMessage } from '@amityco/ts-sdk'
- * const created = await createMessage({
- *   channelId: 'foobar',
- *   data: { text: 'hello world' }
- * })
+ * import { createMessage, createQuery, runQuery } from '@amityco/ts-sdk'
+ *
+ * const query = createQuery(createMessage, {
+ *   subChannelId: 'foobar',
+ *   data: { text: 'hello world' },
+ * });
+ *
+ * runQuery(query, ({ data: message, loading }) => {
+ *   console.log(message);
+ * });
  * ```
  *
  * Creates an {@link Amity.Message}
@@ -25,24 +34,33 @@ import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 export const createMessage = async <T extends Amity.MessageContentType>(
   bundle: Pick<
     Amity.Message<T>,
-    'channelId' | 'parentId' | 'type' | 'tags' | 'metadata' | 'mentionees'
+    'subChannelId' | 'parentId' | 'dataType' | 'tags' | 'metadata' | 'mentionees'
   > & {
     data?: Amity.Message<T>['data'];
-    fileId?: Amity.Message<T>['fileId'];
+    fileId?: Amity.File['fileId'];
   },
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
+  client.log('message/createMessage', bundle);
 
-  client.log('user/createMessage', bundle);
-
-  const { data } = await client.http.post<Amity.MessagePayload>('/api/v3/messages', bundle);
+  const referenceId = uniqueId;
+  uniqueId = undefined;
+  const { data } = await client.http
+    .post<Amity.RawMessagePayload>('/api/v5/messages', {
+      ...convertParams(bundle),
+      referenceId,
+    })
+    .then(convertResponseFromRaw);
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
+  if (client.cache) {
+    dropFromCache(['message', 'get', referenceId]);
+    ingestInCache(data, { cachedAt });
+  }
 
   const { messages } = data;
 
-  fireEvent('v3.message.didCreate', { messages });
+  fireEvent('local.message.created', { messages });
 
   return {
     data: messages[0],
@@ -53,7 +71,8 @@ export const createMessage = async <T extends Amity.MessageContentType>(
 /**
  * ```js
  * import { createMessage } from '@amityco/ts-sdk'
- * const created = createMessage.locally({
+ *
+ * const created = createMessage.optimistically({
  *   channelId: 'foobar',
  *   data: { text: 'hello world' }
  * })
@@ -67,10 +86,7 @@ export const createMessage = async <T extends Amity.MessageContentType>(
  * @category Message API
  */
 createMessage.optimistically = (
-  bundle: Pick<
-    Amity.Message,
-    'channelId' | 'parentId' | 'type' | 'data' | 'tags' | 'metadata' | 'mentionees'
-  >,
+  bundle: Parameters<typeof createMessage>[0],
 ): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient();
 
@@ -83,24 +99,39 @@ createMessage.optimistically = (
    * Updated to handle client requirement to add messageId while uploading
    * message with image. Temporary!
    */
-  const bundleWithMessageId = { messageId: uuid(), ...bundle };
+  const localId = `LOCAL_${uuid()}`;
+  uniqueId = localId;
+  const bundleWithMessageId = { messageId: localId, uniqueId: localId, ...bundle };
+
+  client.log('message/createMessage.optimistically', bundleWithMessageId);
+
+  const subChannel = pullFromCache<Amity.SubChannel>(['subChannel', 'get', bundle.subChannelId]);
 
-  // only log if cache is enabled
-  client.log('user/createMessage.locally', bundleWithMessageId);
+  if (subChannel) {
+    upsertInCache(['subChannel', 'get', bundle.subChannelId], {
+      ...subChannel.data,
+      messageCount: subChannel.data.messageCount + 1,
+    });
 
-  const channel = pullFromCache<Amity.Channel>(['channel', 'get', bundleWithMessageId.channelId]);
+    if (subChannel.data.channelId === subChannel.data.subChannelId) {
+      const channel = pullFromCache<Amity.Channel>(['channel', 'get', subChannel.data.channelId]);
 
-  upsertInCache(['channel', 'get', bundleWithMessageId.channelId], {
-    ...channel?.data,
-    messageCount: (channel?.data.messageCount ?? 0) + 1,
-  });
+      if (channel?.data) {
+        upsertInCache(['channel', 'get', subChannel.data.channelId], {
+          ...channel.data,
+          messageCount: (channel.data.messageCount ?? 0) + 1,
+        });
+      }
+    }
+  }
 
   // as reused to update created and updated time, which should be the same
   const createdTime = new Date().toISOString();
 
   const message = {
-    userId: client.userId,
-    channelSegment: (channel?.data.messageCount ?? 0) + 1,
+    creatorId: client.userId!,
+    channelSegment: (subChannel?.data.messageCount ?? 0) + 1,
+    childrenNumber: 0,
     createdAt: createdTime,
     updatedAt: createdTime,
     ...bundleWithMessageId,
@@ -109,7 +140,7 @@ createMessage.optimistically = (
   const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
 
   pushToCache(['message', 'get', message.messageId], message, { cachedAt });
-  fireEvent('v3.message.didCreate', { messages: [message] });
+  fireEvent('local.message.created', { messages: [message] });
 
   return {
     cachedAt,

package/src/message/api/deleteMessage.ts

@@ -12,7 +12,7 @@ import { getMessage } from './getMessage';
  *
  * Delete a {@link Amity.Message}
  *
- * @param The ID of the {@link Amity.Message} to delete
+ * @param messageId the ID of the {@link Amity.Message} to delete
  * @return A success boolean if the {@link Amity.Message} was deleted
  *
  * @category Message API
@@ -26,12 +26,12 @@ export const deleteMessage = async (
 
   // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(
-    `/api/v3/messages/${encodeURIComponent(messageId)}`,
+    `/api/v5/messages/${encodeURIComponent(messageId)}`,
   );
 
   const deleted = await getMessage(messageId);
 
-  fireEvent('v3.message.didDelete', { messages: [deleted.data] });
+  fireEvent('local.message.deleted', { messages: [deleted.data] });
 
   return deleted.data;
 };
@@ -39,7 +39,7 @@ export const deleteMessage = async (
 /**
  * ```js
  * import { deleteMessage } from '@amityco/ts-sdk'
- * const success = deleteMessage.locally('foobar')
+ * const success = deleteMessage.optimistically('foobar')
  * ```
  *
  * Deletes a {@link Amity.Message}
@@ -53,7 +53,7 @@ deleteMessage.optimistically = (
   messageId: Amity.Message['messageId'],
 ): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient();
-  client.log('message/deleteMessage', messageId);
+  client.log('message/deleteMessage.optimistically', messageId);
 
   const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
 
@@ -67,7 +67,7 @@ deleteMessage.optimistically = (
   };
 
   upsertInCache(['message', 'get', messageId], deleted, { cachedAt });
-  fireEvent('v3.message.didDelete', { messages: [deleted] });
+  fireEvent('local.message.deleted', { messages: [deleted] });
 
   return {
     data: deleted,

package/src/message/api/getMessage.ts

@@ -7,6 +7,7 @@ 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';
 
 /**
  * ```js
@@ -41,9 +42,9 @@ 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/v3/messages/${encodeURIComponent(messageId)}`,
-    );
+    const response = await client.http
+      .get<Amity.RawMessagePayload>(`/api/v5/messages/${encodeURIComponent(messageId)}`)
+      .then(convertResponseFromRaw);
 
     data = response.data;
   } catch (error) {
@@ -59,7 +60,7 @@ export const getMessage = async (
 
   const { messages } = data;
 
-  fireEvent('v3.message.didFetch', { messages });
+  fireEvent('local.message.fetched', { messages });
 
   return {
     data: messages.find(message => message.messageId === messageId)!,

package/src/message/api/getMessages.ts

@@ -3,6 +3,7 @@ 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';
 
 /**
  * ```js
@@ -24,17 +25,18 @@ export const getMessages = async (
   const client = getActiveClient();
   client.log('message/getMessages', messageIds);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.MessagePayload>(`/api/v3/messages/list`, {
-    params: { messageIds },
-  });
+  const { data } = await client.http
+    .get<Amity.RawMessagePayload>(`/api/v5/messages/list`, {
+      params: { messageIds: messageIds.map(encodeURIComponent) },
+    })
+    .then(convertResponseFromRaw);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
   const { messages } = data;
 
-  fireEvent('v3.message.didFetch', { messages });
+  fireEvent('local.message.fetched', { messages });
 
   return {
     data: messages,

package/src/message/api/queryMessages.ts

@@ -1,10 +1,11 @@
 import { getActiveClient } from '~/client/api';
 
 import { fireEvent } from '~/core/events';
-import { toPage, toToken } from '~/core/query';
+import { toPage } 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';
 
 /**
  * ```js
@@ -26,44 +27,31 @@ export const queryMessages = async (
   const client = getActiveClient();
   client.log('message/queryMessages', query);
 
-  const { page = { limit: 10 }, ...params } = query;
+  const params = convertQueryParams(query);
 
   // API-FIX: parameters should be querystring. (1)
   // 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 { data } = await client.http.get<Amity.MessagePayload & Amity.Pagination>(
-    `/api/v3/messages`,
-    {
-      params: {
-        ...params,
-        options: {
-          token: toToken(page, 'afterbefore'),
-        },
-      },
-    },
-  );
+  const response = await client.http
+    .get<Amity.RawMessagePayload & Amity.Pagination>(`/api/v5/messages`, { params })
+    .then(convertResponseFromRaw);
 
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, messages } = unwrapPayload(data)
-
-  const { paging, ...payload } = data;
-  const { messages } = payload;
+  const { paging, ...data } = response.data;
+  const { messages } = data;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.MessagePayload, { cachedAt });
+    ingestInCache(data as Amity.MessagePayload, { cachedAt });
 
-    const cacheKey = [
-      'message',
-      'query',
-      { ...params, options: { ...page } } as Amity.Serializable,
-    ];
+    const cacheKey = ['message', 'query', params as Amity.Serializable];
     pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });
   }
 
-  fireEvent('v3.message.didFetch', { messages });
+  fireEvent('local.message.fetched', { messages });
 
   const nextPage = toPage(paging.next);
   const prevPage = toPage(paging.previous);
@@ -92,9 +80,9 @@ queryMessages.locally = (
 
   if (!client.cache) return;
 
-  const { page = { limit: 10 }, ...params } = query;
+  const params = convertQueryParams(query);
 
-  const queryKey = ['message', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const queryKey = ['message', 'query', params as Amity.Serializable];
   const { data, cachedAt } =
     pullFromCache<{ messages: Pick<Amity.Message, 'messageId'>[] } & Amity.Pagination>(queryKey) ??
     {};

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

@@ -1,29 +1,39 @@
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 
-import { client, message11 } from '~/utils/tests';
+import { client, generateRawMessage, pause } from '~/utils/tests';
 
+import { convertFromRaw } from '../../utils';
 import { onMessageCreated } from '../../events';
 import { createMessage } from '../createMessage';
 
-const messageToCreate = message11;
-const { messageId, ...messageWithoutId } = message11;
-
-const getResolvedMessageValue = () => ({
-  data: {
-    messages: [messageToCreate],
-    users: [],
-    files: [],
-  },
-});
+const rawMessageToCreate = generateRawMessage();
+const messageToCreate = convertFromRaw(rawMessageToCreate);
+const { messageId, uniqueId, ...messageWithoutId } = messageToCreate;
 
 describe('createMessage', () => {
+  const bundle = {
+    data: messageToCreate.data,
+    dataType: messageToCreate.dataType,
+    referenceId: 'LOCAL_xxx',
+    subChannelId: messageToCreate.subChannelId,
+  };
+
+  const response = {
+    data: { messages: [rawMessageToCreate] },
+  };
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
   test('should return created message', async () => {
-    client.http.post = jest.fn().mockResolvedValue(getResolvedMessageValue());
+    client.http.post = jest.fn().mockResolvedValue(response);
 
-    const recieved = createMessage(messageWithoutId);
+    const { data: created } = await createMessage(bundle);
 
-    await expect(recieved).resolves.toEqual(expect.objectContaining({ data: messageToCreate }));
+    expect(created).toMatchObject(messageToCreate);
+    expect(created.uniqueId).toBeDefined();
   });
 
   test('should throw an error if request fails', async () => {
@@ -32,21 +42,18 @@ describe('createMessage', () => {
     await expect(createMessage(messageWithoutId)).rejects.toThrow('error');
   });
 
-  test('should create cache after created messages', async () => {
-    enableCache();
-    client.http.post = jest.fn().mockResolvedValue(getResolvedMessageValue());
-
-    const created = await createMessage(messageWithoutId);
-    const recieved = pullFromCache(['message', 'get', created.data.messageId])?.data;
+  test('should put message into cache', async () => {
+    client.http.post = jest.fn().mockResolvedValue(response);
 
-    expect(recieved).toEqual(expect.objectContaining(messageWithoutId));
+    const { data: created } = await createMessage(bundle);
 
-    disableCache();
+    const cache = pullFromCache(['message', 'get', created.messageId]);
+    expect(cache).toMatchObject({ data: messageWithoutId });
   });
 
   test('should fire event `onMessageCreated`', async () => {
     let dispose;
-    client.http.post = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+    client.http.post = jest.fn().mockResolvedValueOnce(response);
 
     const callbackPromise = new Promise(resolve => {
       dispose = onMessageCreated(resolve);
@@ -54,29 +61,57 @@ describe('createMessage', () => {
 
     await createMessage(messageWithoutId);
 
-    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(messageWithoutId));
+    await expect(callbackPromise).resolves.toMatchObject(messageWithoutId);
   });
 });
 
 describe('createMessage.optimistically', () => {
-  beforeEach(() => enableCache());
-  afterEach(() => disableCache());
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
 
   test('should create cache after created message', () => {
     const optimisticId = createMessage.optimistically(messageWithoutId)?.data?.messageId;
-    const recieved = pullFromCache(['message', 'get', optimisticId])?.data;
+    const received = pullFromCache(['message', 'get', optimisticId])?.data;
 
-    expect(recieved).toEqual(expect.objectContaining(messageWithoutId));
+    expect(received).toMatchObject(messageWithoutId);
   });
 
-  test('should increase message count after created message', () => {
-    const { channelId } = messageWithoutId;
-    pushToCache(['channel', 'get', channelId], { channelId, messageCount: 2 });
-
-    createMessage.optimistically(messageWithoutId);
-    const recieved = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
-
-    expect(recieved?.messageCount).toBe(3);
+  describe('should increase message count after create message', () => {
+    test('in sub channel', () => {
+      const { channelId, subChannelId } = messageWithoutId;
+      pushToCache(['channel', 'get', channelId], { channelId, messageCount: 2 });
+      pushToCache(['subChannel', 'get', subChannelId], {
+        channelId,
+        subChannelId,
+        messageCount: 2,
+      });
+
+      createMessage.optimistically(messageWithoutId);
+
+      const cacheSubChannel = pullFromCache<Amity.SubChannel>([
+        'subChannel',
+        'get',
+        subChannelId,
+      ])?.data;
+
+      expect(cacheSubChannel?.messageCount).toBe(3);
+    });
+
+    test('in channel if message created in main sub channel', () => {
+      const { subChannelId } = messageWithoutId;
+      pushToCache(['channel', 'get', subChannelId], { channelId: subChannelId, messageCount: 2 });
+      pushToCache(['subChannel', 'get', subChannelId], {
+        channelId: subChannelId,
+        subChannelId,
+        messageCount: 2,
+      });
+
+      createMessage.optimistically(messageWithoutId);
+
+      const cacheChannel = pullFromCache<Amity.Channel>(['channel', 'get', subChannelId])?.data;
+      expect(cacheChannel?.messageCount).toBe(3);
+    });
   });
 
   test('should fire event `onMessageCreated`', async () => {
@@ -88,7 +123,7 @@ describe('createMessage.optimistically', () => {
 
     createMessage.optimistically(messageWithoutId);
 
-    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(messageWithoutId));
+    await expect(callbackPromise).resolves.toMatchObject(messageWithoutId);
   });
 
   test('should define object as unsynced object', async () => {
@@ -97,3 +132,60 @@ describe('createMessage.optimistically', () => {
     );
   });
 });
+
+describe('uniqueId / referenceId', () => {
+  const bundle = {
+    data: messageToCreate.data,
+    dataType: messageToCreate.dataType,
+    subChannelId: messageToCreate.subChannelId,
+  };
+
+  beforeAll(enableCache);
+
+  afterAll(disableCache);
+
+  it('should optimistically create message with uniqueId', () => {
+    const { data: message } = createMessage.optimistically(bundle)!;
+
+    expect(message.uniqueId).toBeDefined();
+    expect(message.uniqueId).toEqual(message.messageId);
+  });
+
+  it('should update messageId, retain uniqueId if optimistic message is in cache', async () => {
+    const { data: optimisticMessage } = createMessage.optimistically(bundle)!;
+    client.http.post = jest.fn().mockResolvedValue({
+      data: { messages: [{ ...messageToCreate, referenceId: optimisticMessage.uniqueId }] },
+    });
+
+    const { data: message } = await createMessage(bundle);
+
+    expect(client.http.post as jest.Mock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ referenceId: optimisticMessage.uniqueId }),
+    );
+    expect(message.uniqueId).toEqual(optimisticMessage.uniqueId);
+    expect(message.uniqueId).not.toEqual(message.messageId);
+    expect(pullFromCache(['message', 'get', optimisticMessage.uniqueId])).toBeUndefined();
+    expect(pullFromCache(['message', 'get', message.messageId])).toMatchObject({ data: message });
+  });
+
+  it('should set uniqueId to messageId if optimistic message is not in cache', async () => {
+    const rawNewMessage = {
+      ...rawMessageToCreate,
+      messageId: 'new-message-id',
+      referenceId: 'LOCAL_new-message-id',
+    };
+    const callback = jest.fn();
+
+    onMessageCreated(callback);
+    client.emitter.emit('message.created', { messages: [rawNewMessage] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        messageId: rawNewMessage.messageId,
+        uniqueId: rawNewMessage.messageId,
+      }),
+    );
+  });
+});

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

@@ -1,17 +1,19 @@
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
-import { client, message11 } from '~/utils/tests';
+import { client, generateRawMessage } from '~/utils/tests';
 
 import { deleteMessage } from '../deleteMessage';
 import { onMessageDeleted } from '../../events';
+import { convertFromRaw } from '../../utils';
 
-const messageToDelete = { ...message11, isDeleted: false };
+const rawMessageToDelete = generateRawMessage();
+const messageToDelete = convertFromRaw(rawMessageToDelete);
 const { messageId: deleteId } = messageToDelete;
-const deletedMessage = { ...messageToDelete, isDeleted: true };
-const { updatedAt, ...deletedMessageWithoutTS } = deletedMessage;
+const rawDeletedMessage = { ...rawMessageToDelete, isDeleted: true };
+const deletedMessage = convertFromRaw(rawDeletedMessage);
 
 const getResolvedMessageValue = () => ({
   data: {
-    messages: [deletedMessage],
+    messages: [rawDeletedMessage],
     users: [],
     files: [],
   },
@@ -22,7 +24,7 @@ describe('deleteMessage', () => {
     client.http.delete = jest.fn();
     client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
 
-    await expect(deleteMessage(deleteId)).resolves.toEqual(deletedMessageWithoutTS);
+    await expect(deleteMessage(deleteId)).resolves.toEqual(deletedMessage);
   });
 
   test('should throw an error if request fails', async () => {
@@ -40,7 +42,7 @@ describe('deleteMessage', () => {
     await deleteMessage(deleteId);
     const recieved = pullFromCache<Amity.Message>(['message', 'get', deleteId])?.data;
 
-    expect(recieved).toEqual(deletedMessageWithoutTS);
+    expect(recieved).toEqual(deletedMessage);
 
     disableCache();
   });
@@ -56,7 +58,7 @@ describe('deleteMessage', () => {
 
     await deleteMessage(deleteId);
 
-    await expect(callbackPromise).resolves.toEqual(deletedMessageWithoutTS);
+    await expect(callbackPromise).resolves.toEqual(deletedMessage);
   });
 });
 
@@ -70,7 +72,10 @@ describe('deleteMessage.optimistically', () => {
     deleteMessage.optimistically(deleteId);
     const recieved = pullFromCache<Amity.Message>(['message', 'get', deleteId])?.data;
 
-    expect(recieved).toEqual(expect.objectContaining(deletedMessageWithoutTS));
+    expect(recieved).toEqual({
+      ...deletedMessage,
+      updatedAt: expect.anything(),
+    });
   });
 
   /* TODO: re-enable this after fixed channel message count calculation */
@@ -97,9 +102,10 @@ describe('deleteMessage.optimistically', () => {
 
     await deleteMessage.optimistically(deleteId);
 
-    await expect(callbackPromise).resolves.toEqual(
-      expect.objectContaining(deletedMessageWithoutTS),
-    );
+    await expect(callbackPromise).resolves.toEqual({
+      ...deletedMessage,
+      updatedAt: expect.anything(),
+    });
   });
 
   test('should define object as unsynced object', () => {

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

@@ -2,17 +2,19 @@ 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, message11 } from '~/utils/tests';
+import { client, generateRawMessage } from '~/utils/tests';
 
 import { getMessage } from '../getMessage';
-import { onMessageFetched } from '../../events';
+import { onMessageFetched } from '../../events/onMessageFetched';
+import { convertFromRaw } from '../../utils';
 
-const messageToGet = message11;
+const rawMessageToGet = generateRawMessage();
+const messageToGet = convertFromRaw(rawMessageToGet);
 const { messageId } = messageToGet;
 
 const getResolvedMessageValue = () => ({
   data: {
-    messages: [messageToGet],
+    messages: [rawMessageToGet],
     users: [],
     files: [],
   },