@amityco/ts-sdk 6.3.1 → 6.3.2-3fa3a47.0

package/src/userRepository/observers/getUsers.ts

@@ -29,7 +29,7 @@ import {
 } from '../events';
 
 /* begin_public_function
-  id: user.query, user.search
+  id: user.query
 */
 /**
  * ```js
@@ -69,14 +69,8 @@ export const getUsers = (
   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);
+  const applyFilter = (data: Amity.User[]): Amity.User[] => {
+    let users = filterByPropEquality(data, 'displayName', params.displayName);
 
     switch (params.sortBy) {
       case 'firstCreated':
@@ -95,9 +89,22 @@ export const getUsers = (
           .sort(sortByDisplayName);
     }
 
+    return users;
+  };
+
+  const responder = (data: Amity.UserLiveCollectionCache, isEventModel = false) => {
+    const users: Amity.User[] =
+      data.data
+        .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
     callback({
       onNextPage: onFetch,
-      data: users,
+      /*
+       * Only apply filter to RTE Model
+       */
+      data: isEventModel ? applyFilter(users) : users,
       hasNextPage: !!data.params?.page,
       loading: data.loading,
       error: data.error,
@@ -111,7 +118,7 @@ export const getUsers = (
     collection.data = [...new Set([user.userId, ...collection.data])];
 
     pushToCache(cacheKey, collection);
-    responder(collection);
+    responder(collection, true);
   };
 
   const onFetch = (initial = false) => {

package/src/userRepository/observers/index.ts

@@ -2,3 +2,4 @@ export { getUser } from './getUser';
 export { getUsers } from './getUsers';
 export { observeUser } from './observeUser';
 export { getBlockedUsers } from './getBlockedUsers';
+export { searchUserByDisplayName } from './searchUserByDisplayName';

package/src/userRepository/observers/searchUserByDisplayName.ts

@@ -0,0 +1,30 @@
+import { getUsers } from './getUsers';
+
+/* begin_public_function
+  id: user.search
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk'
+ *
+ * let users = []
+ * const unsub = UserRepository.searchUserByDisplayName({}, response => merge(users, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.User}s
+ *
+ * @param params for searching users
+ * @param callback the function to call when new data are available
+ * @param config the configuration for the live collection
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the users
+ *
+ * @category Category Live Collection
+ */
+export const searchUserByDisplayName = (
+  params: Amity.UserSearchLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.User>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  return getUsers({ ...params, filter: 'all' }, callback, config);
+};
+/* end_public_function */

package/src/userRepository/observers/tests/getUsers.test.ts

@@ -6,7 +6,6 @@ import {
   pause,
   user11,
   user12,
-  user21,
   userQueryResponse,
   userQueryResponsePage2,
 } from '~/utils/tests';
@@ -114,6 +113,7 @@ describe('getUsers', () => {
   });
 
   describe('events', () => {
+    // integration_test_id: 60b4b354-efca-49bc-aa8b-d63a8da6ef31
     const updatedUser = { ...user11, displayName: 'updated-user' };
     const flaggedUser = { ...user11, flagCount: 1 };
     const unflaggedUser = { ...user11, flagCount: 1 };
@@ -167,32 +167,4 @@ describe('getUsers', () => {
       );
     });
   });
-
-  // integration_test_id: 60b4b354-efca-49bc-aa8b-d63a8da6ef31
-  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);
-
-    getUsers(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/userRepository/observers/tests/searchUserByDisplayName.test.ts

@@ -0,0 +1,113 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  user21,
+  userQueryResponse,
+  userQueryResponsePage2,
+} from '~/utils/tests';
+
+import { searchUserByDisplayName } from '../searchUserByDisplayName';
+
+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('searchUserByDisplayName', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const params = { displayName: user21.displayName } as Amity.UserLiveCollection;
+
+  // integration_test_id: c7cb9776-5c72-4abe-9b3c-572d74d534fe
+  test('it should return users collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    searchUserByDisplayName(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);
+
+    searchUserByDisplayName(params, () => undefined);
+    await pause();
+    searchUserByDisplayName(params, callback);
+    await pause();
+
+    // The second `searchUserByDisplayName` 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,
+          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);
+
+    searchUserByDisplayName(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],
+        }),
+      ),
+    );
+  });
+});

package/src/utils/isEqual.ts

