@amityco/ts-sdk-react-native 6.32.7-289cad7.0 → 6.32.7-686c44c.0

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)));
+  }
+}

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

@@ -0,0 +1,57 @@
+/* eslint-disable no-use-before-define */
+
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+import { ReactionLiveCollectionController } from './ReactionLiveCollectionController';
+
+/* begin_public_function
+  id: reaction.query
+*/
+/**
+ * ```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.InternalReactor} for a given target object
+ *
+ * @param params for querying reactions
+ * @param callback the function to call when new data are available
+ * @param config the live collection configuration
+ * @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(`getReactions(tmpid: ${timestamp}) > listen`);
+
+  const reactionLiveCollection = new ReactionLiveCollectionController(params, callback);
+  const disposers = reactionLiveCollection.startSubscription();
+  const cacheKey = reactionLiveCollection.getCacheKey();
+
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
+
+  return () => {
+    log(`getReactions(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

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

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

package/src/reactionRepository/observers/index.ts

@@ -1 +1 @@
-export * from './getReactions';
+export { getReactions } from './getReactions';

package/src/storyRepository/events/onStoryReactionAdded.ts

@@ -30,9 +30,9 @@ export const onStoryReactionAdded = (callback: Amity.Listener<Amity.InternalStor
 export const onStoryReactionAddedLocal = (callback: Amity.Listener<Amity.InternalStory[]>) => {
   const client = getActiveClient();
 
-  const filter = async (payload: Amity.StoryPayload) => {
-    ingestInCache(payload);
-    callback(payload.stories);
+  const filter = async (payload: Amity.LocalEvents['local.story.reactionAdded']) => {
+    ingestInCache({ stories: [payload.story] });
+    callback([payload.story]);
   };
 
   const disposers = [

package/src/storyRepository/events/onStoryReactionRemoved.ts

@@ -30,9 +30,9 @@ export const onStoryReactionRemoved = (callback: Amity.Listener<Amity.InternalSt
 export const onStoryReactionRemovedLocal = (callback: Amity.Listener<Amity.InternalStory[]>) => {
   const client = getActiveClient();
 
-  const filter = async (payload: Amity.StoryPayload) => {
-    ingestInCache(payload);
-    callback(payload.stories);
+  const filter = async (payload: Amity.LocalEvents['local.story.reactionAdded']) => {
+    ingestInCache({ stories: [payload.story] });
+    callback([payload.story]);
   };
 
   const disposers = [

package/src/storyRepository/observers/getGlobalStoryTargets/GlobalStoryLiveCollectionController.ts

@@ -10,6 +10,7 @@ import { onStoryDeleted, onStoryDeletedLocal } from '~/storyRepository/events/on
 import { onStoryError } from '~/storyRepository/events/onStoryError';
 import { GlobalStoryQueryStreamController } from './GlobalStoryQueryStreamController';
 import { GlobalStoryPageController } from './GlobalStoryPageController';
+import { prepareCommunityPayload } from '~/communityRepository/utils';
 
 type StoryTargetBySeenState = {
   seen: Amity.StoryTarget[];
@@ -44,6 +45,10 @@ export class GlobalStoryLiveCollectionController extends LiveCollectionControlle
       this.cacheKey,
       this.notifyChange.bind(this),
       paginationController,
+      (data: Amity.GlobalStoryFeedPayload) => {
+        const { feeds, ...rest } = prepareCommunityPayload({ ...data, feeds: [] });
+        return { ...data, ...rest };
+      },
     );
 
     this.paginationController = paginationController;

package/src/storyRepository/observers/getGlobalStoryTargets/GlobalStoryQueryStreamController.ts

@@ -20,7 +20,9 @@ export class GlobalStoryQueryStreamController extends QueryStreamController<
 > {
   private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
 
-  private preparePayload: (response: Amity.GlobalStoryFeedPayload) => Amity.GlobalStoryFeedPayload;
+  private preparePayload: (
+    response: Amity.GlobalStoryFeedPayload,
+  ) => Amity.ProcessedGlobalStoryFeed;
 
   private paginationController: GlobalStoryPageController;
 
@@ -29,13 +31,14 @@ export class GlobalStoryQueryStreamController extends QueryStreamController<
     cacheKey: string[],
     notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
     paginationController: GlobalStoryPageController,
+    preparePayload: (response: Amity.GlobalStoryFeedPayload) => Amity.ProcessedGlobalStoryFeed,
   ) {
     super(query, cacheKey);
     this.notifyChange = notifyChange;
     this.paginationController = paginationController;
 
     // Fix ESLint, "Expected 'this' to be used by class method"
-    this.preparePayload = payload => payload;
+    this.preparePayload = preparePayload;
   }
 
   saveToMainDB(response: Amity.GlobalStoryFeedPayload) {

package/src/userRepository/constants/index.ts

@@ -0,0 +1,4 @@
+export enum AmityUserSearchMatchType {
+  DEFAULT = 'default',
+  PARTIAL = 'partial',
+}

package/src/userRepository/index.ts

@@ -3,3 +3,4 @@ export * as Relationship from './relationship';
 export * from './api';
 export * from './events';
 export * from './observers';
+export * from './constants';

package/src/userRepository/observers/getBlockedUsers/BlockedUserLiveCollectionController.ts

@@ -8,6 +8,9 @@ import { prepareBlockedUserPayload } from '~/userRepository/utils/prepareBlocked
 import { LinkedObject } from '~/utils/linkedObject';
 import { onUserDeleted } from '~/userRepository/events';
 import { EnumUserActions } from '../enums';
+import { onLocalUserFollowed, onUserFollowed } from '~/userRepository/relationship/follow/events';
+import { convertEventPayload } from '~/utils/event';
+import { EnumFollowActions } from '~/userRepository/relationship/follow/enums';
 
 export class BlockedUserLiveCollectionController extends LiveCollectionController<
   'blockUser',
@@ -69,6 +72,15 @@ export class BlockedUserLiveCollectionController extends LiveCollectionControlle
         fn: onUserDeleted,
         action: EnumUserActions.OnUserDeleted,
       },
+      // In the case of unblocking a user, we need to subscribe to the follow events
+      {
+        fn: convertEventPayload(onLocalUserFollowed, 'to', 'user'),
+        action: EnumFollowActions.OnFollowed,
+      },
+      {
+        fn: convertEventPayload(onUserFollowed, 'to', 'user'),
+        action: EnumFollowActions.OnFollowed,
+      },
     ]);
   }
 
@@ -83,7 +95,6 @@ export class BlockedUserLiveCollectionController extends LiveCollectionControlle
         .map(({ data }) => data)
         .map(LinkedObject.user) ?? [],
     );
-
     if (!this.shouldNotify(data) && origin === 'event') return;
 
     this.callback({

package/src/userRepository/observers/getBlockedUsers/BlockedUserQueryStreamController.ts

@@ -4,6 +4,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 import { getActiveClient } from '~/client';
 import { EnumUserActions } from '../enums';
+import { EnumFollowActions } from '~/userRepository/relationship/follow/enums';
 
 export class BlockedUserQueryStreamController extends QueryStreamController<
   Amity.BlockedUserPayload,
@@ -56,11 +57,18 @@ export class BlockedUserQueryStreamController extends QueryStreamController<
     }
   }
 
-  reactor(action: EnumUserActions) {
-    return (followStatus: Amity.InternalUser) => {
-      const collection = pullFromCache<Amity.BlockedUserLiveCollectionCache>(this.cacheKey)?.data;
+  reactor(action: EnumUserActions | EnumFollowActions) {
+    return (targetUser: Amity.InternalUser) => {
+      if (action === EnumFollowActions.OnFollowed) {
+        const collection = pullFromCache<Amity.BlockedUserLiveCollectionCache>(this.cacheKey)?.data;
+        const updatedCollection = collection?.data.filter(id => id !== targetUser.userId);
+
+        pushToCache(this.cacheKey, {
+          ...collection,
+          data: updatedCollection,
+        });
+      }
 
-      pushToCache(this.cacheKey, collection);
       this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
     };
   }
@@ -68,7 +76,7 @@ export class BlockedUserQueryStreamController extends QueryStreamController<
   subscribeRTE(
     createSubscriber: {
       fn: (reactor: (user: Amity.InternalUser) => void) => Amity.Unsubscriber;
-      action: EnumUserActions;
+      action: EnumUserActions | EnumFollowActions;
     }[],
   ) {
     return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));

package/src/userRepository/relationship/follow/observers/getFollowers/FollowerLiveCollectionController.ts

@@ -34,7 +34,7 @@ export class FollowerLiveCollectionController extends LiveCollectionController<
     query: Amity.FollowerLiveCollection,
     callback: Amity.LiveCollectionCallback<Amity.FollowStatus>,
   ) {
-    const queryStreamId = hash(query);
+    const queryStreamId = hash({ ...query, type: 'follower' });
     const cacheKey = ['follow', 'collection', queryStreamId];
     const paginationController = new FollowerPaginationController(query);
 

package/src/userRepository/relationship/follow/observers/getFollowings/FollowingLiveCollectionController.ts

@@ -36,7 +36,7 @@ export class FollowingLiveCollectionController extends LiveCollectionController<
     query: Amity.FollowingLiveCollection,
     callback: Amity.LiveCollectionCallback<Amity.FollowStatus>,
   ) {
-    const queryStreamId = hash(query);
+    const queryStreamId = hash({ ...query, type: 'following' });
     const cacheKey = ['follow', 'collection', queryStreamId];
     const paginationController = new FollowingPaginationController(query);
 

package/src/utils/linkedObject/messageLinkedObject.ts

@@ -1,3 +1,4 @@
+import { pullFromCache } from '~/cache/api';
 import { getMessageReadCount } from '~/messageRepository/utils/getMessageReadCount';
 import { markReadMessage } from '~/messageRepository/utils/markReadMessage';
 
@@ -11,6 +12,9 @@ export const messageLinkedObject = (message: Amity.InternalMessage): Amity.Messa
     get deliveredCount() {
       return getMessageReadCount(message).deliveredCount;
     },
+    get creator() {
+      return pullFromCache<Amity.InternalUser>(['user', 'get', message.creatorId])?.data;
+    },
     markRead: () => markReadMessage(message),
   };
 };

package/dist/reactionRepository/observers/getReactions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getReactions.d.ts","sourceRoot":"","sources":["../../../src/reactionRepository/observers/getReactions.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,YAAY,WACf,MAAM,sBAAsB,YAC1B,MAAM,sBAAsB,CAAC,MAAM,OAAO,CAAC,WAC5C,MAAM,oBAAoB,KAClC,MAAM,YAsGR,CAAC"}

package/src/reactionRepository/observers/getReactions.ts

@@ -1,146 +0,0 @@
-/* eslint-disable no-use-before-define */
-import { getResolver } from '~/core/model';
-import { getActiveClient } from '~/client/api';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { createQuery, queryOptions, runQuery } from '~/core/query';
-
-import {
-  COLLECTION_DEFAULT_CACHING_POLICY,
-  COLLECTION_DEFAULT_PAGINATION_LIMIT,
-} from '~/utils/constants';
-
-import { LinkedObject } from '~/utils/linkedObject';
-import { onReactorAdded, onReactorRemoved } from '../events';
-import { queryReactor } from '../api/queryReactor';
-
-/* begin_public_function
-  id: reaction.query
-*/
-/**
- * ```js
- * import { getReactions } from '@amityco/ts-sdk-react-native'
- *
- * 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.InternalReactor} for a given target object
- *
- * @param params for querying reactions
- * @param callback the function to call when new data are available
- * @param config the live collection configuration
- * @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.InternalReactor>(['reactor', 'get', reactorId])!)
-        .filter(Boolean)
-        .map(({ data }) => LinkedObject.reactor(data)) ?? [];
-
-    callback({
-      onNextPage: onFetch,
-      data: reactions,
-      hasNextPage: !!data.params?.page,
-      loading: data.loading,
-      error: data.error,
-    });
-  };
-
-  const realtimeRouter =
-    (action: Amity.ReactionActionType) => (reaction: Amity.InternalReactor) => {
-      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 = (initial = false) => {
-    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
-
-    const reactions = collection?.data ?? [];
-
-    if (!initial && reactions.length > 0 && !collection?.params?.page) return;
-
-    const query = createQuery(queryReactor, {
-      ...queryParams,
-      page: (!initial ? collection?.params.page : undefined) ?? { 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.map(getResolver('reactor'))])];
-        }
-
-        pushToCache(cacheKey, data);
-
-        responder(data);
-      },
-      queryOptions(policy),
-    );
-  };
-
-  disposers.push(
-    onReactorAdded(queryParams.referenceType, queryParams.referenceId, realtimeRouter('onAdded')),
-    onReactorRemoved(
-      queryParams.referenceType,
-      queryParams.referenceId,
-      realtimeRouter('onRemoved'),
-    ),
-  );
-
-  onFetch(true);
-
-  return () => {
-    log(`liveReactions(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};
-/* end_public_function */