@stream-io/feeds-client 0.3.7 → 0.3.8

package/dist/{feeds-client-3aXF89xy.mjs → feeds-client-DVbsjKUf.mjs}

@@ -3844,7 +3844,7 @@ const getRateLimitFromResponseHeader = (response_headers) => {
   };
   return result;
 };
-const version = "0.3.7";
+const version = "0.3.8";
 class ApiClient {
   constructor(apiKey, tokenManager, connectionIdManager, options) {
     this.apiKey = apiKey;
@@ -6480,7 +6480,7 @@ const _Feed = class _Feed extends FeedApi {
     }
   }
   async loadNextPageActivityComments(activity, request) {
-    const currentEntityState = this.currentState.comments_by_entity_id[activity.id];
+    const currentEntityState = this.currentState.comments_by_entity_id[typeof activity === "string" ? activity : activity.id];
     const currentPagination = currentEntityState?.pagination;
     const currentNextCursor = currentPagination?.next;
     const currentSort = currentPagination?.sort;
@@ -6489,12 +6489,13 @@ const _Feed = class _Feed extends FeedApi {
     if (isLoading || !checkHasAnotherPage(currentEntityState?.comments, currentNextCursor)) {
       return;
     }
+    const entityId = typeof activity === "string" ? activity : activity.id;
     await this.loadNextPageComments({
-      entityId: activity.id,
+      entityId,
       base: () => this.client.getComments({
         ...request,
         sort,
-        object_id: activity.id,
+        object_id: entityId,
         object_type: "activity",
         next: currentNextCursor
       }),
@@ -6729,7 +6730,7 @@ const _Feed = class _Feed extends FeedApi {
       eventHandler?.(event);
     }
     if (typeof eventHandler === "undefined") {
-      console.warn(`Received unknown event type: ${event.type}`, event);
+      feedsLoggerSystem.getLogger("event-dispatcher").warn(`Received unknown feed event, type: ${event.type}`, event);
     }
     this.eventDispatcher.dispatch(event);
   }
@@ -6871,6 +6872,156 @@ function queueBatchedOwnCapabilities({ feeds }) {
 function clearQueuedFeeds() {
   queuedFeeds.clear();
 }
+function connectActivityToFeed({
+  fid
+}) {
+  const [group, id] = fid.split(":");
+  const activeFeed = this.activeFeeds[fid];
+  const feed = new Feed(
+    this,
+    group,
+    id,
+    void 0,
+    activeFeed?.currentState.watch
+  );
+  return feed;
+}
+function isAnyFeedWatched(fids) {
+  for (const fid of fids) {
+    const feed = this.activeFeeds[fid];
+    if (feed && feed.currentState.last_get_or_create_request_config?.watch) {
+      return true;
+    }
+  }
+  return false;
+}
+function disconnectActivityFromFeed(id) {
+  const activeFeed = this.activeActivities[id];
+  if (activeFeed) {
+    delete this.activeActivities[id];
+  }
+}
+class ActivityWithStateUpdates {
+  constructor(id, feedsClient) {
+    this.id = id;
+    this.feedsClient = feedsClient;
+    this.state = new StateStore({
+      activity: void 0,
+      comments_by_entity_id: {},
+      is_loading: false
+    });
+  }
+  get currentState() {
+    return this.state.getLatestValue();
+  }
+  get feeds() {
+    return this.currentState.activity?.feeds ?? [];
+  }
+  /**
+   * Fetch activity and load it into state
+   * @param watch - Whether to watch the feed the activity belongs to for real-time updates
+   * @param feed - The feed to watch. Use only if the activity belongs to multiple feeds and you want to specify the feed explicitly.
+   * @param feedSelector - A function to select the feed from the activity response. Use only if the activity belongs to multiple feeds and you want to specify the feed explicitly.
+   */
+  async get(request = {}) {
+    if (this.inProgressGet && deepEqual(this.inProgressGet.request, request)) {
+      return this.inProgressGet.promise;
+    }
+    const { comments } = request;
+    this.state.partialNext({
+      is_loading: true,
+      last_get_request_config: request
+    });
+    const getActivityRequest = this.feedsClient.getActivity({
+      id: this.id
+    }).then((response) => response.activity);
+    this.inProgressGet = { request, promise: getActivityRequest };
+    const activityResponse = await getActivityRequest;
+    this.feedsClient.hydratePollCache([activityResponse]);
+    this.setFeed({
+      // We set feed to first containing feed
+      // But in WS event handler we match events by any of the containing feeds, so as long as any of the containing feeds are watched, we'll do a state update
+      // This is a bit hacky, proper solution would be to refactor all activity event handlers and detach them from feed instance
+      fid: activityResponse.feeds[0],
+      initialState: activityResponse
+    });
+    if (this.feed) {
+      this.feed.activityAddedEventFilter = () => false;
+    }
+    if (comments) {
+      await this.loadNextPageActivityComments(comments);
+    }
+    this.subscribeToFeedState();
+    this.inProgressGet = void 0;
+    return activityResponse;
+  }
+  loadNextPageActivityComments(request) {
+    const activity = this.feed?.currentState.activities?.[0];
+    if (!activity || !this.feed) {
+      throw new Error("Initialize activity first");
+    }
+    if (!this.currentState.last_get_request_config?.comments) {
+      this.state.partialNext({
+        last_get_request_config: {
+          ...this.currentState.last_get_request_config,
+          comments: request
+        }
+      });
+    }
+    return this.feed.loadNextPageActivityComments(activity, request);
+  }
+  loadNextPageCommentReplies(...params) {
+    if (!this.feed) {
+      throw new Error("Initialize activity first");
+    }
+    return this.feed.loadNextPageCommentReplies(...params);
+  }
+  dispose() {
+    this.unsubscribeFromFeedState?.();
+    disconnectActivityFromFeed.call(this.feedsClient, this.id);
+  }
+  /**
+   * @internal
+   */
+  async synchronize() {
+    const allFids = this.currentState.activity?.feeds ?? [];
+    if (!isAnyFeedWatched.call(this.feedsClient, allFids)) {
+      return;
+    }
+    this.inProgressGet = void 0;
+    return this.get(this.currentState.last_get_request_config);
+  }
+  setFeed({
+    fid,
+    initialState
+  }) {
+    this.feed = connectActivityToFeed.call(this.feedsClient, { fid });
+    this.feed.state.partialNext({
+      activities: [initialState]
+    });
+  }
+  subscribeToFeedState() {
+    this.unsubscribeFromFeedState?.();
+    this.unsubscribeFromFeedState = this.feed?.state.subscribeWithSelector(
+      (state) => ({
+        activity: state.activities?.find((activity) => activity.id === this.id),
+        comments_by_entity_id: state.comments_by_entity_id
+      }),
+      (state) => {
+        if (state.activity) {
+          this.state.partialNext({
+            activity: state.activity,
+            comments_by_entity_id: state.comments_by_entity_id,
+            is_loading: false
+          });
+        }
+      }
+    );
+  }
+}
+function getFeed() {
+  return this.feed;
+}
 class FeedsClient extends FeedsApi {
   constructor(apiKey, options) {
     const tokenManager = new TokenManager();
@@ -6883,6 +7034,7 @@ class FeedsClient extends FeedsApi {
     );
     super(apiClient);
     this.eventDispatcher = new EventDispatcher();
+    this.activeActivities = {};
     this.activeFeeds = {};
     this.healthyConnectionChangedEventCount = 0;
     this.setGetBatchOwnCapabilitiesThrottlingInterval = (throttlingMs) => {
@@ -6911,13 +7063,20 @@ class FeedsClient extends FeedsApi {
     this.recoverOnReconnect = async () => {
       this.healthyConnectionChangedEventCount++;
       if (this.healthyConnectionChangedEventCount > 1) {
-        const entries = Object.entries(this.activeFeeds);
-        const results = await Promise.allSettled(
-          entries.map(([, feed]) => feed.synchronize())
-        );
-        const failures = results.flatMap(
-          (result, index) => result.status === "rejected" ? [{ feed: entries[index][0], reason: result.reason }] : []
-        );
+        const feedEntries = Object.entries(this.activeFeeds);
+        const activityEntries = Object.entries(this.activeActivities);
+        const results = await Promise.allSettled([
+          ...feedEntries.map(([, feed]) => feed.synchronize()),
+          ...activityEntries.map(([, activity]) => activity.synchronize())
+        ]);
+        const failures = results.flatMap((result, index) => {
+          if (result.status === "fulfilled") {
+            return [];
+          }
+          const activity = activityEntries[index - feedEntries.length]?.[1];
+          const feed = feedEntries[index]?.[0] ?? (activity && getFeed.call(activity)?.feed);
+          return [{ feed, reason: result.reason, activity_id: activity?.id }];
+        });
         this.eventDispatcher.dispatch({
           type: "errors.unhandled",
           error_type: UnhandledErrorType.ReconnectionReconciliation,
@@ -6986,7 +7145,7 @@ class FeedsClient extends FeedsApi {
     };
     this.updateActivity = async (request) => {
       const response = await super.updateActivity(request);
-      for (const feed of Object.values(this.activeFeeds)) {
+      for (const feed of this.allActiveFeeds) {
         handleActivityUpdated.bind(feed)(response, false);
       }
       return response;
@@ -6994,7 +7153,7 @@ class FeedsClient extends FeedsApi {
     this.addComment = async (request) => {
       const response = await super.addComment(request);
       const { comment } = response;
-      for (const feed of Object.values(this.activeFeeds)) {
+      for (const feed of this.allActiveFeeds) {
         handleCommentAdded.bind(feed)(response, false);
         const parentActivityId = comment.object_id;
         if (feed.hasActivity(parentActivityId)) {
@@ -7017,7 +7176,7 @@ class FeedsClient extends FeedsApi {
     };
     this.updateComment = async (request) => {
       const response = await super.updateComment(request);
-      for (const feed of Object.values(this.activeFeeds)) {
+      for (const feed of this.allActiveFeeds) {
         handleCommentUpdated.bind(feed)(response, false);
       }
       return response;
@@ -7025,7 +7184,7 @@ class FeedsClient extends FeedsApi {
     this.deleteComment = async (request) => {
       const response = await super.deleteComment(request);
       const { activity, comment } = response;
-      for (const feed of Object.values(this.activeFeeds)) {
+      for (const feed of this.allActiveFeeds) {
         handleCommentDeleted.bind(feed)({ comment }, false);
         updateCommentCount.bind(feed)({
           activity,
@@ -7038,7 +7197,7 @@ class FeedsClient extends FeedsApi {
     this.addActivityReaction = async (request) => {
       const shouldEnforceUnique = request.enforce_unique;
       const response = await super.addActivityReaction(request);
-      for (const feed of Object.values(this.activeFeeds)) {
+      for (const feed of this.allActiveFeeds) {
         if (shouldEnforceUnique) {
           handleActivityReactionUpdated.bind(feed)(response, false);
         } else {
@@ -7052,7 +7211,7 @@ class FeedsClient extends FeedsApi {
     };
     this.deleteActivityReaction = async (request) => {
       const response = await super.deleteActivityReaction(request);
-      for (const feed of Object.values(this.activeFeeds)) {
+      for (const feed of this.allActiveFeeds) {
         handleActivityReactionDeleted.bind(feed)(response, false);
       }
       return response;
@@ -7060,7 +7219,7 @@ class FeedsClient extends FeedsApi {
     this.addCommentReaction = async (request) => {
       const shouldEnforceUnique = request.enforce_unique;
       const response = await super.addCommentReaction(request);
-      for (const feed of Object.values(this.activeFeeds)) {
+      for (const feed of this.allActiveFeeds) {
         if (shouldEnforceUnique) {
           handleCommentReactionUpdated.bind(feed)(response, false);
         } else {
@@ -7071,7 +7230,7 @@ class FeedsClient extends FeedsApi {
     };
     this.deleteCommentReaction = async (request) => {
       const response = await super.deleteCommentReaction(request);
-      for (const feed of Object.values(this.activeFeeds)) {
+      for (const feed of this.allActiveFeeds) {
         handleCommentReactionDeleted.bind(feed)(response, false);
       }
       return response;
@@ -7101,6 +7260,8 @@ class FeedsClient extends FeedsApi {
       this.connectionIdManager.reset();
       this.tokenManager.reset();
       this.polls_by_id.clear();
+      this.activeActivities = {};
+      this.activeFeeds = {};
       this.state.partialNext({
         connected_user: void 0,
         is_ws_connection_healthy: false,
@@ -7121,6 +7282,14 @@ class FeedsClient extends FeedsApi {
         options2?.activityAddedEventFilter
       );
     };
+    this.activityWithStateUpdates = (id) => {
+      let activity = this.activeActivities[id];
+      if (!activity) {
+        activity = new ActivityWithStateUpdates(id, this);
+        this.activeActivities[id] = activity;
+      }
+      return activity;
+    };
     this.updateNetworkConnectionStatus = (event) => {
       const networkEvent = {
         type: "network.changed",
@@ -7161,7 +7330,7 @@ class FeedsClient extends FeedsApi {
     feedsLoggerSystem.configureLoggers(options?.configure_loggers_options);
     this.on("all", (event) => {
       const fid = event.fid;
-      const feed = typeof fid === "string" ? this.activeFeeds[fid] : void 0;
+      const feeds = this.findAllActiveFeedsFromWSEvent(event);
       switch (event.type) {
         case "connection.changed": {
           const { online } = event;
@@ -7169,14 +7338,14 @@ class FeedsClient extends FeedsApi {
           if (online) {
             this.recoverOnReconnect();
           } else {
-            for (const activeFeed of Object.values(this.activeFeeds)) {
+            for (const activeFeed of this.allActiveFeeds) {
               handleWatchStopped.bind(activeFeed)();
             }
           }
           break;
         }
         case "feeds.feed.created": {
-          if (feed) break;
+          if (this.activeFeeds[event.feed.id]) break;
           this.getOrCreateActiveFeed(
             event.feed.group_id,
             event.feed.id,
@@ -7185,9 +7354,15 @@ class FeedsClient extends FeedsApi {
           break;
         }
         case "feeds.feed.deleted": {
-          feed?.handleWSEvent(event);
+          feeds.forEach((f) => f.handleWSEvent(event));
           if (typeof fid === "string") {
             delete this.activeFeeds[fid];
+            Object.keys(this.activeActivities).forEach((activityId) => {
+              const activity = this.activeActivities[activityId];
+              if (getFeed.call(activity)?.feed === fid) {
+                delete this.activeActivities[activityId];
+              }
+            });
           }
           break;
         }
@@ -7200,7 +7375,7 @@ class FeedsClient extends FeedsApi {
         case "feeds.poll.deleted": {
           if (event.poll?.id) {
             this.polls_by_id.delete(event.poll.id);
-            for (const activeFeed of Object.values(this.activeFeeds)) {
+            for (const activeFeed of this.allActiveFeeds) {
               const currentActivities = activeFeed.currentState.activities;
               if (currentActivities) {
                 const newActivities = [];
@@ -7248,14 +7423,14 @@ class FeedsClient extends FeedsApi {
         case "feeds.bookmark.deleted":
         case "feeds.bookmark.updated": {
           const activityId = event.bookmark.activity.id;
-          const feeds = this.findActiveFeedsByActivityId(activityId);
-          feeds.forEach((f) => f.handleWSEvent(event));
+          const allFeeds = this.findAllActiveFeedsByActivityId(activityId);
+          allFeeds.forEach((f) => f.handleWSEvent(event));
           break;
         }
         case "feeds.activity.feedback": {
           const activityId = event.activity_feedback.activity_id;
-          const feeds = this.findActiveFeedsByActivityId(activityId);
-          feeds.forEach((f) => f.handleWSEvent(event));
+          const allFeeds = this.findAllActiveFeedsByActivityId(activityId);
+          allFeeds.forEach((f) => f.handleWSEvent(event));
           break;
         }
         case "user.updated": {
@@ -7263,11 +7438,20 @@ class FeedsClient extends FeedsApi {
           break;
         }
         default: {
-          feed?.handleWSEvent(event);
+          feeds.forEach((f) => f.handleWSEvent(event));
+          if (event.type === "feeds.activity.deleted") {
+            delete this.activeActivities[event.activity.id];
+          }
         }
       }
     });
   }
+  get allActiveFeeds() {
+    return [
+      ...Object.values(this.activeFeeds),
+      ...Object.values(this.activeActivities).filter((a) => !!getFeed.call(a)).map((a) => getFeed.call(a))
+    ];
+  }
   hydratePollCache(activities) {
     for (const activity of activities) {
       if (!activity.poll) {
@@ -7339,10 +7523,8 @@ class FeedsClient extends FeedsApi {
       response.follow.source_feed.feed,
       response.follow.target_feed.feed
     ].forEach((fid) => {
-      const feed = this.activeFeeds[fid];
-      if (feed) {
-        handleFollowUpdated.bind(feed)(response, false);
-      }
+      const feeds = this.findAllActiveFeedsByFid(fid);
+      feeds.forEach((f) => handleFollowUpdated.bind(f)(response, false));
     });
     return response;
   }
@@ -7353,30 +7535,24 @@ class FeedsClient extends FeedsApi {
       response.follow.source_feed.feed,
       response.follow.target_feed.feed
     ].forEach((fid) => {
-      const feed = this.activeFeeds[fid];
-      if (feed) {
-        handleFollowCreated.bind(feed)(response, false);
-      }
+      const feeds = this.findAllActiveFeedsByFid(fid);
+      feeds.forEach((f) => handleFollowCreated.bind(f)(response, false));
     });
     return response;
   }
   async followBatch(request) {
     const response = await super.followBatch(request);
     response.follows.forEach((follow) => {
-      const feed = this.activeFeeds[follow.source_feed.feed];
-      if (feed) {
-        handleFollowCreated.bind(feed)({ follow });
-      }
+      const feeds = this.findAllActiveFeedsByFid(follow.source_feed.feed);
+      feeds.forEach((f) => handleFollowCreated.bind(f)({ follow }, false));
     });
     return response;
   }
   async unfollow(request) {
     const response = await super.unfollow(request);
     [request.source, request.target].forEach((fid) => {
-      const feed = this.activeFeeds[fid];
-      if (feed) {
-        handleFollowDeleted.bind(feed)(response, false);
-      }
+      const feeds = this.findAllActiveFeedsByFid(fid);
+      feeds.forEach((f) => handleFollowDeleted.bind(f)(response, false));
     });
     return response;
   }
@@ -7386,19 +7562,65 @@ class FeedsClient extends FeedsApi {
       ...request,
       connection_id: connectionId
     });
-    const feed = this.activeFeeds[`${request.feed_group_id}:${request.feed_id}`];
-    if (feed) {
-      handleWatchStopped.bind(feed)();
+    const feeds = this.findAllActiveFeedsByFid(
+      `${request.feed_group_id}:${request.feed_id}`
+    );
+    feeds.forEach((f) => handleWatchStopped.bind(f)());
+    return response;
+  }
+  async getOrCreateFeed(request) {
+    const response = await super.getOrCreateFeed(request);
+    this.hydrateCapabilitiesCache([response.feed]);
+    if (request.watch) {
+      const feeds = this.findAllActiveFeedsByFid(
+        `${request.feed_group_id}:${request.feed_id}`
+      );
+      feeds.forEach((f) => handleWatchStarted.bind(f)());
     }
     return response;
   }
-  findActiveFeedsByActivityId(activityId) {
-    return Object.values(this.activeFeeds).filter(
+  findAllActiveFeedsByActivityId(activityId) {
+    return [
+      ...Object.values(this.activeFeeds),
+      ...Object.values(this.activeActivities).filter((a) => !!getFeed.call(a)).map((a) => getFeed.call(a))
+    ].filter(
       (feed) => feed.hasActivity(activityId) || feed.hasPinnedActivity(activityId)
     );
   }
+  findAllActiveFeedsByFid(fid) {
+    if (!fid) return [];
+    const activeFeed = this.activeFeeds[fid];
+    return [
+      ...activeFeed ? [activeFeed] : [],
+      ...Object.values(this.activeActivities).filter((a) => getFeed.call(a)?.feed === fid).map((a) => getFeed.call(a))
+    ];
+  }
+  /**
+   * When updating from WS events we need a special logic:
+   * - Find active feeds that match a given fid.
+   * - Find active feed from activities where fid matches any of the feeds the activity is posted to.
+   *
+   * This logic is different from `findAllActiveFeedsByFid` which only checks the first feed an activity is posted to.
+   *
+   * @param fid
+   * @param activityId
+   * @returns
+   */
+  findAllActiveFeedsFromWSEvent(event) {
+    const fid = "fid" in event ? event.fid : void 0;
+    if (!fid) return [];
+    const activeFeed = fid ? this.activeFeeds[fid] : void 0;
+    return [
+      ...activeFeed ? [activeFeed] : [],
+      ...Object.values(this.activeActivities).filter((a) => {
+        const feed = getFeed.call(a);
+        return feed?.feed === fid || a.currentState.activity?.feeds.some((f) => f === fid);
+      }).map((a) => getFeed.call(a))
+    ];
+  }
 }
 export {
+  ActivityWithStateUpdates as A,
   Constants as C,
   FeedsClient as F,
   StreamApiError as S,
@@ -7420,4 +7642,4 @@ export {
   shouldUpdateState as s,
   uniqueArrayMerge as u
 };
-//# sourceMappingURL=feeds-client-3aXF89xy.mjs.map
+//# sourceMappingURL=feeds-client-DVbsjKUf.mjs.map