@amityco/ts-sdk 0.0.1 → 6.0.0

package/src/reaction/api/addReaction.ts

@@ -1,9 +1,13 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { mutateCache } from '~/core/cache'
+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'
@@ -19,29 +23,40 @@ import { dispatchReactable, fetchReference } from '../utils'
  *
  * @category Reaction API
  * @async
- **/
+ * */
 export const addReaction = async (
   referenceType: Amity.Reaction['referenceType'],
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName']
-) => {
-  const client = getActiveClient()
+  reactionName: Amity.Reaction['reactionName'],
+): Promise<boolean> => {
+  const client = getActiveClient();
   client.log('reaction/createReaction', {
     referenceId,
     referenceType,
     reactionName,
-  })
+  });
 
-  await client.http.post<{ addedId: 'string' }>(
-    '/api/v2/reactions',
-    { referenceId, referenceType, reactionName }
-  )
+  await client.http.post<{ addedId: 'string' }>('/api/v2/reactions', {
+    referenceId,
+    referenceType,
+    reactionName,
+    referenceVersion: referenceType === 'message' ? 5 : undefined,
+  });
+
+  if (client.cache) {
+    const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
 
-  const model = await fetchReference(referenceType, referenceId)
-  dispatchReactable(referenceType, model)
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
 
-  return model.myReactions?.includes(reactionName) ?? false
-}
+  return true;
+};
+/* end_public_function */
 
 /**
  * ```js
@@ -57,28 +72,44 @@ export const addReaction = async (
  * @returns The added result.
  *
  * @category Reaction API
- **/
+ * */
 addReaction.optimistically = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName']
-) => {
-  const model = mutateCache(referenceType, referenceId, model => {
-    if (model.myReactions?.includes(reactionName)) return
+  reactionName: Amity.Reaction['reactionName'],
+): boolean | undefined => {
+  const client = getActiveClient();
+  client.log('reaction/createReaction.optimistically', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  if (!client.cache) return;
+
+  const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+    referenceType,
+    'get',
+    referenceId,
+  ]);
+
+  if (!model?.data || model.data.myReactions?.includes(reactionName)) return;
+
+  const reaction = {
+    ...model.data,
+    reactionsCount: model.data.reactionsCount + 1,
+    myReactions: [...(model.data.myReactions ?? []), reactionName],
+    reactions: {
+      ...model.data.reactions,
+      [reactionName]: (model.data.reactions[reactionName] ?? 0) + 1,
+    },
+  } as Amity.Models[Amity.ReactableType];
 
-    return {
-      ...model,
-      syncedAt: -1,
-      reactionsCount: model.reactionsCount + 1,
-      myReactions: [...(model.myReactions ?? []), reactionName],
-      reactions: {
-        ...model.reactions,
-        [reactionName]: (model.reactions[reactionName] ?? 0) + 1,
-      },
-    }
-  })
+  upsertInCache([referenceType, 'get', referenceId], reaction, {
+    cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  });
 
-  model && dispatchReactable(referenceType, model)
+  dispatchReactable(referenceType, reaction);
 
-  return model?.myReactions?.includes(reactionName) ?? false
-}
+  return reaction?.myReactions?.includes(reactionName) ?? false;
+};

package/src/reaction/api/index.ts

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

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 { getActiveClient } from '~/client/api';
 
-import { mutateCache } from '~/core/cache'
+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'
@@ -19,29 +24,42 @@ import { dispatchReactable, fetchReference } from '../utils'
  *
  * @category Reaction API
  * @async
- **/
+ * */
 export const removeReaction = async (
   referenceType: Amity.Reaction['referenceType'],
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName']
-) => {
-  const client = getActiveClient()
+  reactionName: Amity.Reaction['reactionName'],
+): Promise<boolean> => {
+  const client = getActiveClient();
   client.log('reaction/removeReaction', {
     referenceId,
     referenceType,
     reactionName,
-  })
+  });
+
+  await client.http.delete<{ removedId: string }>(`/api/v2/reactions`, {
+    data: {
+      referenceId,
+      referenceType,
+      reactionName,
+      referenceVersion: referenceType === 'message' ? 5 : undefined,
+    },
+  });
 
-  await client.http.delete<{ removedId: string }>(
-    `/api/v2/reactions`,
-    { data: { referenceId, referenceType, reactionName } }
-  )
+  if (client.cache) {
+    const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
 
-  const model = await fetchReference(referenceType, referenceId)
-  dispatchReactable(referenceType, model)
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
 
-  return !model.myReactions?.includes(reactionName) ?? false
-}
+  return true;
+};
+/* end_public_function */
 
 /**
  * ```js
@@ -57,28 +75,44 @@ export const removeReaction = async (
  * @returns The added result.
  *
  * @category Reaction API
- **/
+ * */
 removeReaction.optimistically = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName']
