@amityco/ts-sdk 0.0.1-beta.43.1 → 0.0.1-beta.45.0

package/src/message/api/queryMessages.ts

@@ -2,7 +2,9 @@ import { getActiveClient } from '~/client/api';
 
 import { fireEvent } from '~/core/events';
 import { toPageRaw } from '~/core/query';
-import { pullFromCache } from '~/cache/api';
+import { pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
 import { convertQueryParams, prepareMessagePayload } from '../utils';
 
 /* begin_public_function
@@ -47,12 +49,18 @@ export const queryMessages = async (
 
   const cachedAt = client.cache && Date.now();
 
-  // if (client.cache) {
-  //   ingestInCache(data, { cachedAt });
-  //
-  //   const cacheKey = ['message', 'query', params as Amity.Serializable];
-  //   pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });
-  // }
+  if (client.cache) {
+    /*
+     * queryMessages.locally is unsupported for messages as message list updates
+     * frequently and leads to bugs when user switches between channels, i.e. when
+     * the public function (live messages) calls unmount. The list fetched on
+     * after from the cache is stale.
+     */
+    ingestInCache(data, { cachedAt });
+
+    const cacheKey = ['message', 'query', params as Amity.Serializable];
+    pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });
+  }
 
   fireEvent('local.message.fetched', { messages });
 
@@ -62,46 +70,3 @@ export const queryMessages = async (
   return { data: messages, cachedAt, prevPage, nextPage };
 };
 /* end_public_function */
-
-/**
- * ```js
- * import { queryMessages } from '@amityco/ts-sdk'
- * const messages = queryMessages.locally!({ channelId })
- * ```
- *
- * Queries a paginable list of {@link Amity.Message} objects from cache
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Message} objects
- *
- * @category Message API
- */
-queryMessages.locally = (
-  query: Parameters<typeof queryMessages>[0],
-): Amity.Cached<Amity.Paged<Amity.Message, Amity.Page<string>>> | undefined => {
-  const client = getActiveClient();
-  client.log('message/queryMessages.locally', query);
-
-  if (!client.cache) return;
-
-  const params = convertQueryParams(query);
-
-  const queryKey = ['message', 'query', params as Amity.Serializable];
-  const { data, cachedAt } =
-    pullFromCache<{ messages: Pick<Amity.Message, 'messageId'>[] } & Amity.Pagination>(queryKey) ??
-    {};
-
-  if (!data?.messages.length) return;
-
-  const messages: Amity.Message[] = data.messages
-    .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
-    .filter(Boolean)
-    .map(({ data }) => data);
-
-  const prevPage = toPageRaw(data?.paging.previous);
-  const nextPage = toPageRaw(data?.paging.next);
-
-  return messages.length === data?.messages?.length
-    ? { data: messages, cachedAt, prevPage, nextPage }
-    : undefined;
-};

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

@@ -22,7 +22,7 @@ import {
   onMessageUpdated,
 } from '../events';
 import { onMessageFetched } from '../events/onMessageFetched';
-import { queryMessages } from '../api';
+import { queryMessages } from '../api/queryMessages';
 
 /**
  * ```js
@@ -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);
     }
 
@@ -101,16 +101,16 @@ export const liveMessages = (
     responder(collection);
   };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.MessageLiveCollectionCache>(cacheKey)?.data;
 
     const messages = collection?.data ?? [];
 
-    if (messages.length > 0 && !collection?.params?.page) return;
+    if (!initial && messages.length > 0 && !collection?.params?.page) return;
 
     const query = createQuery(queryMessages, {
       ...queryParams,
-      page: collection?.params?.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -147,11 +147,11 @@ export const liveMessages = (
     onMessageReactionRemoved(realtimeRouter('onReactionRemoved')),
   );
 
-  onFetch();
+  onFetch(true);
+  disposers.push(() => dropFromCache(cacheKey));
 
   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,20 +132,21 @@ export const livePosts = (
     }
 
     pushToCache(cacheKey, collection);
+    disposers.push(() => dropFromCache(cacheKey));
 
     responder(collection);
   };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
 
     const posts = collection?.data ?? [];
 
-    if (posts.length > 0 && !collection?.params?.page) return;
+    if (!initial && posts.length > 0 && !collection?.params?.page) return;
 
     const query = createQuery(queryPosts, {
       ...queryParams,
-      page: collection?.params?.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -178,11 +184,10 @@ export const livePosts = (
     onPostReactionRemoved(realtimeRouter('onReactionRemoved')),
   );
 
-  onFetch();
+  onFetch(true);
 
   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/reaction/observers/liveReactions.ts

@@ -88,16 +88,16 @@ export const liveReactions = (
     responder(collection);
   };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
 
     const reactions = collection?.data ?? [];
 
-    if (reactions.length > 0 && !collection?.params?.page) return;
+    if (!initial && reactions.length > 0 && !collection?.params?.page) return;
 
     const query = createQuery(queryReactions, {
       ...queryParams,
-      page: collection?.params?.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -133,7 +133,7 @@ export const liveReactions = (
     ),
   );
 
-  onFetch();
+  onFetch(true);
 
   return () => {
     log(`liveReactions(tmpid: ${timestamp}) > dispose`);

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/user/observers/liveUsers.ts

@@ -111,16 +111,16 @@ export const liveUsers = (
     responder(collection);
   };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.UserLiveCollectionCache>(cacheKey)?.data;
 
     const users = collection?.data ?? [];
 
-    if (users.length > 0 && !collection?.params.page) return;
+    if (!initial && users.length > 0 && !collection?.params.page) return;
 
     const query = createQuery(queryUsers, {
       ...queryParams,
-      page: collection?.params.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -153,7 +153,7 @@ export const liveUsers = (
     onUserFlagCleared(realtimeRouter('onFlagCleared')),
   );
 
-  onFetch();
+  onFetch(true);
 
   return () => {
     log(`liveUsers(tmpid: ${timestamp}) > dispose`);

package/src/user/observers/tests/liveUsers.test.ts

@@ -65,17 +65,11 @@ describe('liveUsers', () => {
     liveUsers(params, callback);
     await pause();
 
-    expect(callback).toHaveBeenCalledTimes(2);
+    // The second `getUsers` call fetches data from the cache,
+    // so there is no loading state and the callback only fires once.
+    expect(callback).toHaveBeenCalledTimes(1);
     expect(callback).toHaveBeenNthCalledWith(
       1,
-      expect.objectContaining(
-        getSnapshot({
-          data: payload.users,
-        }),
-      ),
-    );
-    expect(callback).toHaveBeenNthCalledWith(
-      2,
       expect.objectContaining(
         getSnapshot({
           data: payload.users,

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();
+  });
+});