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

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

@@ -106,48 +106,13 @@ describe('queryMessages', () => {
     expect(mockFn.mock.lastCall[1].params.isDeleted).toBe(false);
   });
 
-  test('it should set isDeleted to undefined if includeDeleted is undefined', async () => {
+  test('it should set isDeleted to false 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', () => {
-  beforeEach(() => enableCache());
-  afterEach(() => disableCache());
-
-  test('should return cached messages', () => {
-    messagesToQuery.forEach(message => pushToCache(['message', 'get', message.messageId], message));
-
-    pushToCache(['message', 'query', convertQueryParams(queryCriteria)], {
-      messages: messageIds,
-      paging,
-    });
-
-    expect(queryMessages.locally(queryCriteria)).toEqual(
-      expect.objectContaining({
-        data: messagesToQuery,
-        prevPage: undefined,
-        nextPage,
-      }),
-    );
-  });
-
-  test(`shouldn't return if individual message cache not exist`, () => {
-    pushToCache(['message', 'query', convertQueryParams(queryCriteria)], {
-      messages: messageIds,
-      paging,
-    });
-
-    expect(queryMessages.locally(queryCriteria)).toBeUndefined();
-  });
-
-  test('it should return undefined if message not in cache', () => {
-    expect(queryMessages.locally({ subChannelId: 'non-existent' })).toBeUndefined();
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBe(false);
   });
 });

package/src/message/observers/liveMessages.ts

@@ -76,7 +76,7 @@ export const liveMessages = (
      * for cases when message is deleted via RTE, this flag is used to get
      * items from cache that are !deleted
      */
-    if (params.includeDeleted === false) {
+    if (!params.includeDeleted) {
       messages = filterByPropEquality(messages, 'isDeleted', false);
     }
 
@@ -97,6 +97,7 @@ export const liveMessages = (
     collection.data = [...new Set([message.messageId, ...collection.data])];
 
     pushToCache(cacheKey, collection);
+    disposers.push(() => dropFromCache(cacheKey));
 
     responder(collection);
   };
@@ -152,6 +153,5 @@ export const liveMessages = (
   return () => {
     log(`liveMessages(tmpid: ${timestamp}) > dispose`);
     disposers.forEach(fn => fn());
-    dropFromCache(cacheKey);
   };
 };

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

@@ -58,7 +58,7 @@ describe('liveMessage', () => {
   ];
 
   test.each(events)('%s', async (test, event) => {
-    await disableCache();
+    disableCache();
     const snapshot = getSnapshot();
 
     // mock response of queryMessages and validate

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

@@ -201,7 +201,7 @@ describe('liveMessages', () => {
         },
       });
 
-    liveMessages({ subChannelId }, callback);
+    liveMessages({ subChannelId, includeDeleted: true }, callback);
 
     expect(callback).toHaveBeenCalled();
 

package/src/message/utils/prepareMessagePayload.ts

@@ -4,6 +4,8 @@ import { toToken } from '~/core/query';
 import { getMessageMarkers } from '~/marker/api';
 import { prepareMessagePayloadForCache } from '~/reaction/utils/prepareMessagePayloadForCache';
 
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
 const getCachedMarker = (message: Amity.Message | Amity.RawMessage) => {
   const key = {
     creatorId: message.creatorId,
@@ -166,7 +168,7 @@ export function convertQueryParams({
   const out: RawQueryMessages = {
     ...rest,
     messageFeedId: subChannelId,
-    isDeleted: includeDeleted === false ? false : undefined,
+    isDeleted: inferIsDeleted(includeDeleted),
     options: { token: toToken(page || { limit: 10 }, 'afterbeforeraw')! },
   };
 

package/src/post/api/queryPosts.ts

@@ -5,7 +5,9 @@ import { toToken, toPageRaw } from '~/core/query';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
+
 import { prepareMembershipPayload } from '~/group/utils';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
 
 /* begin_public_function
   id: post.query, feed.query.community_feed, feed.query.user_feed
@@ -39,7 +41,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,
+      isDeleted: inferIsDeleted(includeDeleted),
       /*
        * when creating post like image, file, video BE will create 2 posts
        * 1. parent post to store text with dataType=text

package/src/post/observers/livePosts.ts

@@ -7,6 +7,7 @@ import {
   createQuery,
   filterByFeedType,
   filterByPropEquality,
+  filterByPostDataTypes,
   queryOptions,
   runQuery,
   sortByFirstCreated,
@@ -89,7 +90,7 @@ export const livePosts = (
     const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
     posts = posts.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
 
-    if (params.includeDeleted === false) {
+    if (!params.includeDeleted) {
       posts = filterByPropEquality(posts, 'isDeleted', false);
     }
 
@@ -101,6 +102,10 @@ export const livePosts = (
       posts = filterByFeedType(posts, params.feedType);
     }
 
+    if (params.dataTypes?.length) {
+      posts = filterByPostDataTypes(posts, params.dataTypes);
+    }
+
     callback({
       onNextPage: onFetch,
       data: posts,
@@ -127,6 +132,7 @@ export const livePosts = (
     }
 
     pushToCache(cacheKey, collection);
+    disposers.push(() => dropFromCache(cacheKey));
 
     responder(collection);
   };
@@ -183,6 +189,5 @@ export const livePosts = (
   return () => {
     log(`livePosts(tmpid: ${timestamp}) > dispose`);
     disposers.forEach(fn => fn());
-    dropFromCache(cacheKey);
   };
 };

package/src/post/observers/tests/livePosts.test.ts

@@ -66,7 +66,7 @@ describe('livePosts', () => {
 
   const filters: [string, Amity.PostLiveCollection, number?][] = [
     ['not deleted', { ...params, includeDeleted: false }],
-    ['tags', { ...params, tags: ['test_tag'] }, 1],
+    ['tags', { ...params, tags: ['test_tag'], includeDeleted: true }, 1],
   ];
 
   test.each(filters)(
@@ -104,7 +104,7 @@ describe('livePosts', () => {
       .mockResolvedValue(postQueryResponse)
       .mockResolvedValueOnce(postQueryResponsePage2);
 
-    livePosts(params, callback);
+    livePosts({ ...params, includeDeleted: true }, callback);
 
     expect(callback).toHaveBeenCalled();
 
@@ -292,7 +292,10 @@ describe('livePosts', () => {
     const callback = jest.fn();
     client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
 
-    livePosts({ ...params, targetType: 'community', feedType: 'reviewing' }, callback);
+    livePosts(
+      { ...params, targetType: 'community', feedType: 'reviewing', includeDeleted: true },
+      callback,
+    );
 
     await pause();
     const payload = postQueryResponsePage2.data.posts;
@@ -335,7 +338,10 @@ describe('livePosts', () => {
     const callback = jest.fn();
     client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
 
-    livePosts({ ...params, targetType: 'community', feedType: 'published' }, callback);
+    livePosts(
+      { ...params, targetType: 'community', feedType: 'published', includeDeleted: true },
+      callback,
+    );
 
     await pause();
     const payload = postQueryResponsePage2.data.posts;

package/src/subChannel/api/querySubChannels.ts

@@ -4,6 +4,8 @@ import { getActiveClient } from '~/client/api';
 import { getResolver } from '~/core/model';
 import { toPage, toToken } from '~/core/query';
 import { fireEvent } from '~/core/events';
+
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
 import { convertQueryParams, prepareSubChannelPayload } from '../utils';
 
 /* begin_public_function
@@ -36,7 +38,7 @@ export const querySubChannels = async (
     {
       params: {
         ...params,
-        isDeleted: includeDeleted === false ? false : undefined,
+        isDeleted: inferIsDeleted(includeDeleted),
         options: {
           token: toToken(page, 'skiplimit'),
         },

package/src/subChannel/observers/liveSubChannels.ts

@@ -59,7 +59,7 @@ export const liveSubChannels = (
   const responder = (data: Amity.SubChannelLiveCollectionCache) => {
     let subChannels: Amity.SubChannel[] = data.data;
 
-    if (params.includeDeleted === false) {
+    if (!params.includeDeleted) {
       subChannels = filterByPropEquality(subChannels, 'isDeleted', false);
     }
 

package/src/utils/inferIsDeleted.ts

@@ -0,0 +1,16 @@
+/*
+ * This is a simple utility that infers the value of isDeleted based on the
+ * value of includeDeleted
+ *
+ * There are two important things to note here:
+ *  1. `includeDeleted` is purely client side query param and not recognized by
+ *  the server
+ *  2. The only values we wish to expose with regards to `isDeleted` (the server
+ *  param for queries) is false | undefined and want to disallow users to query
+ *  for deleted entities
+ *
+ *  Although this is a very simple utility, it's only purpose is to keep things
+ *  DRY
+ */
+export const inferIsDeleted = (includeDeleted?: boolean): boolean | undefined =>
+  includeDeleted === true ? undefined : false;

package/src/utils/tests/inferIsDeleted.test.ts

@@ -0,0 +1,15 @@
+import { inferIsDeleted } from '../inferIsDeleted';
+
+describe('utils > inferIsDeleted', () => {
+  test('it should return false if includeDeleted false', () => {
+    expect(inferIsDeleted(false)).toBe(false);
+  });
+
+  test('it should return false if includeDeleted undefined', () => {
+    expect(inferIsDeleted(undefined)).toBe(false);
+  });
+
+  test('it should return undefined if includeDeleted true', () => {
+    expect(inferIsDeleted(true)).toBeUndefined();
+  });
+});