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

package/src/core/model/index.ts

@@ -33,8 +33,17 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
 };
 
 /** hidden */
-export const hasUpdates = (prevData: Amity.UpdatedAt, nextData: Amity.UpdatedAt): boolean => {
-  return new Date(prevData.updatedAt!) < new Date(nextData.updatedAt!);
+export const hasUpdates = <T extends Amity.Model>(prevData: T, nextData: T): boolean => {
+  if ('updatedAt' in prevData && 'updatedAt' in nextData) {
+    return new Date(prevData.updatedAt!) < new Date(nextData.updatedAt!);
+  }
+
+  /*
+   * hasUpdates is used to identify the latest object among many. If the object
+   * does not extend ${Amity.UpdatedAt}, then there is no way to differentiate.
+   * So it is considered by default that the object hasUpdates
+   */
+  return true;
 };
 
 /** hidden */

package/src/follow/api/getFollowInfo.ts

@@ -1,12 +1,6 @@
 import { getActiveClient } from '~/client/api';
 import { pullFromCache, pushToCache } from '~/cache/api';
 
-const getCacheKey = (userId: Amity.User['userId']) => [
-  'followInfo',
-  'get',
-  `${getActiveClient().userId}#${userId}`,
-];
-
 /* begin_public_function
   id: user.relationship.get_follow_info, user.relationship.get_my_follow_info
 */
@@ -44,7 +38,9 @@ export const getFollowInfo = async (
       : data.followCounts[0];
 
   if (client.cache) {
-    pushToCache(getCacheKey(userId), followInfo, { cachedAt });
+    pushToCache(['followInfo', 'get', userId], followInfo, {
+      cachedAt,
+    });
   }
 
   return {
@@ -77,7 +73,7 @@ getFollowInfo.locally = (
     return;
   }
 
-  const cached = pullFromCache<Amity.FollowInfo>(getCacheKey(userId));
+  const cached = pullFromCache<Amity.FollowInfo>(['followInfo', 'get', userId]);
 
   if (!cached) {
     return;

package/src/follow/observers/index.ts

@@ -4,3 +4,4 @@ export * from './observeFollowings';
 
 export * from './liveFollowers';
 export * from './liveFollowings';
+export * from './liveFollowInfo';

package/src/follow/observers/liveFollowInfo.ts

@@ -0,0 +1,29 @@
+import { liveObject } from '~/utils/liveObject';
+import { getFollowInfo } from '../api';
+import { onFollowInfoUpdated } from '../events';
+
+/**
+ * ```js
+ * import { liveFollowInfo } from '@amityco/ts-sdk';
+ *
+ * let followInfo;
+ *
+ * const unsubscribe = liveFollowInfo(userId, response => {
+ *   followInfo = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.FollowCount} object
+ *
+ * @param userId the ID of the current user
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing
+ *
+ * @category FollowInfo Live Object
+ */
+export const liveFollowInfo = (
+  userId: Amity.FollowInfo['userId'],
+  callback: Amity.LiveObjectCallback<Amity.FollowInfo>,
+): Amity.Unsubscriber => {
+  return liveObject(userId, callback, 'userId', getFollowInfo, [onFollowInfoUpdated]);
+};

package/src/follow/observers/tests/liveFollowInfo.test.ts

@@ -0,0 +1,198 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  follow21,
+  follow11,
+  user11,
+  pause,
+  date,
+} from '~/utils/tests';
+
+import { liveFollowInfo } from '../liveFollowInfo';
+
+const FOLLOWING_COUNT = 2;
+const getFollowInfoMePayload = ({
+  userId = user11.userId,
+  followerCount = 0,
+  pendingCount = 0,
+  followingCount = FOLLOWING_COUNT,
+} = {}): Amity.FollowInfoMePayload => {
+  return {
+    followCounts: [
+      {
+        userId,
+        followerCount,
+        pendingCount,
+        followingCount,
+      },
+    ],
+  };
+};
+
+const getFollowMeStatusPayload = (
+  status: Amity.FollowStatus['status'] = follow11.status,
+): Amity.FollowStatusPayload => {
+  return {
+    follows: [
+      {
+        from: follow11.from,
+        to: follow11.to,
+        status,
+        createdAt: date,
+        updatedAt: date,
+      },
+    ],
+  };
+};
+
+const getFollowStatusPayload = (
+  status: Amity.FollowStatus['status'] = follow21.status,
+): Amity.FollowStatusPayload => {
+  return {
+    follows: [
+      {
+        from: follow21.from,
+        to: follow21.to,
+        status,
+        createdAt: date,
+        updatedAt: date,
+      },
+    ],
+  };
+};
+
+describe('liveFollowInfo > me', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const tests: [
+    string,
+    keyof Amity.MqttFollowEvents,
+    Amity.FollowStatusPayload,
+    Amity.FollowInfoMePayload,
+  ][] = [
+    [
+      'it should update follow info collection on accepted',
+      'follow.accepted',
+      getFollowMeStatusPayload('accepted'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT + 1 }),
+    ],
+    [
+      'it should update follow info collection on unfollowed',
+      'follow.unfollowed',
+      getFollowMeStatusPayload('none'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+    [
+      'it should update follow info collection on requestDeclined',
+      'follow.requestDeclined',
+      getFollowMeStatusPayload('none'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT }),
+    ],
+    [
+      'it should update follow info collection on followerDeleted',
+      'follow.followerDeleted',
+      getFollowMeStatusPayload('none'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+  ];
+
+  test.each(tests)('%s', async (description, event, payload, payloadFrom) => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue({ data: getFollowInfoMePayload() })
+      .mockResolvedValueOnce({ data: payloadFrom })
+      .mockResolvedValueOnce({ data: payloadFrom });
+
+    const unsub = liveFollowInfo(user11.userId, callback);
+    await pause();
+
+    client.emitter.emit(event, payload);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: payloadFrom.followCounts[0],
+        loading: false,
+      }),
+    );
+
+    unsub();
+  });
+});
+
+describe('liveFollowInfo > other', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const tests: [
+    string,
+    keyof Amity.MqttFollowEvents,
+    Amity.FollowStatusPayload,
+    Amity.FollowInfoMePayload,
+  ][] = [
+    [
+      'it should update follow info collection on accepted',
+      'follow.accepted',
+      getFollowStatusPayload('accepted'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT + 1 }),
+    ],
+    [
+      'it should update follow info collection on unfollowed',
+      'follow.unfollowed',
+      getFollowStatusPayload('none'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+    [
+      'it should update follow info collection on requestDeclined',
+      'follow.requestDeclined',
+      getFollowStatusPayload('none'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT }),
+    ],
+    [
+      'it should update follow info collection on followerDeleted',
+      'follow.followerDeleted',
+      getFollowStatusPayload('none'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+  ];
+
+  test.each(tests)('%s', async (description, event, payload, payloadFrom) => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue({ data: getFollowInfoMePayload({ userId: follow21.from }) })
+      .mockResolvedValueOnce({ data: payloadFrom })
+      .mockResolvedValueOnce({ data: payloadFrom });
+
+    const unsub = liveFollowInfo(follow21.from, callback);
+    await pause();
+
+    client.emitter.emit(event, payload);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: payloadFrom.followCounts[0],
+        loading: false,
+      }),
+    );
+
+    unsub();
+  });
+});

