@amityco/ts-sdk 6.2.1-b60a2f4.0 → 6.2.1-b68e715.0

package/src/communityRepository/observers/getCommunities.ts

@@ -147,7 +147,7 @@ export const getCommunities = (
 
     const query = createQuery(queryCommunities, {
       ...queryParams,
-      page: collection?.params.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(

package/src/core/query/tests/runQuery.test.ts

@@ -3,7 +3,7 @@ import { disableCache, enableCache, pushToCache } from '~/cache/api';
 import { runQuery, createQuery } from '~/core/query';
 import { createPost } from '~/postRepository/api';
 import { getPost } from '~/postRepository/api/getPost';
-import { deleteMessage } from '~/messageRepository/api';
+import { softDeleteMessage } from '~/messageRepository/api';
 
 import { posts, client, pause, emptyPostPayload } from '~/utils/tests';
 
@@ -115,7 +115,7 @@ describe('Core/Query/runQuery', () => {
     // 'get', gets called after delete to verify delete
     client.http.get = jest.fn();
 
-    const query = createQuery(deleteMessage, deletingMsgId);
+    const query = createQuery(softDeleteMessage, deletingMsgId);
     runQuery(query);
 
     expect(client.http.delete).toHaveBeenCalledWith(`/api/v5/messages/${deletingMsgId}`);
@@ -148,7 +148,7 @@ describe('Core/Query/runQuery', () => {
       );
     const callback = jest.fn();
 
-    const query = createQuery(deleteMessage, deletingMsgId);
+    const query = createQuery(softDeleteMessage, deletingMsgId);
     runQuery(query, callback);
     await pause();
 

package/src/feedRepository/api/index.ts

@@ -1 +1,2 @@
 export * from './queryGlobalFeed';
+export * from './getCustomRankingGlobalFeed';

package/src/fileRepository/api/index.ts

@@ -1,6 +1,6 @@
 export * from './getFile';
-export * from './createFile';
+export * from './uploadFile';
 export * from './deleteFile';
 export * from './fileUrlWithSize';
-export * from './createVideo';
-export * from './createImage';
+export * from './uploadVideo';
+export * from './uploadImage';

package/src/fileRepository/api/test/uploadFile.test.ts

@@ -0,0 +1,69 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, file12, createEmptyFormData, createFileFormData } from '~/utils/tests';
+
+import { uploadFile } from '../uploadFile';
+
+const videoToCreate = [file12];
+const createIds = videoToCreate.map(({ fileId }) => fileId);
+const resolvedPayloadValue = { data: videoToCreate };
+
+describe('uploadFile', () => {
+  test('it should return created file', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    const received = uploadFile(formData);
+
+    await expect(received).resolves.toEqual(expect.objectContaining({ data: videoToCreate }));
+  });
+
+  test('it should throw an error if request fails', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(uploadFile(formData)).rejects.toThrow('error');
+  });
+
+  test('it should throw an error if formData is empty', async () => {
+    const emptyFormData = createEmptyFormData();
+
+    await expect(uploadFile(emptyFormData)).rejects.toThrow(
+      'The formData object must have a `files` key.',
+    );
+  });
+
+  test('it should call onProgress params on upload progress updated', async () => {
+    expect.assertions(3);
+    const formData = createFileFormData();
+    const onProgress = jest.fn();
+
+    jest.spyOn(client.http, 'post').mockImplementationOnce(
+      (_, __, config) =>
+        new Promise((resolve, _reject) => {
+          config?.onUploadProgress?.({ loaded: 0, bytes: 0, total: 100 });
+          config?.onUploadProgress?.({ loaded: 40, bytes: 40, total: 100 });
+          config?.onUploadProgress?.({ loaded: 100, bytes: 100, total: 100 });
+          resolve(resolvedPayloadValue);
+        }),
+    );
+
+    await uploadFile(formData, onProgress);
+
+    expect(onProgress).toHaveBeenNthCalledWith(1, 0);
+    expect(onProgress).toHaveBeenNthCalledWith(2, 40);
+    expect(onProgress).toHaveBeenNthCalledWith(3, 100);
+  });
+
+  test('it should create cache after created file', async () => {
+    enableCache();
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    await uploadFile(formData);
+    const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
+
+    expect(received).toEqual(expect.objectContaining(videoToCreate));
+
+    disableCache();
+  });
+});

package/src/fileRepository/api/test/{createImage.test.ts → uploadImage.test.ts}

@@ -1,18 +1,18 @@
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { client, file11, createEmptyFormData, createFileFormData } from '~/utils/tests';
 
-import { createImage } from '../createImage';
+import { uploadImage } from '../uploadImage';
 
 const imageToCreate = [file11];
 const createIds = imageToCreate.map(({ fileId }) => fileId);
 const resolvedPayloadValue = { data: imageToCreate };
 
-describe('createImage', () => {
+describe('uploadImage', () => {
   test('should return created image', async () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
 
-    const received = createImage(formData);
+    const received = uploadImage(formData);
 
     await expect(received).resolves.toEqual(expect.objectContaining({ data: imageToCreate }));
   });
@@ -21,13 +21,13 @@ describe('createImage', () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
 
-    await expect(createImage(formData)).rejects.toThrow('error');
+    await expect(uploadImage(formData)).rejects.toThrow('error');
   });
 
   test('should throw an error if formData is empty', async () => {
     const emptyFormData = createEmptyFormData();
 
-    await expect(createImage(emptyFormData)).rejects.toThrow(
+    await expect(uploadImage(emptyFormData)).rejects.toThrow(
       'The formData object must have a `files` key.',
     );
   });
@@ -47,7 +47,7 @@ describe('createImage', () => {
         }),
     );
 
-    await createImage(formData, onProgress);
+    await uploadImage(formData, onProgress);
 
     expect(onProgress).toHaveBeenNthCalledWith(1, 0);
     expect(onProgress).toHaveBeenNthCalledWith(2, 40);
@@ -59,7 +59,7 @@ describe('createImage', () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
 
-    await createImage(formData);
+    await uploadImage(formData);
     const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
 
     expect(received).toEqual(expect.objectContaining(imageToCreate));

package/src/fileRepository/api/test/{createVideo.test.ts → uploadVideo.test.ts}

@@ -2,18 +2,18 @@ import { ContentFeedType } from '~/@types';
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { client, file12, createEmptyFormData, createFileFormData } from '~/utils/tests';
 
-import { createVideo } from '../createVideo';
+import { uploadVideo } from '../uploadVideo';
 
 const videoToCreate = [file12];
 const createIds = videoToCreate.map(({ fileId }) => fileId);
 const resolvedPayloadValue = { data: videoToCreate };
 
-describe('createVideo', () => {
+describe('uploadVideo', () => {
   test('should return created video', async () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
 
-    const received = createVideo(formData);
+    const received = uploadVideo(formData);
 
     await expect(received).resolves.toEqual(expect.objectContaining({ data: videoToCreate }));
   });
@@ -22,13 +22,13 @@ describe('createVideo', () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
 
-    await expect(createVideo(formData)).rejects.toThrow('error');
+    await expect(uploadVideo(formData)).rejects.toThrow('error');
   });
 
   test('should throw an error if formData is empty', async () => {
     const emptyFormData = createEmptyFormData();
 
-    await expect(createVideo(emptyFormData)).rejects.toThrow(
+    await expect(uploadVideo(emptyFormData)).rejects.toThrow(
       'The formData object must have a `files` key.',
     );
   });
@@ -39,7 +39,7 @@ describe('createVideo', () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
 
-    await createVideo(formData, ContentFeedType.POST);
+    await uploadVideo(formData, ContentFeedType.POST);
 
     expect(formData.get('feedType')).toEqual(ContentFeedType.POST);
   });
@@ -59,7 +59,7 @@ describe('createVideo', () => {
         }),
     );
 
-    await createVideo(formData, undefined, onProgress);
+    await uploadVideo(formData, undefined, onProgress);
 
     expect(onProgress).toHaveBeenNthCalledWith(1, 0);
     expect(onProgress).toHaveBeenNthCalledWith(2, 40);
@@ -71,7 +71,7 @@ describe('createVideo', () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
 
-    await createVideo(formData);
+    await uploadVideo(formData);
     const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
 
     expect(received).toEqual(expect.objectContaining(videoToCreate));

package/src/fileRepository/api/{createFile.ts → uploadFile.ts}

@@ -7,8 +7,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 */
 /**
  * ```js
- * import { createFile } from '@amityco/ts-sdk'
- * const created = await createFile(formData)
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const created = await FileRepository.uploadFile(formData)
  * ```
  *
  * Creates an {@link Amity.File}
@@ -20,12 +20,12 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * @category File API
  * @async
  */
-export const createFile = async <T extends Amity.FileType = any>(
+export const uploadFile = async <T extends Amity.FileType = any>(
   formData: FormData,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File[]>> => {
   const client = getActiveClient();
-  client.log('file/createFile', formData);
+  client.log('file/uploadFile', formData);
 
   if (!formData.getAll('files').length)
     throw new Error('The formData object must have a `files` key.');
@@ -54,5 +54,3 @@ export const createFile = async <T extends Amity.FileType = any>(
   };
 };
 /* end_public_function */
-
-// TODO: consider doing local creation with URL.createObjectURL()

package/src/fileRepository/api/{createImage.ts → uploadImage.ts}

@@ -7,8 +7,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 */
 /**
  * ```js
- * import { createImage } from '@amityco/ts-sdk'
- * const created = await createImage(formData)
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const created = await FileRepository.uploadImage(formData)
  * ```
  *
  * Creates an {@link Amity.File<'image'>}
@@ -20,12 +20,12 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * @category File API
  * @async
  */
-export const createImage = async (
+export const uploadImage = async (
   formData: FormData,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File<'image'>[]>> => {
   const client = getActiveClient();
-  client.log('file/createImage', formData);
+  client.log('file/uploadImage', formData);
 
   if (!formData.getAll('files').length)
     throw new Error('The formData object must have a `files` key.');
@@ -58,5 +58,3 @@ export const createImage = async (
   };
 };
 /* end_public_function */
-
-// TODO: consider doing local creation with URL.createObjectURL()

package/src/fileRepository/api/{createVideo.ts → uploadVideo.ts}

@@ -7,8 +7,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 */
 /**
  * ```js
- * import { createVideo } from '@amityco/ts-sdk'
- * const created = await createVideo(formData)
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const created = await FileRepository.uploadVideo(formData)
  * ```
  *
  * Creates an {@link Amity.File<'video'>}
@@ -16,18 +16,18 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * @param formData The data necessary to create a new {@link Amity.File<'video'>}
  * @param feedType The {@link Amity.File<'video'>} feed type
  * @param onProgress The callback to track the upload progress
- * @returns The newly created {@link Amity.File<'video'>}
+ * @returns The newly uploaded {@link Amity.File<'video'>}
  *
  * @category File API
  * @async
  */
-export const createVideo = async (
+export const uploadVideo = async (
   formData: FormData,
   feedType?: Amity.ContentFeedType,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File<'video'>[]>> => {
   const client = getActiveClient();
-  client.log('file/createVideo', formData);
+  client.log('file/uploadVideo', formData);
 
   if (!formData.getAll('files').length)
     throw new Error('The formData object must have a `files` key.');
@@ -64,5 +64,3 @@ export const createVideo = async (
   };
 };
 /* end_public_function */
-
-// TODO: consider doing local creation with URL.createObjectURL()

package/src/messageRepository/api/editMessage.ts

@@ -0,0 +1,100 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+
+import { convertParams, prepareMessagePayload } from '../utils';
+
+/* begin_public_function
+  id: message.edit
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const updated = await MessageRepository.editMessage(messageId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message}
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ * @async
+ */
+export const editMessage = async (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('message/editMessage', patch);
+
+  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 });
+
+  const { messages } = data;
+
+  fireEvent('local.message.updated', { messages });
+
+  return {
+    data: messages.find(message => message.messageId === messageId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { editMessage } from '@amityco/ts-sdk'
+ * const updated = editMessage.optimistically('foobar', {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message} in cache
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ */
+editMessage.optimistically = (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('message/editMessage.optimistically', patch);
+
+  if (!client.cache) return;
+
+  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+
+  if (!message) return;
+
+  const cachedAt = -1;
+  const edited: Amity.Message = {
+    ...message.data,
+    ...patch,
+    updatedAt: new Date().toISOString(),
+  };
+
+  upsertInCache(['message', 'get', messageId], edited, { cachedAt });
+  fireEvent('local.message.updated', { messages: [edited] });
+
+  return {
+    data: edited,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/messageRepository/api/flagMessage.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { prepareMessagePayload } from '~/messageRepository/utils';
+
+/* begin_public_function
+  id: message.flag
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const flagged = await MessageRepository.flagMessage(messageId)
+ * ```
+ *
+ * @param messageId of the message to flag
+ * @returns the created report result
+ *
+ * @category Message API
+ * @async
+ * */
+export const flagMessage = async (messageId: Amity.Message['messageId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('message/flag', messageId);
+
+  const { data: payload } = await client.http.post<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(messageId)}/flags`,
+  );
+
+  if (client.cache) {
+    const messagePayload = await prepareMessagePayload(payload);
+    ingestInCache(messagePayload);
+  }
+
+  fireEvent('message.flagged', payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/messageRepository/api/index.ts

@@ -2,7 +2,13 @@ export { getMessages as getMessageByIds } from './getMessages';
 
 export * from './createMessage';
 export * from './updateMessage';
-export * from './deleteMessage';
+export * from './editMessage';
+export * from './softDeleteMessage';
+
 export * from './markAsDelivered';
 export * from './getReadUsers';
 export * from './getDeliveredUsers';
+
+export * from './flagMessage';
+export * from './unflagMessage';
+export * from './isMessageFlaggedByMe';

package/src/messageRepository/api/isMessageFlaggedByMe.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+/* begin_public_function
+  id: message.check_flag_by_me
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const isReportedByMe = await MessageRepository.isMessageFlaggedByMe(messageId)
+ * ```
+ *
+ * @param messageId of the message to check a report of.
+ * @returns `true` if the report is created by me, `false` if doesn't.
+ *
+ * @category Report API
+ * @async
+ * */
+export const isMessageFlaggedByMe = async (
+  messageId: Amity.Message['messageId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('message/isMessageFlaggedByMe', messageId);
+
+  const { data } = await client.http.get<{ result: boolean }>(
+    `/api/v5/messages/${encodeURIComponent(messageId)}/flags`,
+  );
+
+  return data.result;
+};
+/* end_public_function */

package/src/messageRepository/api/{deleteMessage.ts → softDeleteMessage.ts}

@@ -9,8 +9,8 @@ import { getMessage } from './getMessage';
 */
 /**
  * ```js
- * import { deleteMessage } from '@amityco/ts-sdk'
- * const success = await deleteMessage('foobar')
+ * import { softDeleteMessage } from '@amityco/ts-sdk'
+ * const success = await softDeleteMessage('foobar')
  * ```
  *
  * Delete a {@link Amity.Message}
@@ -21,11 +21,11 @@ import { getMessage } from './getMessage';
  * @category Message API
  * @async
  */
-export const deleteMessage = async (
+export const softDeleteMessage = async (
   messageId: Amity.Message['messageId'],
 ): Promise<Amity.Message> => {
   const client = getActiveClient();
-  client.log('message/deleteMessage', messageId);
+  client.log('message/softDeleteMessage', messageId);
 
   // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(
@@ -41,8 +41,8 @@ export const deleteMessage = async (
 
 /**
  * ```js
- * import { deleteMessage } from '@amityco/ts-sdk'
- * const success = deleteMessage.optimistically('foobar')
+ * import { softDeleteMessage } from '@amityco/ts-sdk'
+ * const success = softDeleteMessage.optimistically('foobar')
  * ```
  *
  * Deletes a {@link Amity.Message}
@@ -52,11 +52,11 @@ export const deleteMessage = async (
  *
  * @category Message API
  */
-deleteMessage.optimistically = (
+softDeleteMessage.optimistically = (
   messageId: Amity.Message['messageId'],
 ): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient();
-  client.log('message/deleteMessage.optimistically', messageId);
+  client.log('message/softDeleteMessage.optimistically', messageId);
 
   const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
 

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

@@ -2,7 +2,7 @@ import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 import { client, generateRawMessage } from '~/utils/tests';
 
-import { deleteMessage } from '../deleteMessage';
+import { softDeleteMessage } from '../softDeleteMessage';
 import { onMessageDeleted } from '../../events';
 import { convertFromRaw } from '../../utils';
 
@@ -20,13 +20,13 @@ const getResolvedMessageValue = () => ({
   },
 });
 
-describe('deleteMessage', () => {
+describe('softDeleteMessage', () => {
   // integration_test_id: 16106137-0e4a-4d2f-b8cf-1a6c571bf0c7
   test('should return deleted message', async () => {
     client.http.delete = jest.fn();
     client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
 
-    await expect(deleteMessage(deleteId)).resolves.toEqual(deletedMessage);
+    await expect(softDeleteMessage(deleteId)).resolves.toEqual(deletedMessage);
   });
 
   // integration_test_id: 27d393d9-480e-4eec-bfdb-f04738801b04
@@ -37,7 +37,7 @@ describe('deleteMessage', () => {
         new ASCApiError('not found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
       );
 
-    await expect(deleteMessage(deleteId)).rejects.toThrow('400400');
+    await expect(softDeleteMessage(deleteId)).rejects.toThrow('400400');
   });
 
   test('should update cache after deleted messages', async () => {
@@ -46,7 +46,7 @@ describe('deleteMessage', () => {
     client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
     pushToCache(['message', 'get', deleteId], messageToDelete);
 
-    await deleteMessage(deleteId);
+    await softDeleteMessage(deleteId);
     const recieved = pullFromCache<Amity.Message>(['message', 'get', deleteId])?.data;
 
     expect(recieved).toEqual(deletedMessage);
@@ -63,20 +63,20 @@ describe('deleteMessage', () => {
       dispose = onMessageDeleted(resolve);
     }).finally(dispose);
 
-    await deleteMessage(deleteId);
+    await softDeleteMessage(deleteId);
 
     await expect(callbackPromise).resolves.toEqual(deletedMessage);
   });
 });
 
-describe('deleteMessage.optimistically', () => {
+describe('softDeleteMessage.optimistically', () => {
   beforeEach(() => enableCache());
   afterEach(() => disableCache());
 
   test('should update `isDeleted` in cache after deleted message', () => {
     pushToCache(['message', 'get', deleteId], messageToDelete);
 
-    deleteMessage.optimistically(deleteId);
+    softDeleteMessage.optimistically(deleteId);
     const recieved = pullFromCache<Amity.Message>(['message', 'get', deleteId])?.data;
 
     expect(recieved).toEqual({
@@ -91,7 +91,7 @@ describe('deleteMessage.optimistically', () => {
     pushToCache(['channel', 'get', channelId], { channelId, messageCount: 2 });
     pushToCache(['message', 'get', deleteId], { ...messageToDelete, channelId });
 
-    deleteMessage.optimistically(deleteId);
+    softDeleteMessage.optimistically(deleteId);
     const recieved = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
 
     expect(recieved?.messageCount).toBe(1);
@@ -107,7 +107,7 @@ describe('deleteMessage.optimistically', () => {
       });
     }).finally(dispose);
 
-    await deleteMessage.optimistically(deleteId);
+    softDeleteMessage.optimistically(deleteId);
 
     await expect(callbackPromise).resolves.toEqual({
       ...deletedMessage,
@@ -118,6 +118,6 @@ describe('deleteMessage.optimistically', () => {
   test('should define object as unsynced object', () => {
     pushToCache(['message', 'get', deleteId], messageToDelete);
 
-    expect(deleteMessage.optimistically(deleteId)?.cachedAt).toBe(-1);
+    expect(softDeleteMessage.optimistically(deleteId)?.cachedAt).toBe(-1);
   });
 });