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

package/src/user/observers/liveUsers.ts

@@ -0,0 +1,162 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByLastCreated,
+  sortByDisplayName,
+  sortByFirstCreated,
+} from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+
+import { queryUsers } from '../api';
+import {
+  onUserFlagged,
+  onUserUpdated,
+  onUserUnflagged,
+  onUserFlagCleared,
+  onUserDeleted,
+} from '../events';
+
+/**
+ * ```js
+ * import { liveUsers } from '@amityco/ts-sdk'
+ *
+ * let users = []
+ * const unsub = liveUsers({}, response => merge(users, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.User}s
+ *
+ * @param params for querying users
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the users
+ *
+ * @category Category Live Collection
+ */
+export const liveUsers = (
+  params: Amity.UserLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.User>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveUsers(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = ['user', 'collection', {}];
+
+  const responder = (data: Amity.UserLiveCollectionCache) => {
+    let users: Amity.User[] =
+      data.data
+        .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    users = filterByPropEquality(users, 'displayName', params.displayName);
+
+    switch (params.sortBy) {
+      case 'firstCreated':
+        users = users.sort(sortByFirstCreated);
+        break;
+
+      case 'lastCreated':
+        users = users.sort(sortByLastCreated);
+        break;
+
+      default:
+        users = users
+          // this needs to be aligned with the backend data type
+          .map(u => (u.displayName ? u : { ...u, displayName: '' }))
+          // @ts-ignore
+          .sort(sortByDisplayName);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: users,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (_: Amity.UserActionType) => (user: Amity.User) => {
+    const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(cacheKey)?.data;
+    if (!collection) return;
+
+    collection.data = [...new Set([user.userId, ...collection.data])];
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.UserLiveCollectionCache>(cacheKey)?.data;
+
+    const users = collection?.data ?? [];
+
+    if (users.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryUsers, {
+      ...queryParams,
+      page: collection?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: users,
+        };
+
+        if (result) {
+          data.data = [...new Set([...users, ...result.map(getResolver('user'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onUserUpdated(realtimeRouter('onUpdate')),
+    onUserDeleted(realtimeRouter('onDelete')),
+    onUserFlagged(realtimeRouter('onFlagged')),
+    onUserUnflagged(realtimeRouter('onUnflagged')),
+    onUserFlagCleared(realtimeRouter('onFlagCleared')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveUsers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

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

@@ -0,0 +1,202 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  user11,
+  user12,
+  user21,
+  userQueryResponse,
+  userQueryResponsePage2,
+} from '~/utils/tests';
+
+import { liveUsers } from '../liveUsers';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.User[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+const { paging, ...payload } = userQueryResponse.data;
+const { paging: paging2, ...payload2 } = userQueryResponsePage2.data;
+
+describe('liveUsers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const params = { sortBy: 'lastCreated' } as Amity.UserLiveCollection;
+
+  test('it should return users collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    liveUsers(params, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.users,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  test('it should return data from cache', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    liveUsers(params, () => undefined);
+    await pause();
+    liveUsers(params, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.users,
+        }),
+      ),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.users,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(userQueryResponse)
+      .mockResolvedValueOnce(userQueryResponsePage2);
+
+    liveUsers(params, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+    await pause();
+
+    // 4 -> because 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: [...payload2.users, ...payload.users],
+        }),
+      ),
+    );
+  });
+
+  describe('events', () => {
+    const updatedUser = { ...user11, displayName: 'updated-user' };
+    const flaggedUser = { ...user11, flagCount: 1 };
+    const unflaggedUser = { ...user11, flagCount: 1 };
+    const flagClearedUser = { ...user11, flagCount: 0 };
+
+    const cases: [string, keyof Amity.Events, Amity.UserPayload, Amity.User[]][] = [
+      [
+        'it should update user in collection onUpdate',
+        'user.updated',
+        { users: [updatedUser], files: [] },
+        [updatedUser, user12],
+      ],
+      [
+        'it should update user in collection onUpdate',
+        'user.flagged',
+        { users: [flaggedUser], files: [] },
+        [flaggedUser, user12],
+      ],
+      [
+        'it should update user in collection onUpdate',
+        'user.unflagged',
+        { users: [unflaggedUser], files: [] },
+        [unflaggedUser, user12],
+      ],
+      [
+        'it should update user in collection onUpdate',
+        'user.flagCleared',
+        { users: [flagClearedUser], files: [] },
+        [flagClearedUser, user12],
+      ],
+    ];
+
+    test.each(cases)('%s', async (test, event, user, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+      liveUsers(params, callback);
+      await pause();
+
+      client.emitter.emit(event, user);
+      await pause();
+
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining(
+          getSnapshot({
+            data: expected,
+            loading: false,
+          }),
+        ),
+      );
+    });
+  });
+
+  const filters: [string, Amity.UserLiveCollection, Amity.User[]][] = [
+    ['displayName', { displayName: 'displayName' }, [user21]],
+  ];
+
+  test.each(filters)('it should filter by %s communities', async (filter, params, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponsePage2);
+
+    liveUsers(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(getSnapshot()));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: expected,
+        }),
+      ),
+    );
+  });
+});

