@amityco/ts-sdk 0.0.1-beta.30 → 0.0.1-beta.32

package/src/reaction/api/removeReaction.ts

@@ -36,10 +36,7 @@ export const removeReaction = async (
     data: { referenceId, referenceType, reactionName },
   });
 
-  const model = await fetchReference(referenceType, referenceId);
-  dispatchReactable(referenceType, model.data);
-
-  return !model.data.myReactions?.includes(reactionName) ?? false;
+  return true;
 };
 
 /**

package/src/reaction/api/tests/addReaction.test.ts

@@ -0,0 +1,37 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { onMessageUpdated } from '~/message/events';
+import { addReaction } from '~/reaction/api';
+import { client, message11 as message, pause } from '~/utils/tests';
+
+describe('addReaction', () => {
+  const cacheKey = ['message', 'get', message.messageId];
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should optimistically add a reaction', async () => {
+    const callback = jest.fn();
+    pushToCache(cacheKey, message);
+    onMessageUpdated(callback);
+
+    const success = await addReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.data).toMatchObject({
+      myReactions: ['like'],
+      reactions: { like: 1 },
+      reactionsCount: 1,
+    });
+    await pause();
+    expect(callback).toBeCalledTimes(1);
+  });
+
+  test('should add a reaction', async () => {
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+
+    const success = await addReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+  });
+});

package/src/reaction/api/tests/removeReaction.test.ts

@@ -0,0 +1,43 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { onMessageUpdated } from '~/message/events';
+import { removeReaction } from '~/reaction/api';
+import { client, message11 as message, message11, pause } from '~/utils/tests';
+
+describe('removeReaction', () => {
+  const message = {
+    ...message11,
+    myReactions: ['like'],
+    reactions: { like: 1 },
+    reactionsCount: 1,
+  };
+  const cacheKey = ['message', 'get', message.messageId];
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should optimistically add a reaction', async () => {
+    const callback = jest.fn();
+    pushToCache(cacheKey, message);
+    onMessageUpdated(callback);
+
+    const success = await removeReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.data).toMatchObject({
+      myReactions: [],
+      reactions: { like: 0 },
+      reactionsCount: 0,
+    });
+    await pause();
+    expect(callback).toBeCalledTimes(1);
+  });
+
+  test('should add a reaction', async () => {
+    client.http.delete = jest.fn().mockResolvedValue({ data: { removedId: 'reactionId' } });
+
+    const success = await removeReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+  });
+});

package/src/user/api/getUser.ts

@@ -2,6 +2,11 @@ import { getActiveClient } from '~/client/api';
 
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 /**
  * ```js
@@ -17,20 +22,42 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * @category User API
  * @async
  */
