@amityco/ts-sdk 0.0.1-beta.3 → 0.0.1-beta.31

package/src/user/api/updateUser.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { fireEvent } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -20,10 +20,13 @@ import { ingestInCache } from '~/core/cache'
  */
 export const updateUser = async (
   userId: Amity.User['userId'],
-  patch: Patch<Amity.User, 'displayName' | 'description' | 'avatarFileId' | 'metadata'>,
-) => {
-  const client = getActiveClient()
-  client.log('user/updateUser', userId, patch)
+  patch: Patch<
+    Amity.User,
+    'displayName' | 'description' | 'avatarFileId' | 'avatarCustomUrl' | 'metadata'
+  >,
+): Promise<Amity.Cached<Amity.User>> => {
+  const client = getActiveClient();
+  client.log('user/updateUser', userId, patch);
 
   // API-FIX: Endpoint is malformed, userId should be a url param.
   /*
@@ -32,13 +35,21 @@ export const updateUser = async (
     )
   */
 
-  const { data } = await client.http.put<Amity.UserPayload>(
-    `/api/v3/users/`, { userId, ...patch, createNewUserWhenNotFound: false },
-  )
+  const { data } = await client.http.put<Amity.UserPayload>(`/api/v3/users/`, {
+    userId,
+    ...patch,
+    createNewUserWhenNotFound: false,
+  });
 
-  decoratePayload(data)
-  ingestInCache(data)
-  // no need for event, fired by server
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  return data.users.find(user => user.userId === userId)!
-}
+  const { users } = data;
+
+  fireEvent('user.updated', data);
+
+  return {
+    data: users.find(user => user.userId === userId)!,
+    cachedAt,
+  };
+};

package/src/user/events/index.ts

@@ -1 +1,7 @@
-export * from './onUserUpdated'
+export * from './onUserFetched';
+export * from './onUserUpdated';
+export * from './onUserDeleted';
+
+export * from './onUserFlagged';
+export * from './onUserUnflagged';
+export * from './onUserFlagCleared';

package/src/user/events/onUserDeleted.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserDeleted } from '@amityco/ts-sdk'
+ * const dispose = onUserDeleted(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been deleted
+ *
+ * @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 onUserDeleted = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.deleted', callback);

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/events/onUserFlagCleared.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserFlagCleared } from '@amityco/ts-sdk'
+ * const dispose = onUserFlagCleared(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when flags have been cleared for a {@link Amity.User}
+ *
+ * @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 onUserFlagCleared = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.flagCleared', callback);

package/src/user/events/onUserFlagged.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserFlagged } from '@amityco/ts-sdk'
+ * const dispose = onUserFlagged(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been flagged
+ *
+ * @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 onUserFlagged = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.flagged', callback);

package/src/user/events/onUserUnflagged.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onUserUnflagged(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.User}
+ *
+ * @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 onUserUnflagged = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.unflagged', callback);

package/src/user/events/onUserUpdated.ts

@@ -1,8 +1,4 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { createUserEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -12,28 +8,12 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when any {@link Amity.User} have been updated
+ * Fired when a {@link Amity.User} has been updated
  *
  * @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 onUserUpdated = (
-  callback: Amity.Listener<Amity.User>
-) => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.UserPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.users[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'user/onUserUpdate',
-    'v3.user.didUpdate',
-    filter
-  )
-}
+export const onUserUpdated = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.updated', callback);

package/src/user/events/utils.ts

@@ -0,0 +1,21 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+export const createUserEventSubscriber = (
+  event: keyof Amity.MqttUserMessageEvents,
+  callback: Amity.Listener<Amity.User>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.UserPayload) => {
+    if (client.cache) {
+      ingestInCache(payload);
+    }
+
+    callback(payload.users[0]);
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/user/observers/index.ts

@@ -1 +1,2 @@
-export { observeUser } from './observeUser'
+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

@@ -1,9 +1,15 @@
-import { createQuery, runQuery } from '~/core/query/query'
+import { createQuery, runQuery } from '~/core/query/query';
 
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { getUser } from '../api'
-import { onUserUpdated } from '../events'
+import { getUser } from '../api';
+import {
+  onUserUpdated,
+  onUserDeleted,
+  onUserFlagged,
+  onUserUnflagged,
+  onUserFlagCleared,
+} from '../events';
 
 /**
  * ```js
@@ -20,45 +26,45 @@ import { onUserUpdated } from '../events'
  * Observe all mutation on a given {@link Amity.User}
  * @category User Observer
  */
-export const observeUser = <Events extends ['onFetch', 'onUpdate']>(
+export const observeUser = <
+  Events extends ['onFetch', 'onUpdate', 'onDelete', 'onFlagged', 'onUnflagged', 'onFlagCleared'],
+>(
   userId: string,
-  callback: Amity.ObjectListener<Amity.QueryResult<Amity.User>, Events>,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.User>, Events>,
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observeUser(tmpid: ${timestamp}) > listen`)
+  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.QueryResult<Amity.User>,
-    action: Events[number]
-  ) => {
+  const router = (result: Amity.Snapshot<Amity.User>, action: Events[number]) => {
     // filter function
-    if (result.data?.userId !== userId) return
+    if (result.data?.userId !== userId) return;
 
-    if (callback instanceof Function)
-      return callback(result)
+    if (callback instanceof Function) return callback(result);
 
-    if (action !== 'onFetch')
-      callback.onEvent?.(action, result)
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
 
-    callback[action]?.(result)
-  }
+    callback[action]?.(result);
+  };
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
   disposers.push(
-    onUserUpdated(data => router({ data }, 'onUpdate'))
-  )
+    onUserUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onUserDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onUserFlagged(data => router({ data, loading: false, origin: 'event' }, 'onFlagged')),
+    onUserUnflagged(data => router({ data, loading: false, origin: 'event' }, 'onUnflagged')),
+    onUserFlagCleared(data => router({ data, loading: false, origin: 'event' }, 'onFlagCleared')),
+  );
 
-  runQuery(
-    createQuery(getUser, userId),
-    (result) => result.data && router(result, 'onFetch'),
-  )
+  runQuery(createQuery(getUser, userId), result => result.data && router(result, 'onFetch'));
 
   return () => {
-    log(`observeUser(tmpid: ${timestamp}) > dispose`)
-    disposers.forEach(fn => fn())
-  }
-}
+    log(`observeUser(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

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