@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/reaction/api/addReaction.ts

@@ -1,9 +1,13 @@
 import { getActiveClient } from '~/client/api';
 
-import { upsertInCache, pullFromCache } from '~/cache/api';
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 
-import { dispatchReactable, fetchReference } from '../utils';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { dispatchReactable } from '../utils';
 
+/* begin_public_function
+  id: reaction.add
+*/
 /**
  * ```js
  * import { addReaction } from '@amityco/ts-sdk'
@@ -36,13 +40,23 @@ export const addReaction = async (
     referenceId,
     referenceType,
     reactionName,
+    referenceVersion: referenceType === 'message' ? 5 : undefined,
   });
 
-  const model = await fetchReference(referenceType, referenceId);
-  dispatchReactable(referenceType, model.data);
+  if (client.cache) {
+    const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
 
-  return model.data.myReactions?.includes(reactionName) ?? false;
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
+
+  return true;
 };
+/* end_public_function */
 
 /**
  * ```js
@@ -73,7 +87,7 @@ addReaction.optimistically = (
 
   if (!client.cache) return;
 
-  const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+  const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
     referenceType,
     'get',
     referenceId,
@@ -89,9 +103,11 @@ addReaction.optimistically = (
       ...model.data.reactions,
       [reactionName]: (model.data.reactions[reactionName] ?? 0) + 1,
     },
-  } as Amity.Model[Amity.ReactableType];
+  } as Amity.Models[Amity.ReactableType];
 
-  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
+  upsertInCache([referenceType, 'get', referenceId], reaction, {
+    cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  });
 
   dispatchReactable(referenceType, reaction);
 

package/src/reaction/api/index.ts

@@ -1,2 +1,3 @@
 export * from './addReaction';
 export * from './removeReaction';
+export * from './queryReactions';

package/src/reaction/api/queryReactions.ts

@@ -0,0 +1,58 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { toToken, toPageRaw } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/* begin_public_function
+  id: reaction.query
+*/
+/**
+ * ```js
+ * import { queryReactions } from '@amityco/ts-sdk'
+ * const { data: reactions, prevPage, nextPage } = await queryReactions({
+ *   referenceId: 'postId',
+ *   referenceType: 'post',
+ * })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.ReactionQuery} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Reaction} objects
+ *
+ * @reaction Reaction API
+ * @async
+ * */
+export const queryReactions = async (
+  query: Amity.QueryReactions,
+): Promise<Amity.Paged<Amity.ReactionQuery, Amity.Page<string>>> => {
+  const client = getActiveClient();
+  client.log('reaction/queryReactions', query);
+
+  const { page = { limit: 10 }, ...params } = query ?? {};
+
+  const { data } = await client.http.get<Amity.ReactionPayload & Amity.Pagination>(
+    `/api/v3/reactions`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'afterbeforeraw'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const { reactions } = payload;
+
+  // FIXME: correct reactions type in model
+  // @ts-ignore
+  ingestInCache({ ...payload, reactions: reactions[0].reactors });
+
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
+
+  return { data: reactions, prevPage, nextPage };
+};
+/* end_public_function */

package/src/reaction/api/removeReaction.ts

@@ -1,9 +1,14 @@
 import { getActiveClient } from '~/client/api';
 
-import { upsertInCache, pullFromCache } from '~/cache/api';
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 
-import { dispatchReactable, fetchReference } from '../utils';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
 
+import { dispatchReactable } from '../utils';
+
+/* begin_public_function
+  id: reaction.remove
+*/
 /**
  * ```js
  * import { deleteReaction } from '@amityco/ts-sdk'
@@ -33,14 +38,28 @@ export const removeReaction = async (
   });
 
   await client.http.delete<{ removedId: string }>(`/api/v2/reactions`, {
-    data: { referenceId, referenceType, reactionName },
+    data: {
+      referenceId,
+      referenceType,
+      reactionName,
+      referenceVersion: referenceType === 'message' ? 5 : undefined,
+    },
   });
 
-  const model = await fetchReference(referenceType, referenceId);
-  dispatchReactable(referenceType, model.data);
+  if (client.cache) {
+    const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
 
-  return !model.data.myReactions?.includes(reactionName) ?? false;
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
+
+  return true;
 };
+/* end_public_function */
 
 /**
  * ```js
@@ -71,7 +90,7 @@ removeReaction.optimistically = (
 
   if (!client.cache) return;
 
-  const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+  const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
     referenceType,
     'get',
     referenceId,
@@ -87,9 +106,11 @@ removeReaction.optimistically = (
       ...model.data.reactions,
       [reactionName]: Math.max(0, (model.data.reactions[reactionName] ?? 0) - 1),
     },
-  } as Amity.Model[Amity.ReactableType];
+  } as Amity.Models[Amity.ReactableType];
 
-  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
+  upsertInCache([referenceType, 'get', referenceId], reaction, {
+    cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  });
 
   dispatchReactable(referenceType, reaction);
 

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

@@ -0,0 +1,73 @@
+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';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+
+const cacheKey = ['message', 'get', message.messageId];
+
+describe('addReaction', () => {
+  test('it 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);
+  });
+
+  test('it should update cache after adding reaction', async () => {
+    enableCache();
+
+    pushToCache(cacheKey, message);
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+
+    const success = await addReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBeDefined();
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(-1);
+
+    disableCache();
+  });
+});
+
+describe('addReaction > optimistically', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(addReaction.optimistically('message', message.messageId, 'like')).toBeUndefined();
+  });
+
+  test('it should optimistically add a reaction', async () => {
+    const callback = jest.fn();
+    pushToCache(cacheKey, message);
+    onMessageUpdated(callback);
+
+    const success = 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('it should mark optimistic object as unsynced', async () => {
+    pushToCache(cacheKey, message);
+
+    const success = addReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+  });
+});

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

@@ -0,0 +1,79 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { onMessageUpdated } from '~/message/events';
+import { removeReaction } from '~/reaction/api';
+
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { client, message11, pause } from '~/utils/tests';
+
+const message = {
+  ...message11,
+  myReactions: ['like'],
+  reactions: { like: 1 },
+  reactionsCount: 1,
+};
+const cacheKey = ['message', 'get', message.messageId];
+
+describe('removeReaction', () => {
+  test('it should remove a reaction', async () => {
+    client.http.delete = jest.fn().mockResolvedValue({ data: { removedId: 'reactionId' } });
+
+    const success = await removeReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+  });
+
+  test('it should update cache after adding reaction', async () => {
+    enableCache();
+
+    pushToCache(cacheKey, message);
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+
+    const success = await removeReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBeDefined();
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(-1);
+
+    disableCache();
+  });
+});
+
+describe('removeReaction > optimistically', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(removeReaction.optimistically('message', message.messageId, 'like')).toBeUndefined();
+  });
+
+  test('it should optimistically remove a reaction', async () => {
+    const callback = jest.fn();
+    pushToCache(cacheKey, message);
+    onMessageUpdated(callback);
+
+    const success = 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('it should mark optimistic object as unsynced', async () => {
+    pushToCache(cacheKey, message);
+
+    const success = removeReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+  });
+});

package/src/reaction/events/index.ts

@@ -1 +1,5 @@
+export * from './onReactionAdded';
 export * from './onReactionRemoved';
+
+export * from './onReactorAdded';
+export * from './onReactorRemoved';

package/src/reaction/events/onReactionAdded.ts

@@ -5,6 +5,7 @@ import { createEventSubscriber } from '~/core/events';
 import { getResolver } from '~/core/model';
 import { onPostReactionAdded } from '~/post/events';
 import { onCommentReactionAdded } from '~/comment/events';
+import { prepareMessagePayload } from '~/message/utils';
 
 /**
  * ```js
@@ -26,18 +27,23 @@ import { onCommentReactionAdded } from '~/comment/events';
 export const onReactionAdded = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  callback: Amity.Listener<Amity.Model[typeof referenceType]>,
+  callback: Amity.Listener<Amity.Models[typeof referenceType]>,
 ): Amity.Unsubscriber => {
-  const callbackWrapper = (model: Amity.Model[typeof referenceType]) => {
+  const callbackWrapper = (model: Amity.Models[typeof referenceType]) => {
     if (getResolver(referenceType)(model as any) === referenceId) {
       callback(model);
     }
   };
 
+  /*
+   * Important: Want to point out that reference type will never be 'message'
+   * for onReactionAdded
+   */
   if (referenceType === 'message') {
     const client = getActiveClient();
 
-    const filter = (payload: Amity.MessagePayload) => {
+    const filter = (rawPayload: Amity.MessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
       const cached = pullFromCache<Amity.Message>([
         'message',
         'get',
@@ -52,12 +58,7 @@ export const onReactionAdded = (
       }
     };
 
-    return createEventSubscriber(
-      client,
-      'reaction/onReactionAdded',
-      'v3.message.didUpdate',
-      filter,
-    );
+    return createEventSubscriber(client, 'reaction/onReactionAdded', 'message.updated', filter);
   }
 
   if (referenceType === 'post') {

package/src/reaction/events/onReactionRemoved.ts

@@ -5,6 +5,7 @@ import { createEventSubscriber } from '~/core/events';
 import { getResolver } from '~/core/model';
 import { onPostReactionRemoved } from '~/post/events';
 import { onCommentReactionRemoved } from '~/comment/events';
+import { prepareMessagePayload } from '~/message/utils';
 
 /**
  * ```js
@@ -26,9 +27,9 @@ import { onCommentReactionRemoved } from '~/comment/events';
 export const onReactionRemoved = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  callback: Amity.Listener<Amity.Model[typeof referenceType]>,
+  callback: Amity.Listener<Amity.Models[typeof referenceType]>,
 ): Amity.Unsubscriber => {
-  const callbackWrapper = (model: Amity.Model[typeof referenceType]) => {
+  const callbackWrapper = (model: Amity.Models[typeof referenceType]) => {
     if (getResolver(referenceType)(model as any) === referenceId) {
       callback(model);
     }
@@ -37,7 +38,8 @@ export const onReactionRemoved = (
   if (referenceType === 'message') {
     const client = getActiveClient();
 
-    const filter = (payload: Amity.MessagePayload) => {
+    const filter = (rawPayload: Amity.MessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
       const cached = pullFromCache<Amity.Message>([
         'message',
         'get',
@@ -52,12 +54,7 @@ export const onReactionRemoved = (
       }
     };
 
-    return createEventSubscriber(
-      client,
-      'reaction/onReactionRemoved',
-      'v3.message.didUpdate',
-      filter,
-    );
+    return createEventSubscriber(client, 'reaction/onReactionRemoved', 'message.updated', filter);
   }
 
   if (referenceType === 'post') {

package/src/reaction/events/onReactorAdded.ts

@@ -0,0 +1,88 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '~/message/utils';
+
+/**
+ * ```js
+ * import { onReactorAdded } from '@amityco/ts-sdk'
+ * const dispose = onReactorAdded('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reactor} has been added
+ *
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Events
+ * */
+export const onReactorAdded = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Reactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.Reactor,
+  ) => {
+    if (referenceType_ === referenceType && referenceId_ === referenceId) {
+      callback(reaction);
+    }
+  };
+
+  if (referenceType === 'message') {
+    const filter = (rawPayload: Amity.MessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
+      if (!payload.messages[0].latestReaction) return;
+
+      const { eventName, referenceId, referenceType, userDisplayName, ...reactor } =
+        payload.messages[0].latestReaction;
+
+      if (eventName !== 'add') return;
+
+      ingestInCache(payload);
+      // FIXME: correct reactions type in model
+      // @ts-ignore
+      ingestInCache({ reactions: [reactor as Amity.Reactor] });
+
+      callbackWrapper('message', payload.messages[0].messageId, reactor);
+    };
+
+    return createEventSubscriber(client, 'reaction/onReactorAdded', 'message.updated', filter);
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.Reactor }) => {
+      const { reactor, ...rest } = payload;
+
+      ingestInCache(rest as Amity.ProcessedPostPayload);
+      // FIXME: correct reactions type in model
+      // @ts-ignore
+      ingestInCache({ reactions: [reactor] });
+
+      callbackWrapper('post', payload.posts[0].postId, reactor);
+    };
+
+    return createEventSubscriber(client, 'post.addReaction', 'post.addReaction', filter);
+  }
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+    const { reactor, ...rest } = payload;
+
+    ingestInCache(rest as Amity.CommentPayload);
+    // FIXME: correct reactions type in model
+    // @ts-ignore
+    ingestInCache({ reactions: [reactor] });
+
+    callbackWrapper('comment', payload.comments[0].commentId, reactor);
+  };
+
+  return createEventSubscriber(client, 'comment.addReaction', 'comment.addReaction', filter);
+};