package/src/utils/tests/dummy/channel.ts

@@ -6,6 +6,7 @@ export function generateRawChannel(params?: Partial<Amity.ChannelRaw>): Amity.Ch
 
   return {
     _id: `${channelId}-internalId`,
+    lastActivity: '',
     channelId,
     createdAt: date,
     isDeleted: false,

package/src/utils/tests/dummy/feed.ts

@@ -0,0 +1,13 @@
+export const feed11 = {
+  targetType: 'community',
+  targetId: '6396a419becb56760a7b0bb9',
+  feedType: 'published',
+  feedId: '16708167935683a5eb158a39f40ffbdd49b7f70dc9bfd',
+  postCount: 4,
+  createdAt: '2022-12-12T03:46:33.557Z',
+  updatedAt: '2022-12-12T05:51:37.927Z',
+};
+
+export const feedPayload = {
+  feeds: [feed11],
+};

package/src/utils/tests/dummy/index.ts

@@ -21,3 +21,5 @@ export * from './community';
 export * from './category';
 
 export * from './stream';
+
+export * from './feed';

package/src/utils/tests/dummy/post.ts

@@ -1,4 +1,4 @@
-import { user11, file11, communityUser11, date } from '.';
+import { user11, file11, date, feed11 } from '.';
 import { encodeJson } from '..';
 
 export function generatePost(params?: Partial<Amity.Post>): Amity.Post {
@@ -18,6 +18,7 @@ export function generatePost(params?: Partial<Amity.Post>): Amity.Post {
     path: '',
     postedUserId: user11.userId,
     postId: 'postId11',
+    isDeleted: false,
     reactions: {},
     reactionsCount: 0,
     targetId: user11.userId,
@@ -73,6 +74,7 @@ export const post14: Amity.Post = {
   ...post11,
   postId: 'post14',
   targetType: 'community',
+  feedId: 'feedId',
   isDeleted: false,
   children: [],
 };
@@ -82,6 +84,7 @@ export const post15: Amity.Post = {
   postId: 'post15',
   isDeleted: true,
   children: [post11.postId],
+  feedId: 'feedId',
   targetType: 'community',
   tags: ['test_tag'],
 };
@@ -128,8 +131,9 @@ export const postQueryResponse = {
 
 export const postQueryResponsePage2 = {
   data: {
-    posts: [post14, post15, post16],
+    posts: [post14, post15],
     files: [],
+    feeds: [{ ...feed11, feedType: 'reviewing', targetId: post14.targetId, feedId: post14.feedId }],
     paging: {
       next: nextPage,
     },

package/src/utils/tests/dummy/user.ts

@@ -26,6 +26,17 @@ export const user14: Amity.User = {
   userId: 'user4',
 };
 
+export const user21: Amity.User = {
+  ...user11,
+  displayName: 'displayName',
+  userId: 'user21',
+};
+
+export const user22: Amity.User = {
+  ...user11,
+  userId: 'user22',
+};
+
 export const userQueryResponse = {
   data: {
     users: [user11, user12],
@@ -37,6 +48,30 @@ export const userQueryResponse = {
   },
 };
 
+export const userQueryResponsePage2 = {
+  data: {
+    users: [user21, user22],
+    files: [],
+    paging: {
+      previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+      next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+    },
+  },
+};
+
+export const flaggedUser = {
+  ...user11,
+  userId: 'to-be-flagged',
+  flagCount: 1,
+};
+
+export const flaggedUserQueryResponse = {
+  data: {
+    users: [flaggedUser],
+    files: [],
+  },
+};
+
 export const userUpdateResponse = {
   data: {
     users: [
@@ -57,6 +92,7 @@ export const userUpdateResponse = {
     files: [],
   },
 };
+
 export const users = [user11, user12, user13, user14];
 
 // user payload with file