@amityco/ts-sdk-react-native 6.7.1-80c1951.0

package/src/reactionRepository/api/removeReaction.ts

@@ -0,0 +1,118 @@
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
+
+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-react-native'
+ * const success = await deleteReaction('post', 'foobar', 'like')
+ * ```
+ *
+ * Removes a {@link Amity.Reaction} from a {@link Amity.Reactable} object
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The removed result.
+ *
+ * @category Reaction API
+ * @async
+ * */
+export const removeReaction = async (
+  referenceType: Amity.Reaction['referenceType'],
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reactor['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,
+    },
+  });
+
+  if (client.cache) {
+    const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
+
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
+
+  return true;
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { removeReaction } from '@amityco/ts-sdk-react-native'
+ * const success = removeReaction.optimistically('post', postId, 'like')
+ * ```
+ *
+ * Removes a {@link Amity.Reaction} from a {@link Amity.Reactable} object optimistically
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ * */
+removeReaction.optimistically = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reactor['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/reactionRepository/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 '~/messageRepository/events';
+import { addReaction } from '~/reactionRepository/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/reactionRepository/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 '~/messageRepository/events';
+import { removeReaction } from '~/reactionRepository/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/reactionRepository/events/index.ts

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

package/src/reactionRepository/events/onReactionAdded.ts

@@ -0,0 +1,69 @@
+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 '~/postRepository/events';
+import { onCommentReactionAdded } from '~/commentRepository/events';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+
+/**
+ * ```js
+ * import { onReactionAdded } from '@amityco/ts-sdk-react-native'
+ * 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.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Models[typeof referenceType]>,
+): Amity.Unsubscriber => {
+  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 = 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;
+
+      ingestInCache(payload);
+
+      if (isReactionEvent) {
+        callbackWrapper(payload.messages[0]);
+      }
+    };
+
+    return createEventSubscriber(client, 'reaction/onReactionAdded', 'message.updated', filter);
+  }
+
+  if (referenceType === 'post') {
+    return onPostReactionAdded(callbackWrapper);
+  }
+
+  return onCommentReactionAdded(callbackWrapper);
+};

package/src/reactionRepository/events/onReactionRemoved.ts

@@ -0,0 +1,65 @@
+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 { onPostReactionRemoved } from '~/postRepository/events';
+import { onCommentReactionRemoved } from '~/commentRepository/events';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+
+/**
+ * ```js
+ * import { onReactionRemoved } from '@amityco/ts-sdk-react-native'
+ * const dispose = onReactionRemoved('post', postId, post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reaction} 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 Message Events
+ * */
+export const onReactionRemoved = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Models[typeof referenceType]>,
+): Amity.Unsubscriber => {
+  const callbackWrapper = (model: Amity.Models[typeof referenceType]) => {
+    if (getResolver(referenceType)(model as any) === referenceId) {
+      callback(model);
+    }
+  };
+
+  if (referenceType === 'message') {
+    const client = getActiveClient();
+
+    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;
+
+      ingestInCache(payload);
+
+      if (isReactionEvent) {
+        callbackWrapper(payload.messages[0]);
+      }
+    };
+
+    return createEventSubscriber(client, 'reaction/onReactionRemoved', 'message.updated', filter);
+  }
+
+  if (referenceType === 'post') {
+    return onPostReactionRemoved(callbackWrapper);
+  }
+
+  return onCommentReactionRemoved(callbackWrapper);
+};

package/src/reactionRepository/events/onReactorAdded.ts

@@ -0,0 +1,80 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+
+/**
+ * ```js
+ * import { onReactorAdded } from '@amityco/ts-sdk-react-native'
+ * 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 = async (rawPayload: Amity.MessagePayload) => {
+      const payload = await prepareMessagePayload(rawPayload);
+      if (!payload.reactions[0]) return;
+
+      ingestInCache(payload);
+
+      callbackWrapper('message', payload.messages[0].messageId, payload.reactions[0]);
+    };
+
+    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/reactionRepository/events/onReactorRemoved.ts

@@ -0,0 +1,80 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+
+/**
+ * ```js
+ * import { onReactorRemoved } from '@amityco/ts-sdk-react-native'
+ * 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 = async (rawPayload: Amity.MessagePayload) => {
+      const payload = await prepareMessagePayload(rawPayload);
+      if (!payload.reactions[0]) return;
+
+      ingestInCache(payload);
+
+      callbackWrapper('message', payload.messages[0].messageId, payload.reactions[0]);
+    };
+
+    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/reactionRepository/index.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './events';
+export * from './observers';