@amityco/ts-sdk 6.32.4 → 6.32.5-a934b24.0

package/src/postRepository/observers/getGlobalPinnedPosts/GlobalPinnedPostQueryStreamController.ts

@@ -0,0 +1,88 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+import { EnumPostActions } from '../enums';
+
+export class GlobalPinnedPostQueryStreamController extends QueryStreamController<
+  Amity.PinnedPostPayload,
+  Amity.GlobalPinnedPostLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.PinnedPostPayload) => Amity.ProcessedPostPayload;
+
+  constructor(
+    query: Amity.GlobalPinnedPostLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.PinnedPostPayload) => Amity.ProcessedPostPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async saveToMainDB(response: Amity.PinnedPostPayload) {
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(response, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.PinnedPostPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.pins.map(getResolver('pin')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.PinnedPostLiveCollectionCache>(this.cacheKey)?.data;
+
+      const pinnedPosts = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...pinnedPosts, ...response.pins.map(getResolver('pin'))])],
+      });
+
+      this.notifyChange({
+        origin: Amity.LiveDataOrigin.SERVER,
+        loading: false,
+      });
+    }
+  }
+
+  reactor(action: EnumPostActions) {
+    return (post: Amity.InternalPost) => {
+      const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
+
+      if (!collection) return;
+
+      if (action === EnumPostActions.OnPostDeleted) {
+        collection.data = collection.data.filter(
+          referenceId => referenceId !== `global#${post.postId}`,
+        );
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (post: Amity.InternalPost) => void) => Amity.Unsubscriber;
+      action: EnumPostActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/postRepository/observers/getGlobalPinnedPosts.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { GlobalPinnedPostLiveCollectionController } from './getGlobalPinnedPosts/GlobalPinnedPostLiveCollectionController';
+
+/**
+ * Get global pinned posts
+ *
+ * @returns the global pinned post(s)
+ *
+ * @category Pined Posts Live Collection
+ *
+ */
+export const getGlobalPinnedPosts = (
+  params: Amity.LiveCollectionParams<Amity.GlobalPinnedPostLiveCollection>,
+  callback: Amity.LiveCollectionCallback<Amity.PinnedPost>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getGlobalPinnedPosts(tmpid: ${timestamp}) > listen`);
+
+  const globalPinnedPostLiveCollection = new GlobalPinnedPostLiveCollectionController(
+    params,
+    callback,
+  );
+  const disposers = globalPinnedPostLiveCollection.startSubscription();
+
+  const cacheKey = globalPinnedPostLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getGlobalPinnedPosts(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/postRepository/observers/index.ts

@@ -3,4 +3,5 @@ export * from './observePost';
 export * from './getPost';
 export * from './getPosts';
 export * from './getPinnedPosts';
+export * from './getGlobalPinnedPosts';
 export * from './semanticSearchPosts';

package/src/reactionRepository/api/addReaction.ts

@@ -37,7 +37,7 @@ export const addReaction = async (
     reactionName,
   });
 
-  await client.http.post<{ addedId: 'string' }>('/api/v2/reactions', {
+  const { data } = await client.http.post<{ addedId: 'string' }>('/api/v2/reactions', {
     referenceId,
     referenceType,
     reactionName,
@@ -66,6 +66,11 @@ export const addReaction = async (
     if (referenceType === 'comment') {
       fireEvent('local.comment.addReaction', {
         comment: updatedModel as Amity.InternalComment,
+        reactor: {
+          userId: client.userId!,
+          reactionName,
+          reactionId: data.addedId,
+        },
       });
 
       return true;
@@ -73,6 +78,23 @@ export const addReaction = async (
     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;

package/src/reactionRepository/api/removeReaction.ts

@@ -38,7 +38,7 @@ export const removeReaction = async (
     reactionName,
   });
 
-  await client.http.delete<{ removedId: string }>(`/api/v2/reactions`, {
+  const { data } = await client.http.delete<{ removedId: string }>(`/api/v2/reactions`, {
     data: {
       referenceId,
       referenceType,
@@ -69,6 +69,11 @@ export const removeReaction = async (
     if (referenceType === 'comment') {
       fireEvent('local.comment.removeReaction', {
         comment: updatedModel as Amity.InternalComment,
+        reactor: {
+          reactionId: data.removedId,
+          reactionName,
+          userId: client.userId!,
+        },
       });
 
       return true;
@@ -76,6 +81,24 @@ export const removeReaction = async (
     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;
@@ -139,5 +162,5 @@ removeReaction.optimistically = (
 
   dispatchReactable(referenceType, reaction);
 
-  return !reaction?.myReactions?.includes(reactionName) ?? false;
+  return !reaction?.myReactions?.includes(reactionName);
 };

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/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/observers/getReactions/ReactionLiveCollectionController.ts

@@ -0,0 +1,111 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ReactionPaginationController } from './ReactionPaginationController';
+import { ReactionQueryStreamController } from './ReactionQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+
+import { onReactorAdded, onReactorRemoved } from '../../events';
+
+import { LinkedObject } from '~/utils/linkedObject';
+import { onReactorRemovedLocal } from '~/reactionRepository/events/onReactorRemovedLocal';
+import { onReactorAddedLocal } from '~/reactionRepository/events/onReactorAddedLocal';
+
+export class ReactionLiveCollectionController extends LiveCollectionController<
+  'reaction',
+  Amity.ReactionLiveCollection,
+  Amity.Reactor,
+  ReactionPaginationController
+> {
+  private queryStreamController: ReactionQueryStreamController;
+
+  private query: Amity.ReactionLiveCollection;
+
+  constructor(
+    query: Amity.ReactionLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Reactor>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['reaction', 'collection', queryStreamId];
+    const paginationController = new ReactionPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new ReactionQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      payload => payload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.ReactionPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'reaction'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      {
+        fn: callback => onReactorAdded(this.query.referenceType, this.query.referenceId, callback),
+        action: Amity.ReactionActionTypeEnum.OnAdded,
+      },
+      {
+        fn: callback =>
+          onReactorRemoved(this.query.referenceType, this.query.referenceId, callback),
+        action: Amity.ReactionActionTypeEnum.OnRemoved,
+      },
+      {
+        fn: callback =>
+          onReactorRemovedLocal(this.query.referenceType, this.query.referenceId, callback),
+        action: Amity.ReactionActionTypeEnum.OnRemoved,
+      },
+      {
+        fn: callback =>
+          onReactorAddedLocal(this.query.referenceType, this.query.referenceId, callback),
+        action: Amity.ReactionActionTypeEnum.OnRemoved,
+      },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data =
+      collection.data
+        .map(reactorId => pullFromCache<Amity.InternalReactor>(['reactor', 'get', reactorId])!)
+        .filter(Boolean)
+        .map(({ data }) => LinkedObject.reactor(data)) ?? [];
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+}

package/src/reactionRepository/observers/getReactions/ReactionPaginationController.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client';
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { REFERENCE_API_V5 } from '~/reactionRepository/api/constants';
+
+export class ReactionPaginationController extends PaginationController<
+  'reaction',
+  Amity.ReactionLiveCollection
+> {
+  async getRequest(queryParams: Amity.ReactionLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+    const client = getActiveClient();
+    client.log('reaction/queryReactions', queryParams);
+
+    const path = '/api/v3/reactions';
+
+    const { data: queryResponse } = await this.http.get<Amity.ReactionPayload & Amity.Pagination>(
+      path,
+      {
+        params: {
+          ...params,
+          referenceVersion: REFERENCE_API_V5, // Need to put this param to make it can query reaction for message in sub-channel
+          options,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/reactionRepository/observers/getReactions/ReactionQueryStreamController.ts

@@ -0,0 +1,92 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+
+export class ReactionQueryStreamController extends QueryStreamController<
+  Amity.ReactionPayload,
+  Amity.ReactionLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.ReactionPayload) => Amity.ReactionPayload;
+
+  constructor(
+    query: Amity.ReactionLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.ReactionPayload) => Amity.ReactionPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.ReactionPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      const { reactions, ...restPayload } = processedPayload;
+      ingestInCache(
+        {
+          ...restPayload,
+          reactions,
+          reactors: reactions[0]?.reactors,
+        },
+        { cachedAt },
+      );
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.ReactionPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    const reactors = response.reactions[0]?.reactors ?? [];
+
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: reactors.map(getResolver('reactor')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(this.cacheKey)?.data;
+
+      const reactions = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...reactions, ...reactors.map(getResolver('reactor'))])],
+      });
+    }
+  }
+
+  reactor(action: Amity.ReactionActionTypeEnum) {
+    return (reaction: Amity.InternalReactor) => {
+      const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      if (action === Amity.ReactionActionTypeEnum.OnAdded) {
+        collection.data = [...new Set([reaction.reactionId, ...collection.data])];
+      } else if (action === Amity.ReactionActionTypeEnum.OnRemoved) {
+        collection.data = collection.data.filter(p => p !== reaction.reactionId);
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (reaction: Amity.InternalReactor) => void) => Amity.Unsubscriber;
+      action: Amity.ReactionActionTypeEnum;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}