@@ -0,0 +1,69 @@
+/**
+ * ```js
+ * import { isEqual } from '~/utils/isEqual'
+ * const isEqual = isEqual(post1, post2)
+ * ```
+ *
+ * Compares two Amity.Model
+ *
+ * @param x the Amity.Model to compare
+ * @param y the Amity.Model to compare wit x
+ * @returns a boolean based on equality
+ *
+ * @category utility
+ * @private
+ */
+export function isEqual(x: any, y: any): boolean {
+  if (x === null || x === undefined || y === null || y === undefined) {
+    return x === y;
+  }
+
+  // after this just checking type of one would be enough
+  if (x.constructor !== y.constructor) {
+    return false;
+  }
+
+  // if they are functions, they should exactly refer to same one (because of closures)
+  if (x instanceof Function) {
+    return x === y;
+  }
+
+  // if they are regexps, they should exactly refer to same one
+  if (x instanceof RegExp) {
+    return x === y;
+  }
+
+  if (x === y || x.valueOf() === y.valueOf()) {
+    return true;
+  }
+
+  if (Array.isArray(x) && x.length !== y.length) {
+    return false;
+  }
+
+  // if they are dates, they must had equal valueOf
+  if (x instanceof Date) {
+    return false;
+  }
+
+  // if they are strictly equal, they both need to be object at least
+  if (!(x instanceof Object)) {
+    return false;
+  }
+
+  if (!(y instanceof Object)) {
+    return false;
+  }
+
+  // recursive object equality check
+  const p = Object.keys(x);
+  return (
+    Object.keys(y).every(i => {
+      // @ts-ignore
+      return p.indexOf(i) !== -1;
+    }) &&
+    p.every(i => {
+      return isEqual(x[i], y[i]);
+    })
+  );
+}

package/src/utils/liveObject.ts

@@ -8,6 +8,8 @@ import { hasUpdates } from '~/core/model';
 import { createQuery, runQuery } from '~/core/query';
 import { ASCApiError } from '~/core/errors';
 
+import { isEqual } from './isEqual';
+
 export const liveObject = <
   T extends Amity.Models[Amity.Domain],
   K extends keyof T,
@@ -46,8 +48,25 @@ export const liveObject = <
       return;
     }
 
-    if (model && !hasUpdates(model, eventModel)) {
-      return;
+    if (model) {
+      /*
+       * This test is required as follow does not extend Amity.Timestamps
+       * Also, follow can have an event where the paylod is not updated i.e.
+       * when a request is declined
+       */
+      if ('updatedAt' in model && 'updatedAt' in eventModel) {
+        /*
+         * NOTE: the isEqual is added as a fail safe as the server does not update
+         * the updatedAt when the model updates rather when the data in the data of
+         * the model (if any) updates.
+         *
+         * Ex: post.addReaction | post.removeReaction does not update the updatedAt
+         * of the post
+         */
+        if (!hasUpdates(model, eventModel) || isEqual(model, eventModel)) {
+          return;
+        }
+      }
     }
 
     dispatcher({ loading: false, data: eventModel, origin: 'event' });

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

@@ -0,0 +1,86 @@
+import { isEqual } from '../isEqual';
+
+describe('utils > isEqual', () => {
+  describe('isEqual > primitive types', () => {
+    test('it should return true if both objects are null', () => {
+      expect(isEqual(null, null)).toBe(true);
+    });
+
+    test('it should return false if one of the object is undefined', () => {
+      expect(isEqual(null, undefined)).toBe(false);
+    });
+
+    test('it should return false if x & y regexps that dont to the same instance', () => {
+      expect(isEqual(/abc/, /abc/)).toBe(false);
+    });
+
+    test('it should return false if x & y are not the same regexps', () => {
+      expect(isEqual(/abc/, /123/)).toBe(false);
+    });
+
+    test('it should return true if x & y are regexps with the same instance', () => {
+      const regEx = /123/;
+      expect(isEqual(regEx, regEx)).toBe(true);
+    });
+
+    test('it should return true if x & y are the same string', () => {
+      expect(isEqual('test', 'test')).toBe(true);
+    });
+
+    test('it should return true if x & y are the same number', () => {
+      expect(isEqual(5, 5)).toBe(true);
+    });
+
+    test('it should return false if x & y are not the same number', () => {
+      expect(isEqual(5, 6)).toBe(false);
+    });
+  });
+
+  describe('isEqual > complex types', () => {
+    describe('- arrays', () => {
+      test('it should return true if x & y are empty arrays', () => {
+        expect(isEqual([], [])).toBe(true);
+      });
+
+      test('it should return true if x & y are the same array', () => {
+        expect(isEqual([1, 'hi'], [1, 'hi'])).toBe(true);
+      });
+
+      test('it should return false if x & y are not the same array', () => {
+        expect(isEqual([1, 'hi'], ['hi', 1])).toBe(false);
+      });
+
+      test('it should return false if x & y are only partially similar', () => {
+        expect(isEqual([1, 'hi'], [1, 'hi', 'fail'])).toBe(false);
+      });
+    });
+
+    describe('- objects', () => {
+      test('it should return true if x & y are empty objects', () => {
+        expect(isEqual({}, {})).toBe(true);
+      });
+
+      test('it should return true if x & y are the same object', () => {
+        expect(isEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true);
+      });
+
+      test('it should return false if x & y are the same nested object', () => {
+        expect(
+          isEqual(
+            { 1: { name: 'mhc', age: 28 }, 2: { name: 'arb', age: 26 } },
+            { 1: { name: 'mhc', age: 28 }, 2: { name: 'arb', age: 26 } },
+          ),
+        ).toBe(true);
+      });
+
+      test('it should return false if x & y are not the same nested object', () => {
+        expect(
+          isEqual(
+            { 1: { name: 'mhc', age: 28 }, 2: { name: 'arb', age: 26 } },
+            { 1: { name: 'mhc', age: 28 }, 2: { name: 'arb', age: 27 } },
+          ),
+        ).toBe(false);
+      });
+    });
+  });
+});