@amityco/ts-sdk 0.0.1-beta.37 → 0.0.1-beta.39

package/src/channel/api/tests/createChannel.test.ts

@@ -1,20 +1,44 @@
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
-import { channelPayload, client } from '~/utils/tests';
+import {
+  channelPayload,
+  client,
+  conversationChannelPayload,
+  liveChannelPayload,
+} from '~/utils/tests';
 import { prepareChannelPayload } from '~/channel/utils';
 import { createChannel } from '../createChannel';
 
 const resPayload = { data: channelPayload };
 
 describe('createChannel', () => {
-  const channel = prepareChannelPayload(channelPayload).channels[0];
-
-  test('it should create a channel', async () => {
+  // integration_test_id: 9d80fd54-9e6d-454d-8344-6f9436b8e495
+  test('it should create a channel for community', async () => {
     client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
 
     const res = await createChannel({ type: 'community' });
 
     expect(res).toBeDefined();
-    expect(res.data).toStrictEqual(channel);
+    expect(res.data).toStrictEqual(prepareChannelPayload(channelPayload).channels[0]);
+  });
+
+  // integration_test_id: cef520ab-027d-4c5b-836c-a7f63ddc5146
+  test('it should create a channel for live', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: liveChannelPayload });
+
+    const res = await createChannel({ type: 'live' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(prepareChannelPayload(liveChannelPayload).channels[0]);
+  });
+
+  // integration_test_id: 11a43612-ff6f-4262-874c-4419d342cff1
+  test('it should create a channel for conversation', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: conversationChannelPayload });
+
+    const res = await createChannel({ type: 'conversation' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(prepareChannelPayload(conversationChannelPayload).channels[0]);
   });
 
   test('it should add channel to cache', async () => {
@@ -27,7 +51,7 @@ describe('createChannel', () => {
     const data = pullFromCache(['channel', 'get', channelId]);
 
     expect(data).toBeDefined();
-    expect(data?.data).toStrictEqual(channel);
+    expect(data?.data).toStrictEqual(prepareChannelPayload(channelPayload).channels[0]);
 
     disableCache();
   });

package/src/channel/api/tests/getChannel.test.ts

@@ -12,7 +12,8 @@ const { channelId } = channelQueryResponse.data.channels[0];
 const channel = prepareChannelPayload(channelQueryResponse.data).channels[0];
 
 describe('getChannel', () => {
-  test('it should return a channel', async () => {
+  // integration_test_id: b331e01c-20db-4f17-979b-b280d8818792
+  test('it should return a valid channel', async () => {
     client.http.get = jest.fn().mockResolvedValueOnce(channelQueryResponse);
 
     const expected = channel;
@@ -31,6 +32,7 @@ describe('getChannel', () => {
     disableCache();
   });
 
+  // integration_test_id: da9dc3e8-01fd-4e76-a26b-ac8333a69b23
   test('it should return an error', async () => {
     client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
 

package/src/channel/api/tests/getChannels.test.ts

@@ -0,0 +1,97 @@
+import { disableCache, enableCache, pushToCache, pullFromCache } from '~/cache/api';
+import { client, getChannelsResponse } from '~/utils/tests';
+
+import { getChannels } from '../getChannels';
+import { prepareChannelPayload } from '~/channel/utils';
+import { ASCApiError } from '~/core/errors';
+
+const channelIds = [
+  getChannelsResponse.data.channels[0].channelId,
+  getChannelsResponse.data.channels[1].channelId,
+  getChannelsResponse.data.channels[2].channelId,
+];
+const channel = prepareChannelPayload(getChannelsResponse.data).channels;
+
+describe('getChannels', () => {
+  // integration_test_id: ced0cd3b-1714-499d-862e-0284da1c8bb1
+  test('it should return a valid channels', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(getChannelsResponse);
+
+    const expected = channel;
+    const { data: received } = await getChannels(channelIds);
+
+    expect(received).toStrictEqual(expected);
+  });
+
+  test('it should update cache after fetch from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(getChannelsResponse);
+    await getChannels(channelIds);
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+
+    disableCache();
+  });
+
+  // integration_test_id: 344a8f3d-0e54-4eb9-850f-80283e638352
+  test('it should return an error 400400 when try to get channels by invalid channel id', async () => {
+    const error = new ASCApiError(
+      'Some channel not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValueOnce(error);
+
+    await expect(getChannels(channelIds)).rejects.toThrow(error);
+  });
+});
+
+describe('getChannels locally', () => {
+  test('it should return data from cache', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelIds[0]], channel[0], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[1]], channel[1], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[2]], channel[2], { cachedAt });
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+
+  test('should return undefined if channel not in cache', () => {
+    expect(
+      getChannels.locally(['non-existent-channel-1', 'non-existent-channel-2']),
+    ).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    expect(getChannels.locally(channelIds)).toBeUndefined();
+  });
+
+  test('it should return cachedAt same date with oldest record', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelIds[0]], channel[0], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[1]], channel[1], { cachedAt: cachedAt + 1 });
+    pushToCache(['channel', 'get', channelIds[2]], channel[2], { cachedAt: cachedAt + 2 });
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+});

package/src/channel/api/tests/joinChannel.test.ts

@@ -1,4 +1,5 @@
 import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
 import { getResolver } from '~/core/model';
 
 import {
@@ -19,6 +20,7 @@ describe('joinChannel', () => {
 
   const { channelId } = channel1;
 
+  // integration_test_id: efef33a8-bf09-4dfe-8ed9-e7c3615ad74d
   test('it should return channelUser', async () => {
     client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
 
@@ -44,9 +46,66 @@ describe('joinChannel', () => {
     disableCache();
   });
 
-  test('it should throw error', async () => {
-    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+  // integration_test_id: 402a8cd8-6522-42d0-8f40-ccccae0093a1
+  test('it should throw error 400400 when user joins channel which does not exist', async () => {
+    const apiError = new ASCApiError(
+      'ChannelId Not Found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
 
-    await expect(joinChannel(channelId)).rejects.toThrow('error');
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: dcad7f35-586c-400f-8eca-2334d6d7b3e0
+  test("it should throw error 400300 when user tries to join channel in which he doesn't have permission", async () => {
+    const apiError = new ASCApiError(
+      "Can't join the conversation channel",
+      Amity.ServerError.FORBIDDEN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: 8ccb81b7-a89c-486a-81ed-7371b3ef1c4f
+  test('it should throw error 400304 when user tries to join channel in which he is banned', async () => {
+    const apiError = new ASCApiError(
+      'User is banned from this channel',
+      Amity.ServerError.CHANNEL_BAN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
   });
 });

package/src/channel/api/tests/leaveChannel.test.ts

@@ -0,0 +1,90 @@
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel1,
+  user11,
+  rawChannelUser,
+  channelUserQueryResponse,
+} from '~/utils/tests';
+
+import { leaveChannel } from '../leaveChannel';
+
+describe('leaveChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const { channelId } = channel1;
+
+  // integration_test_id: 3b4408dd-0f45-4270-9384-73d9ddac4511
+  test('it should return channelUser', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await leaveChannel(channelId);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache', async () => {
+    enableCache();
+
+    const expected = rawChannelUser;
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const didleaveChannel = await leaveChannel(channelId);
+
+    const resolverId = getResolver('channelUsers')({ channelId, userId: user11.userId });
+    const recieved = pullFromCache(['channelUsers', 'get', resolverId]);
+
+    expect(didleaveChannel).toBe(true);
+    expect(recieved?.data).toStrictEqual(expected);
+
+    disableCache();
+  });
+
+  // integration_test_id: 4f56790e-5fa0-4d04-8c20-ab0c39d0776f
+  test('it should throw error 400301 when user try to leave a channel which user is not a member', async () => {
+    const apiError = new ASCApiError(
+      'User is not member of channel',
+      Amity.ServerError.PERMISSION_DENIED,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.delete = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await leaveChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: 818d2317-e138-4d66-bdc0-bcc858580df5
+  test('it should throw error 400304 when user try to leave channel which he got banned', async () => {
+    const apiError = new ASCApiError(
+      'User is banned from this channel',
+      Amity.ServerError.CHANNEL_BAN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.delete = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await leaveChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+});

package/src/channel/api/tests/queryChannels.test.ts

@@ -4,11 +4,17 @@ import { disableCache, enableCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '~/channel/utils';
-import { client, channelQueryResponse } from '~/utils/tests';
+import {
+  client,
+  channelQueryResponse,
+  channelTagQueryResponse,
+  channelExcludeTagQueryResponse,
+} from '~/utils/tests';
 
 import { queryChannels } from '../queryChannels';
 
 describe('queryChannels', () => {
+  // integration_test_id: 06c14dab-4799-4f26-9e52-be7c12b3bdb3
   test('it should return channels', async () => {
     const expected = prepareChannelPayload(channelQueryResponse.data).channels;
     client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
@@ -18,6 +24,37 @@ describe('queryChannels', () => {
     expect(data).toEqual(expected);
   });
 
+  // integration_test_id: 253fb0ac-f868-4570-9b1e-98b08861aa53
+  test('it should return channels match with membership type', async () => {
+    // Actually there is no any flag to tell about this list is relate to membership type
+    // But need to implement this case to match with our test list
+    const expected = prepareChannelPayload(channelQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+    const { data } = await queryChannels({ membership: 'member' });
+    expect(data).toEqual(expected);
+  });
+
+  // integration_test_id: 92329d41-9403-44e7-979f-ed227e6ab120
+  test('it should return channels match with tags query type', async () => {
+    const expected = prepareChannelPayload(channelTagQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelTagQueryResponse);
+    const { data } = await queryChannels({ tags: ['tag1'] });
+    expect(data).toEqual(expected);
+    expect(data[0].tags).toContain('tag1');
+  });
+
+  // integration_test_id: 5249778c-6d99-4e2f-9b80-2f4ea6ae1833
+  test('it should return channels without tags which defined in exclude options', async () => {
+    const expected = prepareChannelPayload(channelExcludeTagQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelExcludeTagQueryResponse);
+    const { data } = await queryChannels({ excludeTags: ['tag1'] });
+    expect(data).toEqual(expected);
+
+    data.forEach(item => {
+      expect(item.tags).not.toContain('tag1');
+    });
+  });
+
   test('it should throw error', async () => {
     client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
 

package/src/channel/observers/liveChannel.ts

@@ -1,12 +1,4 @@
-import { ASCApiError } from '~/core/errors';
-import { getActiveClient } from '~/client/api';
-import { createQuery, runQuery } from '~/core/query';
-import {
-  LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
-  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
-  UNSYNCED_OBJECT_CACHED_AT_VALUE,
-} from '~/utils/constants';
-import { hasUpdates } from '~/core/model';
+import { liveObject } from '~/utils/liveObject';
 import { onMessageCreated } from '~/message/events';
 import { getChannel } from '../api';
 import { onChannelDeleted, onChannelJoined, onChannelMuted, onChannelUpdated } from '../events';
@@ -34,75 +26,11 @@ export const liveChannel = (
   channelId: Amity.Channel['channelId'],
   callback: Amity.LiveObjectCallback<Amity.Channel>,
 ): Amity.Unsubscriber => {
-  const { log, cache } = getActiveClient();
-  const timestamp = Date.now();
-  log(`liveChannel(tmpid: ${timestamp}) > listen`);
-
-  if (!cache) {
-    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-  }
-
-  let channel: Amity.Channel;
-  let isUnsyncedObject = false;
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const dispatcher = (data: Amity.LiveObject<Amity.Channel>) => {
-    channel = data.data;
-    callback(data);
-  };
-
-  const realtimeRouter = (eventChannel: Amity.Channel) => {
-    if (channelId !== eventChannel.channelId) {
-      return;
-    }
-
-    if (channel && !hasUpdates(channel, eventChannel)) {
-      return;
-    }
-
-    dispatcher({ loading: false, data: eventChannel, origin: 'event' });
-  };
-
-  const onFetch = () => {
-    const query = createQuery(getChannel, channelId);
-
-    runQuery(query, ({ loading, data, error, origin, cachedAt }) => {
-      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
-        dispatcher({
-          data,
-          origin,
-          loading: false,
-          error: new ASCApiError(
-            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
-            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
-            Amity.ErrorLevel.ERROR,
-          ),
-        });
-
-        isUnsyncedObject = true;
-        disposers.forEach(fn => fn());
-      } else if (!isUnsyncedObject) {
-        dispatcher({ loading, data, origin, error });
-      }
-
-      if (error) {
-        disposers.forEach(fn => fn());
-      }
-    });
-  };
-
-  disposers.push(
-    onChannelUpdated(realtimeRouter),
-    onChannelDeleted(realtimeRouter),
-    onChannelJoined(realtimeRouter),
-    onChannelMuted(realtimeRouter),
-    onMessageCreated(() => null), // watch unread count
-  );
-
-  onFetch();
-
-  return () => {
-    log(`liveChannel(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
+  return liveObject(channelId, callback, 'channelId', getChannel, [
+    onChannelUpdated,
+    onChannelDeleted,
+    onChannelJoined,
+    onChannelMuted,
+    () => onMessageCreated(() => null), // watch unread count
+  ]);
 };

package/src/channel/observers/liveChannels.ts

@@ -10,6 +10,7 @@ import {
   filterByChannelMembership,
   sortByLastCreated,
   sortByDisplayName,
+  sortByLastActivity,
   sortByFirstCreated,
 } from '~/core/query';
 import {
@@ -97,24 +98,32 @@ export const liveChannels = (
       channels = filterByChannelMembership(channels, params.membership, userId);
     }
 
-    const sortBy = params.sortBy || 'lastCreated';
-
-    if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
-      channels = channels.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
-    }
-
-    /*
-     * The server returns channels with empty | null displayName's first before
-     * returning sorted list of channels with displayNames
-     *
-     * This section needs to be updated as displayNames can be null as well
-     */
-    if (sortBy === 'displayName') {
-      channels = channels
-        // this needs to be aligned with the backend data type
-        .map(c => (c.displayName ? c : { ...c, displayName: '' }))
-        // @ts-ignore
-        .sort(sortByDisplayName);
+    switch (params.sortBy) {
+      case 'firstCreated':
+        channels = channels.sort(sortByFirstCreated);
+        break;
+
+      case 'lastCreated':
+        channels = channels.sort(sortByLastCreated);
+        break;
+
+      case 'displayName':
+        /*
+         * The server returns channels with empty | null displayName's first before
+         * returning sorted list of channels with displayNames
+         *
+         * This section needs to be updated as displayNames can be null as well
+         */
+        channels = channels
+          // this needs to be aligned with the backend data type
+          .map(c => (c.displayName ? c : { ...c, displayName: '' }))
+          // @ts-ignore
+          .sort(sortByDisplayName);
+        break;
+
+      default:
+        channels = channels.sort(sortByLastActivity);
+        break;
     }
 
     callback({
@@ -126,15 +135,11 @@ export const liveChannels = (
     });
   };
 
-  const realtimeRouter = (action: Amity.ChannelActionType) => (channel: Amity.Channel) => {
+  const realtimeRouter = (_: Amity.ChannelActionType) => (channel: Amity.Channel) => {
     const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
     if (!collection) return;
 
-    if (action === 'onDelete' && params.isDeleted === false) {
-      collection.data = collection.data.filter(c => c !== channel.channelId);
-    } else {
-      collection.data = [...new Set([channel.channelId, ...collection.data])];
-    }
+    collection.data = [...new Set([channel.channelId, ...collection.data])];
 
     pushToCache(cacheKey, collection);
     responder(collection);

package/src/client/api/accessTokenExpiryWatcher.ts

@@ -26,10 +26,12 @@ export const isExpired = (expiresAt: Amity.Tokens['expiresAt']): boolean =>
  *
  * @category private
  */
-export const isAboutToExpire = (
-  expiresAt: Amity.Tokens['expiresAt'],
-  issuedAt: Amity.Tokens['issuedAt'],
-): boolean => {
+export const isAboutToExpire = (params: {
+  expiresAt: Amity.Tokens['expiresAt'];
+  issuedAt: Amity.Tokens['issuedAt'];
+}): boolean => {
+  const { expiresAt, issuedAt } = params;
+
   const expires = Date.parse(expiresAt);
   const issued = Date.parse(issuedAt);
   const now = Date.now();
@@ -74,7 +76,7 @@ export const accessTokenExpiryWatcher = (
       return;
     }
 
-    if (isAboutToExpire(issuedAt, expiresAt)) {
+    if (isAboutToExpire({ expiresAt, issuedAt })) {
       sessionHandler.sessionWillRenewAccessToken(renewal());
     }
   }, ACCESS_TOKEN_WATCHER_INTERVAL);

package/src/client/api/connectClient.ts

@@ -164,8 +164,6 @@ export const connectClient = async (
 
       subscriptions.forEach(fn => fn());
     }),
-
-    onUserDeleted(() => null),
   );
 
   return client.ws.connected;

package/src/client/api/tests/accessTokenExpiryWatcher.test.ts

@@ -96,19 +96,22 @@ describe('accessTokenExpiryWatcher > aboutToExpire', () => {
 
     aboutToExpireTime.setHours(aboutToExpireTime.getHours() + 1);
 
-    expect(isAboutToExpire(aboutToExpireTime.toISOString(), oldIssuedAtTime.toISOString())).toBe(
-      true,
-    );
+    expect(
+      isAboutToExpire({
+        expiresAt: aboutToExpireTime.toISOString(),
+        issuedAt: oldIssuedAtTime.toISOString(),
+      }),
+    ).toBe(true);
   });
 
   test('it should return false if token expired', () => {
-    expect(isAboutToExpire(expiresAt, issuedAt)).toBe(false);
+    expect(isAboutToExpire({ expiresAt, issuedAt })).toBe(false);
   });
 
   test('it should return false if not about to expire', () => {
     oldIssuedAtTime.setDate(oldIssuedAtTime.getDate() - 10);
 
-    expect(isAboutToExpire(expiresAt, issuedAt)).toBe(false);
+    expect(isAboutToExpire({ expiresAt, issuedAt })).toBe(false);
   });
 });
 

package/src/comment/api/deleteComment.ts

@@ -1,10 +1,12 @@
 import { getActiveClient } from '~/client/api';
 
-import { dropFromCache, upsertInCache } from '~/cache/api';
+import { upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 
-import { getComment } from './getComment';
 import { getPost } from '~/post/api/getPost';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { scheduleTask } from '~/core/microtasks';
+import { getComment } from './getComment';
 
 /**
  * ```js
@@ -49,9 +51,7 @@ export const deleteComment = async (
   fireEvent('comment.deleted', { comments: [deleted] });
 
   if (permanent) {
-    setTimeout(() => {
-      dropFromCache(['comment', 'get', commentId], true);
-    }, 0);
+    scheduleTask(() => pushToTombstone('comment', commentId));
   } else {
     upsertInCache(['comment', 'get', commentId], { isDeleted: true });
   }