@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

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'
+ * 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,95 @@
+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'
+ * const dispose = onReactorAdded('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.InternalReactor} 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.InternalReactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.InternalReactor,
+  ) => {
+    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);
+      ingestInCache({ reactors: payload.reactions });
+
+      callbackWrapper('message', payload.messages[0].messageId, payload.reactions[0]);
+    };
+
+    return createEventSubscriber(
+      client,
+      'reaction/onReactorAdded',
+      'message.reactionAdded',
+      filter,
+    );
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.InternalReactor }) => {
+      const { reactor, ...rest } = payload;
+
+      ingestInCache(rest as Amity.ProcessedPostPayload);
+      ingestInCache({ reactions: [reactor] });
+
+      callbackWrapper('post', payload.posts[0].postId, reactor);
+    };
+
+    return createEventSubscriber(client, 'post.addReaction', 'post.addReaction', filter);
+  }
+
+  if (referenceType === 'story') {
+    const filter = (payload: Amity.StoryReactionPayload) => {
+      const { reactions, ...rest } = payload;
+      ingestInCache(rest as Amity.StoryPayload);
+      ingestInCache({ reactors: reactions });
+
+      if (payload.stories.length === 0 || payload.reactions.length === 0) return;
+      callbackWrapper('story', payload.stories[0].storyId, payload.reactions[0]);
+    };
+
+    return createEventSubscriber(client, 'story.reactionAdded', 'story.reactionAdded', filter);
+  }
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.InternalReactor }) => {
+    const { reactor, ...rest } = payload;
+
+    ingestInCache(rest as Amity.CommentPayload);
+    ingestInCache({ reactions: [reactor] });
+
+    callbackWrapper('comment', payload.comments[0].commentId, reactor);
+  };
+
+  return createEventSubscriber(client, 'comment.addReaction', 'comment.addReaction', filter);
+};

package/src/reactionRepository/events/onReactorAddedLocal.ts