package/src/message/api/createMessage.ts

@@ -44,12 +44,23 @@ export const createMessage = async <T extends Amity.MessageContentType>(
   > & {
     data?: Amity.Message<T>['data'];
     fileId?: Amity.File['fileId'];
+    // Custom referenceId is a workaround for the case:
+    // User wants to create an image message. He should
+    // - create and show dummy message in ui
+    // - upload image to get fileId, while uploading show a spinner in dummy message in ui
+    // - call createMessage and pass fileId
+    // - replace dummy message with the actual message received from backend
+    // Custom referenceId is needed to make relation between dummy message and actual message.
+    // TODO: passing file src into createMessage so that sdk uploads files itself,
+    // returns the dummy message bound with the file to eliminate the need to create
+    // the dummy message on the user side,
+    referenceId?: string;
   },
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
   client.log('message/createMessage', bundle);
 
-  const referenceId = uniqueId || getLocalId();
+  const referenceId = bundle.referenceId || uniqueId || getLocalId();
   uniqueId = undefined;
 
   const { data: payload } = await client.http.post<Amity.MessagePayload>('/api/v5/messages', {
@@ -91,9 +102,10 @@ export const createMessage = async <T extends Amity.MessageContentType>(
  *
  * @category Message API
  */
-createMessage.optimistically = (
-  bundle: Parameters<typeof createMessage>[0],
-): Amity.Cached<Amity.Message> | undefined => {
+createMessage.optimistically = ({
+  referenceId,
+  ...bundle
+}: Parameters<typeof createMessage>[0]): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient();
 
   if (!client.cache) return;
@@ -105,7 +117,7 @@ createMessage.optimistically = (
    * Updated to handle client requirement to add messageId while uploading
    * message with image. Temporary!
    */
-  uniqueId = getLocalId();
+  uniqueId = referenceId || getLocalId();
   const bundleWithMessageId = { messageId: uniqueId, uniqueId, ...bundle };
 
   client.log('message/createMessage.optimistically', bundleWithMessageId);

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

@@ -1,3 +1,4 @@
+import { ASCApiError } from '~/core/errors';
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 
@@ -28,6 +29,7 @@ describe('createMessage', () => {
 
   afterEach(disableCache);
 
+  // integration_test_id: 9691969d-6ba8-4af6-93d6-dfe9134e9796
   test('should return created message', async () => {
     client.http.post = jest.fn().mockResolvedValue(response);
 
@@ -37,10 +39,15 @@ describe('createMessage', () => {
     expect(created.uniqueId).toBeDefined();
   });
 
-  test('should throw an error if request fails', async () => {
-    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+  // integration_test_id: acc3be84-9234-4af1-88a1-cbb517fa247f
+  test('should throw an 404300 if user has no permission', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('forbidden', Amity.ServerError.FORBIDDEN, Amity.ErrorLevel.ERROR),
+      );
 
-    await expect(createMessage(messageWithoutId)).rejects.toThrow('error');
+    await expect(createMessage(messageWithoutId)).rejects.toThrow('400300');
   });
 
   test('should put message into cache', async () => {
@@ -141,9 +148,9 @@ describe('uniqueId / referenceId', () => {
     subChannelId: messageToCreate.subChannelId,
   };
 
-  beforeAll(enableCache);
+  beforeEach(enableCache);
 
-  afterAll(disableCache);
+  afterEach(disableCache);
 
   it('should optimistically create message with uniqueId', () => {
     const { data: message } = createMessage.optimistically(bundle)!;
@@ -208,4 +215,28 @@ describe('uniqueId / referenceId', () => {
       }),
     );
   });
+
+  describe('custom referenceId', () => {
+    it('should handle custom referenceId for optimistic message', () => {
+      const referenceId = 'custom-reference-id';
+
+      const { data: message } = createMessage.optimistically({ ...bundle, referenceId })!;
+
+      expect(message.uniqueId).toEqual(referenceId);
+    });
+
+    it('should handle custom referenceId if cache is turned off', async () => {
+      disableCache();
+      const referenceId = 'custom-reference-id';
+      client.http.post = jest.fn().mockResolvedValue({ data: { messages: [rawMessageToCreate] } });
+
+      runQuery(createQuery(createMessage, { ...bundle, referenceId }));
+      await pause();
+
+      expect(client.http.post).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({ referenceId }),
+      );
+    });
+  });
 });

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

@@ -1,3 +1,4 @@
+import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 import { client, generateRawMessage } from '~/utils/tests';
 
@@ -20,6 +21,7 @@ const getResolvedMessageValue = () => ({
 });
 
 describe('deleteMessage', () => {
+  // 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());
@@ -27,10 +29,15 @@ describe('deleteMessage', () => {
     await expect(deleteMessage(deleteId)).resolves.toEqual(deletedMessage);
   });
 
-  test('should throw an error if request fails', async () => {
-    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+  // integration_test_id: 27d393d9-480e-4eec-bfdb-f04738801b04
+  test('should return 400400 if message not found', async () => {
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
 
-    await expect(deleteMessage(deleteId)).rejects.toThrow('error');
+    await expect(deleteMessage(deleteId)).rejects.toThrow('400400');
   });
 
   test('should update cache after deleted messages', async () => {

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

@@ -21,6 +21,7 @@ const getResolvedMessageValue = () => ({
 });
 
 describe('getMessage', () => {
+  // integration_test_id: bc048747-17ea-43fe-9f97-7b2bf008c476
   test('should return fetched message', async () => {
     client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
 
@@ -41,10 +42,15 @@ describe('getMessage', () => {
     disableCache();
   });
 
-  test('should throw an error if request fails', async () => {
-    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+  // integration_test_id: 81375153-2886-46e0-a164-7f3902e77b55
+  test('should return 400300 if unauthorized', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('forbidden', Amity.ServerError.FORBIDDEN, Amity.ErrorLevel.ERROR),
+      );
 
-    await expect(getMessage(messageId)).rejects.toThrow('error');
+    await expect(getMessage(messageId)).rejects.toThrow('400300');
   });
 
   test('should fire event `onMessageFetched`', async () => {

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

@@ -74,6 +74,36 @@ describe('queryMessages', () => {
     await queryMessages(queryCriteria);
     await expect(callbackPromise).resolves.toEqual(messagesToQuery[0]);
   });
+
+  test('it should set isDeleted to undefined if includeDeleted is true', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages({ ...queryCriteriaWithoutPage, includeDeleted: true });
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBeUndefined();
+  });
+
+  test('it should set isDeleted to false if includeDeleted is false', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages({ ...queryCriteriaWithoutPage, includeDeleted: false });
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBe(false);
+  });
+
+  test('it should set isDeleted to undefined if includeDeleted is undefined', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages(queryCriteriaWithoutPage);
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBeUndefined();
+  });
 });
 
 describe('queryMessages.locally', () => {

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

@@ -1,3 +1,4 @@
+import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 import { client, generateRawMessage } from '~/utils/tests';
 
@@ -21,6 +22,7 @@ const getResolvedMessageValue = () => ({
 });
 
 describe('updateMessage', () => {
+  // integration_test_id: 3ae17ea2-dee5-4418-88af-fe809ee48a52
   test('should return updated message', async () => {
     client.http.put = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
 
@@ -29,10 +31,15 @@ describe('updateMessage', () => {
     await expect(recieved).resolves.toEqual(expect.objectContaining({ data: updatedMessage }));
   });
 
+  // integration_test_id: 3ae17ea2-dee5-4418-88af-fe809ee48a52
   test('should throw an error if request fails', async () => {
-    client.http.put = jest.fn().mockRejectedValueOnce(new Error('error'));
+    client.http.put = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
 
-    await expect(updateMessage(messageId, patch)).rejects.toThrow('error');
+    await expect(updateMessage(messageId, patch)).rejects.toThrow('400400');
   });
 
   test('should update cache after updated messages', async () => {

package/src/message/observers/liveMessages.ts

@@ -1,8 +1,8 @@
 /* eslint-disable no-use-before-define */
 import { getResolver } from '~/core/model';
 import { getActiveClient } from '~/client/api';
-import { pushToCache, pullFromCache } from '~/cache/api';
-import { createQuery, runQuery, queryOptions, filterByPropEquality } from '~/core/query';
+import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
+import { createQuery, filterByPropEquality, queryOptions, runQuery } from '~/core/query';
 
 import {
   COLLECTION_DEFAULT_CACHING_POLICY,
@@ -10,15 +10,16 @@ import {
   ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
 
+import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
 import {
   onMessageCreated,
   onMessageDeleted,
-  onMessageUpdated,
-  onMessageFlagged,
-  onMessageUnflagged,
   onMessageFlagCleared,
+  onMessageFlagged,
   onMessageReactionAdded,
   onMessageReactionRemoved,
+  onMessageUnflagged,
+  onMessageUpdated,
 } from '../events';
 import { onMessageFetched } from '../events/onMessageFetched';
 import { queryMessages } from '../api';
@@ -73,9 +74,11 @@ export const liveMessages = (
 
     /*
      * for cases when message is deleted via RTE, this flag is used to get
-     * items fro cache that are deleted | !deleted
+     * items from cache that are !deleted
      */
-    messages = filterByPropEquality(messages, 'isDeleted', params.isDeleted);
+    if (params.includeDeleted === false) {
+      messages = filterByPropEquality(messages, 'isDeleted', false);
+    }
 
     callback({
       onNextPage: onFetch,
@@ -86,16 +89,12 @@ export const liveMessages = (
     });
   };
 
-  const realtimeRouter = (action: Amity.MessageActionType) => (message: Amity.Message) => {
+  const realtimeRouter = (_: Amity.MessageActionType) => (message: Amity.Message) => {
     const collection = pullFromCache<Amity.MessageLiveCollectionCache>(cacheKey)?.data;
 
-    if (params.subChannelId !== message.subChannelId || !collection) return;
+    if (params.subChannelId !== message?.subChannelId || !collection) return;
 
-    if (action === 'onCreate') {
-      collection.data = [...new Set([message.messageId, ...collection.data])];
-    } else if (['onDelete'].includes(action)) {
-      collection.data = collection.data.filter(m => m !== message.messageId);
-    }
+    collection.data = [...new Set([message.messageId, ...collection.data])];
 
     pushToCache(cacheKey, collection);
 
@@ -132,7 +131,7 @@ export const liveMessages = (
 
         responder(data);
       },
-      queryOptions(policy),
+      queryOptions(policy, CACHE_SHORTEN_LIFESPAN),
     );
   };
 
@@ -153,5 +152,6 @@ export const liveMessages = (
   return () => {
     log(`liveMessages(tmpid: ${timestamp}) > dispose`);
     disposers.forEach(fn => fn());
+    dropFromCache(cacheKey);
   };
 };

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

@@ -146,7 +146,7 @@ describe('liveMessages', () => {
       },
     });
 
-    liveMessages({ subChannelId, isDeleted: false }, callback);
+    liveMessages({ subChannelId, includeDeleted: false }, callback);
 
     expect(callback).toHaveBeenCalledTimes(1);
 
@@ -351,7 +351,7 @@ describe('liveMessages', () => {
     expect(callback).toHaveBeenNthCalledWith(
       3,
       expect.objectContaining({
-        data: [],
+        data: [message],
         error: undefined,
         loading: false,
       }),

package/src/message/utils/index.ts

@@ -89,8 +89,15 @@ export const convertResponseFromRaw = <T extends Amity.MessagePayload>(
   };
 };
 
-type RawQueryMessages = Omit<Amity.QueryMessages, 'page' | 'sortBy' | 'subChannelId' | 'tags'> & {
+type RawQueryMessages = Omit<
+  Amity.QueryMessages,
+  /*
+   * include deleted is for internal sdk use only. The server expects isDeleted
+   */
+  'page' | 'sortBy' | 'subChannelId' | 'tags' | 'includeDeleted'
+> & {
   includeTags?: Amity.QueryMessages['tags'];
+  isDeleted?: Amity.Message['isDeleted'];
   messageFeedId: Amity.QueryMessages['subChannelId'];
   options: {
     sortBy?: Amity.QueryMessages['sortBy'];
@@ -111,11 +118,13 @@ export function convertQueryParams({
   sortBy,
   subChannelId,
   tags,
+  includeDeleted,
   ...rest
 }: Amity.QueryMessages): RawQueryMessages {
   const out: RawQueryMessages = {
     ...rest,
     messageFeedId: subChannelId,
+    isDeleted: includeDeleted === false ? false : undefined,
     options: { token: toToken(page || { limit: 10 }, 'afterbeforeraw')! },
   };
 

package/src/post/api/queryPosts.ts

@@ -30,7 +30,7 @@ export const queryPosts = async (
   const client = getActiveClient();
   client.log('post/queryPosts', query);
 
-  const { page = { limit: 10 }, ...params } = query;
+  const { page = { limit: 10 }, includeDeleted, ...params } = query;
   const { dataTypes, matchingOnlyParentPost } = params;
 
   // API-FIX: parameters should be querystring. (1)
@@ -39,6 +39,7 @@ export const queryPosts = async (
   const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(`/api/v4/posts`, {
     params: {
       ...params,
+      isDeleted: includeDeleted === false ? false : undefined,
       /*
        * when creating post like image, file, video BE will create 2 posts
        * 1. parent post to store text with dataType=text