@amityco/ts-sdk 0.0.1 → 6.0.0

package/src/reaction/events/onReactionRemoved.ts

@@ -1,41 +1,65 @@
-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 { onPostReactionRemoved } from '~/post/events';
+import { onCommentReactionRemoved } from '~/comment/events';
+import { prepareMessagePayload } from '~/message/utils';
 
 /**
  * ```js
  * import { onReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onReactionRemoved(message => {
+ * 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.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 filter = (payload: Amity.MessagePayload) => {
-    // TODO: lol
+  if (referenceType === 'message') {
+    const client = getActiveClient();
 
-    decoratePayload(payload)
-    ingestInCache(payload)
+    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 createEventSubscriber(
-    client,
-    'reaction/onReactionRemoved',
-    'v3.message.didUpdate',
-    filter
-  )
-}
+  return onCommentReactionRemoved(callbackWrapper);
+};

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 = async (rawPayload: Amity.MessagePayload) => {
+      const payload = await 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 = async (rawPayload: Amity.MessagePayload) => {
+      const payload = await 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/index.ts

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

package/src/reaction/observers/getReactions.ts

@@ -0,0 +1,142 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import { onReactorAdded, onReactorRemoved } from '../events';
+import { queryReactions } from '../api/queryReactions';
+
+/**
+ * ```js
+ * import { getReactions } from '@amityco/ts-sdk'
+ *
+ * let reactions = []
+ * const unsub = liveReactions({
+ *   referenceId: Amity.Reaction['referenceId'],
+ *   referenceType: Amity.Reaction['referenceType'],
+ * }, response => merge(reactions, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Reaction} for a given target object
+ *
+ * @param params.referenceType the type of the target
+ * @param params.referenceId the ID of the target
+ * @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 messages
+ *
+ * @category Reactions Live Collection
+ */
+export const getReactions = (
+  params: Amity.ReactionLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Reactor>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveReactions(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = [
+    'reaction',
+    'collection',
+    { referenceId: params.referenceId, referenceType: params.referenceType },
+  ];
+
+  const responder = (data: Amity.ReactionLiveCollectionCache) => {
+    const reactions: Amity.Reactor[] =
+      data.data
+        .map(reactorId => pullFromCache<Amity.Reactor>(['reaction', 'get', reactorId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    callback({
+      onNextPage: onFetch,
+      data: reactions,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (action: Amity.ReactionActionType) => (reaction: Amity.Reactor) => {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+    if (!collection) return;
+
+    if (action === 'onAdded') {
+      collection.data = [...new Set([reaction.reactionId, ...collection.data])];
+    } else if (action === 'onRemoved') {
+      collection.data = collection.data.filter(p => p !== reaction.reactionId);
+    }
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+
+    const reactions = collection?.data ?? [];
+
+    if (reactions.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryReactions, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: reactions,
+        };
+
+        if (result) {
+          data.data = [
+            ...new Set([...reactions, ...result[0].reactors.map(getResolver('reaction'))]),
+          ];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onReactorAdded(queryParams.referenceType, queryParams.referenceId, realtimeRouter('onAdded')),
+    onReactorRemoved(
+      queryParams.referenceType,
+      queryParams.referenceId,
+      realtimeRouter('onRemoved'),
+    ),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveReactions(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/reaction/observers/index.ts

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

package/src/reaction/utils/dispatchReactable.ts

@@ -1,19 +1,17 @@
-import { fireEvent } from "~/core/events"
+import { fireEvent } from '~/core/events';
 
 /** @hidden */
 export const dispatchReactable = <T extends Amity.ReactableType>(
   referenceType: T,
-  model: Amity.Model[T],
+  model: Amity.Models[T],
 ) => {
-  let payload: any
-
   if (referenceType === 'message')
     // @ts-ignore: refactor later
-    fireEvent('v3.message.didUpdate', { messages: [model] })
+    fireEvent('local.message.updated', { messages: [model] });
   else if (referenceType === 'post')
     // @ts-ignore: refactor later
-    fireEvent('v3.post.didUpdate', { posts: [model] })
+    fireEvent('post.updated', { posts: [model] });
   else if (referenceType === 'comment')
     // @ts-ignore: refactor later
-    fireEvent('v3.comment.didUpdate', { comments: [model] })
-}
+    fireEvent('comment.updated', { comments: [model] });
+};

package/src/reaction/utils/fetchReference.ts

@@ -1,18 +1,15 @@
-import { getMessage } from '~/message/api'
-import { getPost } from '~/post/api'
-import { getComment } from '~/comment/api'
+import { getMessage } from '~/message/api/getMessage';
+import { getPost } from '~/post/api/getPost';
+import { getComment } from '~/comment/api/getComment';
 
 /** @hidden */
 export const fetchReference = async (
   referenceType: Amity.ReactableType,
   referenceId: string,
-): Promise<Amity.Model[typeof referenceType]> => {
-  if (referenceType === 'message')
-    return getMessage(referenceId)
-  else if (referenceType === 'post')
-    return getPost(referenceId)
-  else if (referenceType === 'comment')
-    return getComment(referenceId)
+): Promise<Amity.Cached<Amity.Models[typeof referenceType]>> => {
+  if (referenceType === 'message') return getMessage(referenceId);
+  if (referenceType === 'post') return getPost(referenceId);
+  if (referenceType === 'comment') return getComment(referenceId);
 
-  throw new Error(`Incorrect referenceType: ${referenceType}`)
-}
+  throw new Error(`Incorrect referenceType: ${referenceType}`);
+};

package/src/reaction/utils/index.ts

@@ -1,2 +1,4 @@
-export * from './dispatchReactable'
-export * from './fetchReference'
+export * from './dispatchReactable';
+export * from './fetchReference';
+export * from './preparePayloadForCache';
+export * from './prepareMessagePayloadForCache';

package/src/reaction/utils/prepareMessagePayloadForCache.ts

@@ -0,0 +1,40 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+/** @hidden */
+/*
+ * @param message payload from http request without myReactions
+ * add myReactions to http response if the event was a reaction event
+ */
+export const prepareMessagePayloadForCache = (payload: Amity.Message) => {
+  const client = getActiveClient();
+
+  const cached = pullFromCache<Amity.Message>(['message', 'get', payload.messageId]);
+  // '[]' in cases where the new reaction is the first one
+  const myReactions = cached?.data.myReactions || [];
+
+  // add myReactions to the payload
+  Object.assign(payload, { myReactions });
+
+  // check if there are any updates to the reactions
+  const latestReaction = payload?.latestReaction;
+  const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
+
+  if (!isLatestReactionMine) {
+    return;
+  }
+
+  // new reaction added
+  if (latestReaction.eventName === 'add' && !myReactions.includes(latestReaction.reactionName)) {
+    Object.assign(payload, {
+      myReactions: [...myReactions, latestReaction.reactionName],
+    });
+  }
+
+  // existing reaction removed
+  if (latestReaction.eventName === 'remove' && myReactions.includes(latestReaction.reactionName)) {
+    Object.assign(payload, {
+      myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
+    });
+  }
+};

package/src/reaction/utils/preparePayloadForCache.ts

@@ -0,0 +1,53 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+/** @hidden */
+export const preparePayloadForCache = <
+  T extends
+    | 'post.addReaction'
+    | 'post.removeReaction'
+    | 'comment.addReaction'
+    | 'comment.removeReaction',
+>(
+  event: T,
+  payload: Amity.Events[T],
+) => {
+  const client = getActiveClient();
+
+  if (client.userId !== payload.reactor.userId) {
+    return;
+  }
+
+  let model: Amity.Reactable;
+  let cached: Amity.Reactable | undefined;
+
+  if (event === 'post.addReaction' || event === 'post.removeReaction') {
+    const post = (payload as Amity.Events['post.addReaction']).posts[0];
+    cached = pullFromCache<Amity.Post>(['post', 'get', post.postId])?.data;
+    model = post;
+  } else {
+    const comment = (payload as Amity.Events['comment.addReaction']).comments[0];
+    cached = pullFromCache<Amity.Comment>(['comment', 'get', comment.commentId])?.data;
+    model = comment;
+  }
+
+  if (!cached || !cached.myReactions) {
+    return;
+  }
+
+  if (event === 'post.addReaction' || event === 'comment.addReaction') {
+    if (cached.myReactions.includes(payload.reactor.reactionName)) {
+      return;
+    }
+
+    Object.assign(model, { myReactions: [...cached.myReactions, payload.reactor.reactionName] });
+  } else {
+    if (!cached.myReactions.includes(payload.reactor.reactionName)) {
+      return;
+    }
+
+    Object.assign(model, {
+      myReactions: cached.myReactions.filter(x => x !== payload.reactor.reactionName),
+    });
+  }
+};

package/src/report/api/createReport.ts

@@ -1,11 +1,15 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { ingestInCache } from '~/core/cache'
-import { fireEvent } from '~/core/events'
-import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 
-import REFERENCE_TYPES from '../constants/referenceTypes'
+import { prepareMessagePayload } from '~/message/utils';
+import REFERENCE_TYPES from '../constants/referenceTypes';
 
+/* begin_public_function
+  id: user.flag, message.flag, post.flag, comment.flag
+*/
 /**
  * ```js
  * import { createReport } from '@amityco/ts-sdk'
@@ -18,23 +22,45 @@ import REFERENCE_TYPES from '../constants/referenceTypes'
  *
  * @category Report API
  * @async
- **/
+ * */
 export const createReport = async (
   referenceType: keyof typeof REFERENCE_TYPES,
-  referenceId: string
-) => {
-  const client = getActiveClient()
-  client.log('report/createReport', { referenceType, referenceId })
+  referenceId: string,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('report/createReport', { referenceType, referenceId });
 
-  const { domainName } = REFERENCE_TYPES[referenceType]
+  const getAPIUrl = (): string => {
+    if (referenceType === 'user') {
+      return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
+    }
 
-  const { data } = await client.http.post<Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload>(
-    `/api/v3/${domainName}/${referenceId}/flag`
-  )
+    if (referenceType === 'message') {
+      return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
+    }
 
-  decoratePayload(data)
-  ingestInCache(data)
-  fireEvent(`v3.${referenceType}.didUpdate`, data)
+    const { domainName } = REFERENCE_TYPES[referenceType];
 
-  return !!data
-}
+    return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`;
+  };
+
+  const { data: payload } = await client.http.post<
+    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
+  >(getAPIUrl());
+
+  if (client.cache) {
+    if (referenceType === 'message') {
+      const messagePayload = await prepareMessagePayload(payload as Amity.MessagePayload);
+      ingestInCache(messagePayload);
+    } else if (referenceType === 'post') {
+      ingestInCache(prepareMembershipPayload(payload as Amity.PostPayload, 'communityUsers'));
+    } else {
+      ingestInCache(payload as Amity.CommentPayload | Amity.UserPayload);
+    }
+  }
+
+  fireEvent(`${referenceType}.flagged`, payload);
+
+  return !!payload;
+};
+/* end_public_function */