package/src/reaction/events/onReactorRemoved.ts

@@ -0,0 +1,88 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '~/message/utils';
+
+/**
+ * ```js
+ * import { onReactorRemoved } from '@amityco/ts-sdk'
+ * const dispose = onReactorRemoved('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reactor} has been removed
+ *
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Events
+ * */
+export const onReactorRemoved = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Reactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.Reactor,
+  ) => {
+    if (referenceType_ === referenceType && referenceId_ === referenceId) {
+      callback(reaction);
+    }
+  };
+
+  if (referenceType === 'message') {
+    const filter = (rawPayload: Amity.MessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
+      if (!payload.messages[0].latestReaction) return;
+
+      const { eventName, referenceId, referenceType, ...reactor } =
+        payload.messages[0].latestReaction;
+
+      if (eventName !== 'remove') return;
+
+      ingestInCache(payload);
+      // FIXME: correct reactions type in model
+      // @ts-ignore
+      ingestInCache({ reactions: [reactor as Amity.Reactor] });
+
+      callbackWrapper('message', payload.messages[0].messageId, reactor);
+    };
+
+    return createEventSubscriber(client, 'reaction/onReactorRemoved', 'message.updated', filter);
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.Reactor }) => {
+      const { reactor, ...rest } = payload;
+
+      ingestInCache(rest as Amity.ProcessedPostPayload);
+      // FIXME: correct reactions type in model
+      // @ts-ignore
+      ingestInCache({ reactions: [reactor] });
+
+      callbackWrapper('post', payload.posts[0].postId, reactor);
+    };
+
+    return createEventSubscriber(client, 'post.removeReaction', 'post.removeReaction', filter);
+  }
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+    const { reactor, ...rest } = payload;
+
+    ingestInCache(rest as Amity.CommentPayload);
+    // FIXME: correct reactions type in model
+    // @ts-ignore
+    ingestInCache({ reactions: [reactor] });
+
+    callbackWrapper('comment', payload.comments[0].commentId, reactor);
+  };
+
+  return createEventSubscriber(client, 'comment.removeReaction', 'comment.removeReaction', filter);
+};

package/src/reaction/observers/index.ts

@@ -0,0 +1 @@
+export * from './liveReactions';