-) => {
-  const model = mutateCache(referenceType, referenceId, model => {
-    if (!model.myReactions?.includes(reactionName)) return
-
-    return {
-      ...model,
-      syncedAt: -1,
-      reactionsCount: Math.max(0, model.reactionsCount - 1),
-      myReactions: (model.myReactions ?? []).filter(item => item !== reactionName),
-      reactions: {
-        ...model.reactions,
-        [reactionName]: Math.max(0, (model.reactions[reactionName] ?? 0) - 1),
-      },
-    }
-  })
-
-  model && dispatchReactable(referenceType, model)
-
-  return !model?.myReactions?.includes(reactionName) ?? false
-}
+  reactionName: Amity.Reaction['reactionName'],
+): boolean | undefined => {
+  const client = getActiveClient();
+  client.log('reaction/removeReaction.optimistically', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  if (!client.cache) return;
+
+  const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+    referenceType,
+    'get',
+    referenceId,
+  ]);
+
+  if (!model?.data || !model.data.myReactions?.includes(reactionName)) return;
+
+  const reaction = {
+    ...model.data,
+    reactionsCount: Math.max(0, model.data.reactionsCount - 1),
+    myReactions: (model.data.myReactions ?? []).filter(item => item !== reactionName),
+    reactions: {
+      ...model.data.reactions,
+      [reactionName]: Math.max(0, (model.data.reactions[reactionName] ?? 0) - 1),
+    },
+  } as Amity.Models[Amity.ReactableType];
+
+  upsertInCache([referenceType, 'get', referenceId], reaction, {
+    cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  });
+
+  dispatchReactable(referenceType, reaction);
+
+  return !reaction?.myReactions?.includes(reactionName) ?? false;
+};

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

@@ -0,0 +1,86 @@
+import { ASCApiError } from '~/core/errors';
+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', () => {
+  // integration_test_id: 6252e6ed-afd7-460f-a285-f95650ec513a
+  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);
+  });
+
+  // integration_test_id: ddc6da15-cfa3-4f54-ad52-be50c2841d6e
+  test('it should throw 400400 when resource not found', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(addReaction('message', message.messageId, 'like')).rejects.toThrow();
+  });
+
+  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,92 @@
+import { ASCApiError } from '~/core/errors';
+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', () => {
+  // integration_test_id: dda62dbf-7649-4f1e-b264-0f79984ae1c8
+  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);
+  });
+
+  // integration_test_id: b5ab2716-044c-488a-839e-4a7517e58ca9
+  test('it should throw 400400 when resource not found', async () => {
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(removeReaction('message', message.messageId, 'like')).rejects.toThrow();
+  });
+
+  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 './onReactionRemoved'
+export * from './onReactionAdded';
+export * from './onReactionRemoved';
+
+export * from './onReactorAdded';
+export * from './onReactorRemoved';

package/src/reaction/events/onReactionAdded.ts

@@ -1,43 +1,69 @@
-import { getActiveClient } from '~/client/api'
-import { ingestInCache } from '~/core/cache'
-import { createEventSubscriber } from '~/core/events'
-import { decoratePayload } from '~/core/query'
+import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+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
  * import { onReactionAdded } from '@amityco/ts-sdk'
- * const dispose = onReactionAdded(message => {
+ * const dispose = onReactionAdded('post', postId, post => {
  *   // ...
  * })
  * ```
  *
  * Fired when an {@link Amity.Reaction} 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 Message Events
- **/
+ * */
 export const onReactionAdded = (
-  referenceType: Amity.Reaction['referenceType'],
+  referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  callback: Amity.Listener<Amity.Model[typeof referenceType]>
+  callback: Amity.Listener<Amity.Models[typeof referenceType]>,
 ): Amity.Unsubscriber => {
-  const client = getActiveClient()
+  const callbackWrapper = (model: Amity.Models[typeof referenceType]) => {
+    if (getResolver(referenceType)(model as any) === referenceId) {
+      callback(model);
+    }
+  };
 
-  const event = `v3.${referenceType}.didUpdate` as const
+  /*
+   * Important: Want to point out that reference type will never be 'message'
+   * for onReactionAdded
+   */
+  if (referenceType === 'message') {
+    const client = getActiveClient();
 
-  const filter = (payload: Amity.Events[typeof event]) => {
-    // TODO: lol
+    const filter = async (rawPayload: Amity.MessagePayload) => {
+      const payload = await prepareMessagePayload(rawPayload);
+      const cached = pullFromCache<Amity.Message>([
+        'message',
+        'get',
+        payload.messages[0].messageId,
+      ]);
+      const isReactionEvent = cached?.data?.reactionsCount !== payload.messages[0].reactionsCount;
 
-    decoratePayload(payload)
-    ingestInCache(payload)
+      ingestInCache(payload);
+
+      if (isReactionEvent) {
+        callbackWrapper(payload.messages[0]);
+      }
+    };
+
+    return createEventSubscriber(client, 'reaction/onReactionAdded', 'message.updated', filter);
+  }
+
+  if (referenceType === 'post') {
+    return onPostReactionAdded(callbackWrapper);
   }
 
-  return createEventSubscriber(
-    client,
-    'reaction/onReactionAdded',
-    event,
-    filter
-  )
-}
+  return onCommentReactionAdded(callbackWrapper);
+};