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

package/src/subChannel/observers/tests/liveSubChannel.test.ts

@@ -1,4 +1,3 @@
-import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache } from '~/cache/api';
 import {
   pause,
@@ -30,27 +29,6 @@ describe('liveSubChannel', () => {
 
   afterEach(disableCache);
 
-  test('should get sub channel', async () => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(response);
-
-    liveSubChannel(rawSubChannel.messageFeedId, callback);
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-    expect(callback).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({ data: undefined, loading: true }),
-    );
-    expect(callback).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({
-        data: convertFromRaw(rawSubChannel),
-        loading: false,
-      }),
-    );
-  });
-
   const events: [string, keyof Amity.Events][] = [
     ['should get update on message-feed.updated event', 'message-feed.updated'],
     ['should get update on message-feed.deleted event', 'message-feed.deleted'],
@@ -149,64 +127,4 @@ describe('liveSubChannel', () => {
       );
     });
   });
-
-  test('should not get update on api failure', async () => {
-    const error = new ASCApiError(
-      'server error!',
-      Amity.ServerError.ITEM_NOT_FOUND,
-      Amity.ErrorLevel.ERROR,
-    );
-    const update = {
-      ...rawSubChannel,
-      name: 'new name',
-      updatedAt: getFutureDate(rawSubChannel.updatedAt),
-    };
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockRejectedValue(error);
-
-    liveSubChannel(subChannel.subChannelId, callback);
-    await pause();
-    client.emitter.emit('message-feed.updated', { messageFeeds: [update] });
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-    expect(callback).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({
-        data: undefined,
-        error,
-        loading: false,
-      }),
-    );
-  });
-
-  test('should not call callback if liveMessage is disposed', async () => {
-    const update = {
-      ...rawSubChannel,
-      name: 'new name',
-      updatedAt: getFutureDate(rawSubChannel.updatedAt),
-    };
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(response);
-
-    const dispose = liveSubChannel(subChannel.subChannelId, callback);
-    await pause();
-    dispose();
-    client.emitter.emit('message-feed.updated', { messageFeeds: [update] });
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-  });
-
-  test('should not call callback if data is the same', async () => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(response);
-
-    liveSubChannel(subChannel.subChannelId, callback);
-    await pause();
-    client.emitter.emit('message-feed.updated', { messageFeeds: response.data.messageFeeds });
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-  });
 });

package/src/user/api/queryUsers.ts

@@ -23,12 +23,7 @@ import { fireEvent } from '~/core/events';
  * @async
  */
 export const queryUsers = async (
-  query: {
-    displayName?: Amity.User['displayName'];
-    filter?: 'all' | 'flagged';
-    sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
-    page?: Amity.Page;
-  } = {},
+  query: Amity.QueryUsers = {},
 ): Promise<Amity.Cached<Amity.Paged<Amity.User>>> => {
   const client = getActiveClient();
   client.log('user/queryUsers', query);

package/src/user/api/tests/updateUser.test.ts

@@ -0,0 +1,60 @@
+import { disableCache, enableCache, pushToCache, pullFromCache } from '~/cache/api';
+
+import { client, userUpdateResponse } from '~/utils/tests';
+
+import { updateUser } from '../updateUser';
+import { onUserUpdated } from '../../events/onUserUpdated';
+
+describe('updateUser', () => {
+  const displayName = 'updated-display-name';
+  const userId = 'test-user';
+  const avatarCustomUrl = 'updated-avatarUrl';
+
+  // integration_test_id: a1a8260f-3314-41ba-9f5f-3a96dd52453d
+  test('it should return updated user on success', async () => {
+    const { users: expected } = userUpdateResponse.data;
+    client.http.put = jest.fn().mockResolvedValue(userUpdateResponse);
+
+    const { data: received } = await updateUser(userId, { displayName, avatarCustomUrl });
+
+    expect(received).toStrictEqual(expected[0]);
+  });
+
+  // integration_test_id: 67cb7ad8-28a9-4950-a86c-35497bb5212c
+  test('it should return 400301 when updating another user', async () => {
+    client.http.put = jest.fn().mockRejectedValueOnce(new Error('400301'));
+
+    await expect(
+      updateUser('different-user', { displayName: 'updated-display-name' }),
+    ).rejects.toThrow('400301');
+  });
+
+  test('it should update cache with updated user', async () => {
+    enableCache();
+
+    const expected = userUpdateResponse.data.users[0];
+    pushToCache(['user', 'get', userId], { ...expected, displayName: 'old-displayName' });
+
+    client.http.put = jest.fn().mockResolvedValue(userUpdateResponse);
+    await updateUser(userId, { displayName, avatarCustomUrl });
+
+    const received = pullFromCache(['user', 'get', userId])?.data;
+
+    expect(received).toStrictEqual(expected);
+    disableCache();
+  });
+
+  test('it should fire event for updated user', async () => {
+    let dispose;
+    const { users: expected } = userUpdateResponse.data;
+    client.http.put = jest.fn().mockResolvedValue(userUpdateResponse);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserUpdated(resolve);
+    }).finally(dispose);
+
+    await updateUser(userId, { displayName, avatarCustomUrl });
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(expected[0]));
+  });
+});

package/src/user/observers/index.ts

@@ -1,2 +1,3 @@
 export { liveUser } from './liveUser';
+export { liveUsers } from './liveUsers';
 export { observeUser } from './observeUser';

package/src/user/observers/liveUser.ts

@@ -1,9 +1,4 @@
-import { getActiveClient } from '~/client/api';
-import { createQuery, runQuery } from '~/core/query';
-
-import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
-
-import { hasUpdates } from '~/core/model';
+import { liveObject } from '~/utils/liveObject';
 import {
   onUserDeleted,
   onUserUpdated,
@@ -37,59 +32,12 @@ export const liveUser = (
   userId: Amity.User['userId'],
   callback: Amity.LiveObjectCallback<Amity.User>,
 ): Amity.Unsubscriber => {
-  const { log, cache } = getActiveClient();
-  const timestamp = Date.now();
-  log(`liveUser(tmpid: ${timestamp}) > listen`);
-
-  if (!cache) {
-    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-  }
-
-  let user: Amity.User;
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const dispatcher = (data: Amity.LiveObject<Amity.User>) => {
-    user = data.data;
-    callback(data);
-  };
-
-  const realtimeRouter = (eventUser: Amity.User) => {
-    if (userId !== eventUser.userId) {
-      return;
-    }
-
-    if (user && !hasUpdates(user, eventUser)) {
-      return;
-    }
-
-    dispatcher({ loading: false, data: eventUser, origin: 'event' });
-  };
-
-  const onFetch = () => {
-    const query = createQuery(getUser, userId, true);
-
-    runQuery(query, ({ loading, data, error, origin }) => {
-      dispatcher({ loading, data, origin, error });
-
-      if (error) {
-        disposers.forEach(fn => fn());
-      }
-    });
-  };
-
-  disposers.push(
-    onUserFetched(realtimeRouter),
-    onUserUpdated(realtimeRouter),
-    onUserDeleted(realtimeRouter),
-    onUserFlagged(realtimeRouter),
-    onUserUnflagged(realtimeRouter),
-    onUserFlagCleared(realtimeRouter),
-  );
-
-  onFetch();
-
-  return () => {
-    log(`liveUser(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
+  return liveObject(userId, callback, 'userId', getUser, [
+    onUserFetched,
+    onUserUpdated,
+    onUserDeleted,
+    onUserFlagged,
+    onUserUnflagged,
+    onUserFlagCleared,
+  ]);
 };

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