@@ -0,0 +1,95 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+
+/**
+ * ```js
+ * import { onReactorAddedLocal } from '@amityco/ts-sdk'
+ * const dispose = onReactorAdded('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.InternalReactor} 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 onReactorAddedLocal = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.InternalReactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.InternalReactor,
+  ) => {
+    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);
+      ingestInCache({ reactors: payload.reactions });
+
+      callbackWrapper('message', payload.messages[0].messageId, payload.reactions[0]);
+    };
+
+    return createEventSubscriber(
+      client,
+      'reaction/onReactorAdded',
+      'message.reactionAdded',
+      filter,
+    );
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.LocalEvents['local.post.addReaction']) => {
+      callbackWrapper('post', payload.post.postId, payload.reactor);
+    };
+
+    return createEventSubscriber(
+      client,
+      'local.post.addReaction',
+      'local.post.addReaction',
+      filter,
+    );
+  }
+
+  if (referenceType === 'story') {
+    const filter = (payload: Amity.StoryReactionPayload) => {
+      const { reactions, ...rest } = payload;
+      ingestInCache(rest as Amity.StoryPayload);
+      ingestInCache({ reactors: reactions });
+
+      if (payload.stories.length === 0 || payload.reactions.length === 0) return;
+      callbackWrapper('story', payload.stories[0].storyId, payload.reactions[0]);
+    };
+
+    return createEventSubscriber(client, 'story.reactionAdded', 'story.reactionAdded', filter);
+  }
+
+  const filter = (payload: Amity.LocalEvents['local.comment.addReaction']) => {
+    callbackWrapper('comment', payload.comment.commentId, payload.reactor);
+  };
+
+  return createEventSubscriber(
+    client,
+    'local.comment.addReaction',
+    'local.comment.addReaction',
+    filter,
+  );
+};

package/src/reactionRepository/events/onReactorRemoved.ts

@@ -0,0 +1,98 @@
+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'
+ * const dispose = onReactorRemoved('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.InternalReactor} 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.InternalReactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.InternalReactor,
+  ) => {
+    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.reactionRemoved',
+      filter,
+    );
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.InternalReactor }) => {
+      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);
+  }
+
+  if (referenceType === 'story') {
+    const filter = (payload: Amity.StoryReactionPayload) => {
+      const { reactions, ...rest } = payload;
+      ingestInCache(rest as Amity.StoryPayload);
+      ingestInCache({ reactors: reactions });
+
+      if (payload.stories.length === 0 || payload.reactions.length === 0) return;
+      callbackWrapper('story', payload.stories[0].storyId, payload.reactions[0]);
+    };
+
+    return createEventSubscriber(client, 'story.reactionRemoved', 'story.reactionRemoved', filter);
+  }
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.InternalReactor }) => {
+    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/events/onReactorRemovedLocal.ts

@@ -0,0 +1,94 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+
+/**
+ * ```js
+ * import { onReactorRemovedLocal } from '@amityco/ts-sdk'
+ * const dispose = onReactorRemoved('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.InternalReactor} 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 onReactorRemovedLocal = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.InternalReactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.InternalReactor,
+  ) => {
+    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.reactionRemoved',
+      filter,
+    );
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.LocalEvents['local.post.removeReaction']) => {
+      callbackWrapper('post', payload.post.postId, payload.reactor);
+    };
+
+    return createEventSubscriber(
+      client,
+      'local.post.removeReaction',
+      'local.post.removeReaction',
+      filter,
+    );
+  }
+
+  if (referenceType === 'story') {
+    const filter = (payload: Amity.StoryReactionPayload) => {
+      const { reactions, ...rest } = payload;
+      ingestInCache(rest as Amity.StoryPayload);
+      ingestInCache({ reactors: reactions });
+
+      if (payload.stories.length === 0 || payload.reactions.length === 0) return;
+      callbackWrapper('story', payload.stories[0].storyId, payload.reactions[0]);
+    };
+
+    return createEventSubscriber(client, 'story.reactionRemoved', 'story.reactionRemoved', filter);
+  }
+
+  const filter = (payload: Amity.LocalEvents['local.comment.removeReaction']) => {
+    callbackWrapper('comment', payload.comment.commentId, payload.reactor);
+  };
+
+  return createEventSubscriber(
+    client,
+    'local.comment.removeReaction',
+    'local.comment.removeReaction',
+    filter,
+  );
+};

package/src/reactionRepository/index.ts

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

package/src/reactionRepository/internalApi/addReaction.ts

@@ -0,0 +1,137 @@
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache, pullFromCache } from '~/cache/api';
+
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { dispatchReactable } from '../utils/dispatchReactable';
+import { fireEvent } from '~/core/events';
+import { ASCApiError } from '~/core/errors';
+
+export const addReaction = async (
+  referenceType: Amity.Reaction['referenceType'],
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.InternalReactor['reactionName'],
+  referenceVersion?: number,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('reaction/createReaction', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  if (!['post', 'comment', 'story', 'message'].includes(referenceType))
+    throw new ASCApiError(
+      'The reference type is not valid. It should be one of post, comment, story, or message',
+      Amity.ServerError.BAD_REQUEST,
+      Amity.ErrorLevel.ERROR,
+    );
+
+  const { data } = await client.http.post<{ addedId: 'string' }>('/api/v2/reactions', {
+    referenceId,
+    referenceType,
+    reactionName,
+    referenceVersion,
+  });
+
+  if (client.cache) {
+    const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
+
+    if (!model || model.data.myReactions?.includes(reactionName)) return true;
+
+    const updatedModel = {
+      ...model.data,
+      reactionsCount: model.data.reactionsCount + 1,
+      myReactions: [...(model.data.myReactions ?? []), reactionName],
+      reactions: {
+        ...model.data.reactions,
+        [reactionName]: (model.data.reactions[reactionName] ?? 0) + 1,
+      },
+      updatedAt: new Date().toISOString(),
+    } as Amity.Models[Amity.ReactableType];
+
+    if (referenceType === 'comment') {
+      fireEvent('local.comment.addReaction', {
+        comment: updatedModel as Amity.InternalComment,
+        reactor: {
+          userId: client.userId!,
+          reactionName,
+          reactionId: data.addedId,
+        },
+      });
+
+      return true;
+    }
+    if (referenceType === 'post') {
+      fireEvent('local.post.addReaction', {
+        post: updatedModel as Amity.InternalPost,
+        reactor: {
+          userId: client.userId!,
+          reactionName,
+          reactionId: data.addedId,
+        },
+      });
+
+      return true;
+    }
+    if (referenceType === 'story') {
+      fireEvent('local.story.reactionAdded', {
+        story: updatedModel as Amity.InternalStory,
+        reactor: {
+          userId: client.userId!,
+          reactionName,
+          reactionId: data.addedId,
+        },
+      });
+
+      return true;
+    }
+  }
+
+  return true;
+};
+
+addReaction.optimistically = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.InternalReactor['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];
+
+  upsertInCache([referenceType, 'get', referenceId], reaction, {
+    cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  });
+
+  dispatchReactable(referenceType, reaction);
+
+  return reaction?.myReactions?.includes(reactionName) ?? false;
+};

package/src/reactionRepository/internalApi/index.ts

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

package/src/reactionRepository/internalApi/removeReaction.ts

@@ -0,0 +1,95 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+import { ASCApiError } from '~/core/errors';
+
+export const removeReaction = async (
+  referenceType: Amity.Reaction['referenceType'],
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.InternalReactor['reactionName'],
+  referenceVersion?: number,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('reaction/removeReaction', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  if (!['post', 'comment', 'story', 'message'].includes(referenceType))
+    throw new ASCApiError(
+      'The reference type is not valid. It should be one of post, comment, story, or message',
+      Amity.ServerError.BAD_REQUEST,
+      Amity.ErrorLevel.ERROR,
+    );
+
+  const { data } = await client.http.delete<{ removedId: string }>(`/api/v2/reactions`, {
+    data: {
+      referenceId,
+      referenceType,
+      reactionName,
+      referenceVersion,
+    },
+  });
+
+  if (client.cache) {
+    const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
+
+    if (!model) return true;
+
+    const updatedModel = {
+      ...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),
+      },
+      updatedAt: new Date().toISOString(),
+    } as Amity.Models[Amity.ReactableType];
+
+    if (referenceType === 'comment') {
+      fireEvent('local.comment.removeReaction', {
+        comment: updatedModel as Amity.InternalComment,
+        reactor: {
+          reactionId: data.removedId,
+          reactionName,
+          userId: client.userId!,
+        },
+      });
+
+      return true;
+    }
+    if (referenceType === 'post') {
+      fireEvent('local.post.removeReaction', {
+        post: updatedModel as Amity.InternalPost,
+        reactor: {
+          reactionId: data.removedId,
+          reactionName,
+          userId: client.userId!,
+        },
+      });
+
+      return true;
+    }
+
+    if (referenceType === 'story') {
+      fireEvent('local.story.reactionAdded', {
+        story: updatedModel as Amity.InternalStory,
+        reactor: {
+          userId: client.userId!,
+          reactionName,
+          reactionId: data.removedId,
+        },
+      });
+
+      return true;
+    }
+  }
+
+  return true;
+};