-export const getUser = async (userId: Amity.User['userId']): Promise<Amity.Cached<Amity.User>> => {
+export const getUser = async (
+  userId: Amity.User['userId'],
+  isLive = false,
+): Promise<Amity.Cached<Amity.User>> => {
   const client = getActiveClient();
   client.log('user/getUser', userId);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.UserPayload>(
-    `/api/v3/users/${encodeURIComponent(userId)}`,
-  );
+  if (!isLive) {
+    console.log('getUser will be deprecated on 25th November 2022, please use liveUser instead.');
+  }
+
+  isInTombstone('user', userId);
+
+  let data: Amity.UserPayload;
+
+  try {
+    const response = await client.http.get<Amity.UserPayload>(
+      `/api/v3/users/${encodeURIComponent(userId)}`,
+    );
+
+    data = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('user', userId);
+    }
+
+    throw error;
+  }
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
   const { users } = data;
 
+  fireEvent('user.fetched', data);
+
   return {
     data: users.find(user => user.userId === userId)!,
     cachedAt,

package/src/user/api/getUsers.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -33,6 +34,8 @@ export const getUsers = async (
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
+  fireEvent('user.fetched', data);
+
   return {
     data: data.users,
     cachedAt,

package/src/user/api/queryUsers.ts

@@ -5,6 +5,7 @@ import { toPage, toToken } from '~/core/query';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -32,9 +33,14 @@ export const queryUsers = async (
   const client = getActiveClient();
   client.log('user/queryUsers', query);
 
-  const { page, displayName, filter = 'all', sortBy = 'displayName', ...params } = query;
+  const {
+    page = { limit: 10 },
+    displayName,
+    filter = 'all',
+    sortBy = 'displayName',
+    ...params
+  } = query;
 
-  // API-FIX: parameters should be querystring.
   const { data } = await client.http.get<Amity.UserPayload & Amity.Pagination>(`/api/v3/users`, {
     params: {
       ...params,
@@ -56,10 +62,16 @@ export const queryUsers = async (
   if (client.cache) {
     ingestInCache(payload as Amity.UserPayload, { cachedAt });
 
-    const cacheKey = ['user', 'query', query as Amity.Serializable];
+    /*
+     * using query as cache key over params because if the keyword, filter, sort
+     * change the API will NOT cache results, when it should
+     */
+    const cacheKey = ['user', 'query', { ...query, options: { ...page } } as Amity.Serializable];
     pushToCache(cacheKey, { users: users.map(getResolver('user')), paging });
   }
 
+  fireEvent('user.fetched', data);
+
   const prevPage = toPage(paging.previous);
   const nextPage = toPage(paging.next);
 
@@ -88,9 +100,19 @@ queryUsers.locally = (
 
   if (!client.cache) return;
 
-  const queryKey = ['user', 'query', query as Amity.Serializable];
+  const { page = { limit: 10 } } = query ?? {};
+
+  const cacheKey = [
+    'user',
+    'query',
+    {
+      ...query,
+      options: { ...page },
+    } as Amity.Serializable,
+  ];
+
   const { data, cachedAt } =
-    pullFromCache<{ users: Pick<Amity.User, 'userId'>[] } & Amity.Pagination>(queryKey) ?? {};
+    pullFromCache<{ users: Pick<Amity.User, 'userId'>[] } & Amity.Pagination>(cacheKey) ?? {};
 
   const users: Amity.User[] =
     data?.users

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

@@ -0,0 +1,124 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { client, userQueryResponse } from '~/utils/tests';
+
+import { queryUsers } from '../queryUsers';
+
+describe('queryUsers', () => {
+  test('it should return users', async () => {
+    const { users: expected } = userQueryResponse.data;
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    const { data } = await queryUsers();
+
+    expect(data).toEqual(expected);
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryUsers()).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    const { data: expected } = await queryUsers();
+    const { data: received } = queryUsers.locally()!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+
+    disableCache();
+  });
+});
+
+describe('queryUsers.locally', () => {
+  const cacheKey = [
+    'user',
+    'query',
+    { options: { limit: 10, after: undefined } } as Amity.Serializable,
+  ];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { data } = userQueryResponse;
+    const { users: expected, paging } = data;
+
+    ingestInCache(data as Amity.UserPayload);
+
+    pushToCache(cacheKey, { users: expected.map(getResolver('user')), paging });
+
+    const { data: received } = queryUsers.locally()!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { data } = userQueryResponse;
+    const { users, paging } = data;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...data,
+      users: [data.users[0]],
+    } as Amity.UserPayload);
+
+    pushToCache(cacheKey, {
+      users: users.map(getResolver('user')),
+      paging,
+    });
+
+    const received = queryUsers.locally()!;
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  // added because of comment above cache key in queryUsers
+  test('it should return undefined if params do not match', () => {
+    enableCache();
+
+    const { data } = userQueryResponse;
+    const { users: expected, paging } = data;
+
+    ingestInCache(data as Amity.UserPayload);
+
+    pushToCache(cacheKey, { users: expected.map(getResolver('user')), paging });
+
+    const { data: received } = queryUsers.locally()!;
+    const received2 = queryUsers.locally({ displayName: 'test' })!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+    expect(received2).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const received = queryUsers.locally();
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryUsers.locally()).toBeUndefined();
+  });
+});

package/src/user/api/updateUser.ts

@@ -1,5 +1,6 @@
 import { getActiveClient } from '~/client/api';
 
+import { fireEvent } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
@@ -45,6 +46,8 @@ export const updateUser = async (
 
   const { users } = data;
 
+  fireEvent('user.updated', data);
+
   return {
     data: users.find(user => user.userId === userId)!,
     cachedAt,

package/src/user/events/index.ts

@@ -1,3 +1,4 @@
+export * from './onUserFetched';
 export * from './onUserUpdated';
 export * from './onUserDeleted';
 

package/src/user/events/onUserFetched.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserFetched } from '@amityco/ts-sdk'
+ * const dispose = onUserFetched(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserFetched = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.fetched', callback);

package/src/user/observers/index.ts

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

package/src/user/observers/liveUser.ts

@@ -0,0 +1,89 @@
+import { getActiveClient } from '~/client/api';
+import { createQuery, runQuery } from '~/core/query';
+
+import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import {
+  onUserFetched,
+  onUserDeleted,
+  onUserUpdated,
+  onUserFlagCleared,
+  onUserFlagged,
+  onUserUnflagged,
+} from '../events';
+import { getUser } from '../api';
+
+/**
+ * ```js
+ * import { liveUser } from '@amityco/ts-sdk'
+ *
+ * let users = []
+ * const unsub = liveUser(userId, response => merge(users, response.data))
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.User}
+ *
+ * @param userId the ID of the user to observe
+ * @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 Message Live Object
+ */
+export const liveUser = (
+  userId: Amity.User['userId'],
+  callback: Amity.LiveObjectCallback<Amity.User>,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+  let user: Amity.User;
+
+  if (!cache) {
+    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveUser(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const dispatcher = (data: Amity.LiveObject<Amity.User>) => {
+    // we check updatedAt to see if the current snapshot is new so
+    // we won't send old data back, only fresh new data
+    if (user && data.data?.updatedAt === user?.updatedAt && data.origin !== 'server') return;
+
+    callback(data);
+    user = data.data;
+  };
+
+  const realtimeRouter = (user: Amity.User, action: Amity.UserActionType) => {
+    dispatcher({ loading: false, data: user, origin: 'event' });
+  };
+
+  const onFetch = () => {
+    const query = createQuery(getUser, userId, true);
+
+    runQuery(query, ({ loading, data, error, origin }) => {
+      dispatcher({ loading, data, origin, error });
+
+      if (error) {
+        // Terminate observe functionality on error
+        disposers.forEach(fn => fn());
+      }
+    });
+  };
+
+  disposers.push(
+    onUserFetched(user => realtimeRouter(user, 'onFetch')),
+    onUserUpdated(user => realtimeRouter(user, 'onUpdate')),
+    onUserDeleted(user => realtimeRouter(user, 'onDelete')),
+    onUserFlagged(user => realtimeRouter(user, 'onFlagged')),
+    onUserUnflagged(user => realtimeRouter(user, 'onUnflagged')),
+    onUserFlagCleared(user => realtimeRouter(user, 'onFlagCleared')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveUser(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/user/observers/observeUser.ts

@@ -37,6 +37,8 @@ export const observeUser = <
   const timestamp = Date.now();
   log(`observeUser(tmpid: ${timestamp}) > listen`);
 
+  console.log('observeUser will be deprecated on 25th November 2022, please use liveUser instead.');
+
   // wrapper function to make sure
   const router = (result: Amity.Snapshot<Amity.User>, action: Events[number]) => {
     // filter function

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

@@ -0,0 +1,112 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { client, user11 } from '~/utils/tests';
+
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+
+import { getUser } from '../../api/getUser';
+
+const user = user11;
+const getResolvedUserValue = () => ({
+  data: {
+    users: [user],
+    files: [],
+  },
+});
+
+describe('getUser', () => {
+  test('should return user data', async () => {
+    client.http.get = jest.fn().mockResolvedValue(getResolvedUserValue());
+
+    const { data } = await getUser(user.userId);
+
+    expect(data).toStrictEqual(user);
+  });
+
+  test('it should update cache after fetch from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(getResolvedUserValue());
+    await getUser(user.userId);
+
+    expect(getUser.locally(user.userId)).toBeDefined();
+
+    disableCache();
+  });
+
+  test('should return an error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getUser(user.userId)).rejects.toThrow('error');
+  });
+
+  test('should return an error if user in cache but api throws not found', async () => {
+    enableCache();
+    pushToCache(['user', 'get', user.userId], user, { cachedAt: Date.now() });
+
+    client.http.get = jest
+
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getUser(user.userId)).rejects.toThrow();
+
+    expect(getUser.locally(user.userId)).toBeUndefined();
+    disableCache();
+  });
+});
+
+describe('getUser locally', () => {
+  test('should return data from cache', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['user', 'get', user.userId], user, { cachedAt });
+
+    const data = getUser.locally(user.userId);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(user);
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+
+  test('should return undefined if user not in cache', () => {
+    expect(getUser.locally('non-existent-user')).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    expect(getUser.locally(user.userId)).toBeUndefined();
+  });
+});
+
+describe('getUser tombostone', () => {
+  test('it should add user to tombostone if 404', async () => {
+    enableCache();
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getUser(user.userId)).rejects.toThrow();
+    expect(() => {
+      isInTombstone('user', user.userId);
+    }).toThrow();
+
+    disableCache();
+  });
+
+  test('it should throw error if user not found in tombostone', async () => {
+    enableCache();
+
+    pushToTombstone('user', user.userId);
+    await expect(getUser(user.userId)).rejects.toThrow();
+
+    disableCache();
+  });
+});