@stream-io/feeds-client 0.3.31 → 0.3.33

package/src/bindings/react/hooks/feed-state-hooks/useOwnCapabilities.ts

@@ -1,38 +1,29 @@
-import { useCallback } from 'react';
 import { useStateStore } from '@stream-io/state-store/react-bindings';
 
 import { useFeedContext } from '../../contexts/StreamFeedContext';
-import { useFeedsClient } from '../../contexts/StreamFeedsContext';
-import type { Feed } from '../../../../feed';
+import type { Feed, FeedState } from '../../../../feed';
 import type { FeedOwnCapability } from '../../../../gen/models';
-import type { FeedsClientState } from '../../../../feeds-client';
+import { useFeedsClient } from '../../contexts/StreamFeedsContext';
 
 const stableEmptyArray: readonly FeedOwnCapability[] = [];
 
+const selector = (currentState: FeedState) => {
+  return {
+    feedOwnCapabilities: currentState.own_capabilities ?? stableEmptyArray,
+  };
+};
+
 export const useOwnCapabilities = (feedFromProps?: Feed | string) => {
   const client = useFeedsClient();
   const feedFromContext = useFeedContext();
-  const feed = feedFromProps ?? feedFromContext;
-  const fid = typeof feed === 'string' ? feed : feed?.feed;
-
-  const selector = useCallback(
-    (currentState: FeedsClientState) => {
-      if (!fid) {
-        return { feedOwnCapabilities: stableEmptyArray };
-      }
-
-      return {
-        feedOwnCapabilities:
-          currentState.own_capabilities_by_fid[fid] ?? stableEmptyArray,
-      };
-    },
-    [fid],
-  );
+  let feed = feedFromProps ?? feedFromContext;
+  if (typeof feed === 'string') {
+    const [groupId, id] = feed.split(':');
+    feed = groupId && id ? client?.feed(groupId, id) : undefined;
+  }
 
   const { feedOwnCapabilities = stableEmptyArray } =
-    useStateStore(client?.state, selector) ?? {};
-
-  // console.log('GETTING CAPA: ', feed?.feed, feedOwnCapabilities);
+    useStateStore(feed?.state, selector) ?? {};
 
   return feedOwnCapabilities;
 };

package/src/bindings/react/hooks/feed-state-hooks/useOwnFollowings.ts

@@ -0,0 +1,18 @@
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+import type { Feed, FeedState } from '../../../../feed';
+
+/**
+ * A React hook that returns a reactive array of feeds that the feeds's owner is following and is owned by the current user.
+ */
+export const useOwnFollowings = (feedFromProps?: Feed) => {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+
+  return useStateStore(feed?.state, selector);
+};
+
+const selector = ({ own_followings }: FeedState) => ({
+  own_followings,
+});

package/src/common/types.ts

@@ -6,7 +6,7 @@ export type FeedsClientOptions = {
   base_url?: string;
   timeout?: number;
   configure_loggers_options?: ConfigureLoggersOptions;
-  query_batch_own_capabilties_throttling_interval?: number;
+  query_batch_own_fields_throttling_interval?: number;
 };
 
 export type RateLimit = {

package/src/feed/event-handlers/activity/handle-activity-added.ts

@@ -62,12 +62,6 @@ export function handleActivityAdded(
     const activity = event.activity;
     this.client.hydratePollCache([activity]);
 
-    const currentFeed = activity.current_feed;
-
-    if (currentFeed) {
-      this.client.hydrateCapabilitiesCache([currentFeed]);
-    }
-
     this.state.partialNext({ activities: result.activities });
   }
 }

package/src/feed/event-handlers/activity/handle-activity-updated.ts

@@ -92,10 +92,6 @@ export function handleActivityUpdated(
   if (result1?.changed || result2.changed) {
     this.client.hydratePollCache([payload.activity]);
 
-    if (payload.activity.current_feed) {
-      this.client.hydrateCapabilitiesCache([payload.activity.current_feed]);
-    }
-
     this.state.partialNext({
       activities: result1?.changed ? result1.entities : currentActivities,
       pinned_activities: result2.entities,

package/src/feed/feed.ts

@@ -14,6 +14,7 @@ import type {
   FollowRequest,
   QueryCommentsRequest,
   ActivityAddedEvent,
+  EnrichmentOptions,
 } from '../gen/models';
 import type { StreamResponse } from '../gen-imports';
 import { StateStore } from '@stream-io/state-store';
@@ -63,16 +64,16 @@ import {
   checkHasAnotherPage,
   Constants,
   feedsLoggerSystem,
-  ownFeedFields,
   uniqueArrayMerge,
 } from '../utils';
 import { handleActivityFeedback } from './event-handlers/activity/handle-activity-feedback';
 import { deepEqual } from '../utils/deep-equal';
 import { getOrCreateActiveFeed } from '../feeds-client/get-or-create-active-feed';
+import { queueBatchedOwnFields } from '../utils/throttling';
 
 export type FeedState = Omit<
   Partial<GetOrCreateFeedResponse & FeedResponse>,
-  'feed' | 'own_capabilities' | 'duration'
+  'feed' | 'duration'
 > & {
   /**
    * True when loading state using `getOrCreate`
@@ -333,11 +334,6 @@ export class Feed extends FeedApi {
         }
       }
 
-      this.client.hydrateCapabilitiesCache([
-        response.feed,
-        ...currentActivityFeeds,
-      ]);
-
       if (request?.next) {
         const { activities: currentActivities = [] } = this.currentState;
 
@@ -919,10 +915,7 @@ export class Feed extends FeedApi {
       ...request,
       feeds: [this.feed],
     });
-    const currentFeed = response.activity.current_feed;
-    if (currentFeed) {
-      this.client.hydrateCapabilitiesCache([currentFeed]);
-    }
+
     return response;
   }
 
@@ -934,34 +927,19 @@ export class Feed extends FeedApi {
 
     // no need to run noop function
     if (eventHandler !== Feed.noop) {
-      if ('activity' in event && this.hasActivity(event.activity.id)) {
+      // Backfill current_feed if activity is posted to multiple feeds
+      if (
+        'activity' in event &&
+        event.activity.feeds.length > 1 &&
+        this.hasActivity(event.activity.id)
+      ) {
         const currentActivity = this.currentState.activities?.find(
           (a) => a.id === event.activity.id,
         );
 
-        // Backfill current_feed if activity is posted to multiple feeds
-        if (
-          event.activity.feeds.length > 1 &&
-          !event.activity.current_feed &&
-          currentActivity?.current_feed
-        ) {
+        if (!event.activity.current_feed && currentActivity?.current_feed) {
           event.activity.current_feed = currentActivity.current_feed;
         }
-
-        // Backfill own_ fields if activity is posted to a single feed
-        if (
-          event.activity.feeds.length === 1 &&
-          event.activity.current_feed &&
-          currentActivity?.current_feed
-        ) {
-          ownFeedFields.forEach((field) => {
-            if (field in currentActivity.current_feed!) {
-              // @ts-expect-error TODO: fix this
-              event.activity.current_feed![field] =
-                currentActivity.current_feed![field];
-            }
-          });
-        }
       }
       // @ts-expect-error intersection of handler arguments results to never
       eventHandler?.(event);
@@ -994,10 +972,7 @@ export class Feed extends FeedApi {
   ) {
     const enrichmentOptions =
       this.currentState.last_get_or_create_request_config?.enrichment_options;
-    if (
-      !enrichmentOptions?.skip_activity_current_feed &&
-      !enrichmentOptions?.skip_all
-    ) {
+    if (this.shouldAddToActiveFeeds(enrichmentOptions)) {
       const feedsToGetOrCreate = new Map<string, FeedResponse>();
       activities.forEach((activity) => {
         if (
@@ -1010,14 +985,51 @@ export class Feed extends FeedApi {
           );
         }
       });
-      Array.from(feedsToGetOrCreate.values()).forEach((feed) => {
+      const newFeeds = Array.from(feedsToGetOrCreate.values());
+      const fieldsToUpdate: Array<
+        'own_capabilities' | 'own_follows' | 'own_followings' | 'own_membership'
+      > = [];
+      if (!options.fromWebSocket) {
+        fieldsToUpdate.push(
+          'own_capabilities',
+          'own_follows',
+          'own_membership',
+        );
+        if (enrichmentOptions?.enrich_own_followings) {
+          fieldsToUpdate.push('own_followings');
+        }
+      }
+      newFeeds.forEach((feed) => {
         getOrCreateActiveFeed.bind(this.client)({
           group: feed.group_id,
           id: feed.id,
           data: feed,
-          fromWebSocket: options.fromWebSocket,
+          fieldsToUpdate,
         });
       });
+      if (options.fromWebSocket) {
+        const uninitializedFeeds = newFeeds.filter((feedResponse) => {
+          const feed = this.client.feed(feedResponse.group_id, feedResponse.id);
+          // own_capabilities can only be undefined if we haven't fetched it yet
+          return feed.currentState.own_capabilities === undefined;
+        });
+        if (uninitializedFeeds.length > 0) {
+          queueBatchedOwnFields.bind(this.client)({
+            feeds: uninitializedFeeds.map((feed) => feed.feed),
+          });
+        }
+      }
     }
   }
+
+  private shouldAddToActiveFeeds(enrichmentOptions?: EnrichmentOptions) {
+    if (!enrichmentOptions) {
+      return true;
+    }
+    return (
+      !enrichmentOptions?.skip_activity &&
+      !enrichmentOptions?.skip_activity_current_feed &&
+      !enrichmentOptions?.skip_all
+    );
+  }
 }

package/src/feeds-client/feeds-client.ts

@@ -60,6 +60,7 @@ import { ModerationClient } from '../moderation-client';
 import { StreamPoll } from '../common/Poll';
 import {
   Feed,
+  type FeedState,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
   handleActivityReactionUpdated,
@@ -86,15 +87,16 @@ import { feedsLoggerSystem } from '../utils';
 import { handleCommentReactionUpdated } from '../feed/event-handlers/comment/handle-comment-reaction-updated';
 import {
   throttle,
-  DEFAULT_BATCH_OWN_CAPABILITIES_THROTTLING_INTERVAL,
-  type GetBatchedOwnCapabilitiesThrottledCallback,
-  queueBatchedOwnCapabilities,
-  type ThrottledGetBatchedOwnCapabilities,
   clearQueuedFeeds,
+  type ThrottledGetBatchedOwnFields,
+  type GetBatchedOwnFieldsThrottledCallback,
+  DEFAULT_BATCH_OWN_FIELDS_THROTTLING_INTERVAL,
 } from '../utils/throttling';
 import { ActivityWithStateUpdates } from '../activity-with-state-updates/activity-with-state-updates';
 import { getFeed } from '../activity-with-state-updates/get-feed';
 import {
+  isOwnCapabilitiesEqual,
+  isOwnFollowingsEqual,
   isOwnFollowsEqual,
   isOwnMembershipEqual,
 } from '../utils/check-own-fields-equality';
@@ -102,7 +104,6 @@ import {
 export type FeedsClientState = {
   connected_user: ConnectedUser | undefined;
   is_ws_connection_healthy: boolean;
-  own_capabilities_by_fid: Record<string, FeedResponse['own_capabilities']>;
 };
 
 type FID = string;
@@ -128,9 +129,9 @@ export class FeedsClient extends FeedsApi {
 
   private healthyConnectionChangedEventCount = 0;
 
-  protected throttledGetBatchOwnCapabilities!: ThrottledGetBatchedOwnCapabilities;
-  private cancelGetBatchOwnCapabilitiesTimer!: () => void;
-  private query_batch_own_capabilties_throttling_interval!: number;
+  protected throttledGetBatchOwnFields!: ThrottledGetBatchedOwnFields;
+  private cancelGetBatchOwnFieldsTimer!: () => void;
+  private query_batch_own_fields_throttling_interval!: number;
 
   constructor(apiKey: string, options?: FeedsClientOptions) {
     const tokenManager = new TokenManager();
@@ -145,16 +146,15 @@ export class FeedsClient extends FeedsApi {
     this.state = new StateStore<FeedsClientState>({
       connected_user: undefined,
       is_ws_connection_healthy: false,
-      own_capabilities_by_fid: {},
     });
     this.moderation = new ModerationClient(apiClient);
     this.tokenManager = tokenManager;
     this.connectionIdManager = connectionIdManager;
     this.polls_by_id = new Map();
 
-    this.query_batch_own_capabilties_throttling_interval =
-      options?.query_batch_own_capabilties_throttling_interval ??
-      DEFAULT_BATCH_OWN_CAPABILITIES_THROTTLING_INTERVAL;
+    this.query_batch_own_fields_throttling_interval =
+      options?.query_batch_own_fields_throttling_interval ??
+      DEFAULT_BATCH_OWN_FIELDS_THROTTLING_INTERVAL;
 
     feedsLoggerSystem.configureLoggers(options?.configure_loggers_options);
 
@@ -184,6 +184,7 @@ export class FeedsClient extends FeedsApi {
             group: event.feed.group_id,
             id: event.feed.id,
             data: event.feed,
+            fieldsToUpdate: [],
           });
 
           break;
@@ -284,30 +285,27 @@ export class FeedsClient extends FeedsApi {
     });
   }
 
-  private setGetBatchOwnCapabilitiesThrottlingInterval = (
-    throttlingMs: number,
-  ) => {
-    const {
-      throttledFn: throttledGetBatchOwnCapabilities,
-      cancelTimer: cancel,
-    } = throttle<GetBatchedOwnCapabilitiesThrottledCallback>(
-      (feeds, callback) => {
-        this.ownBatch({
-          feeds,
-        }).catch((error) => {
-          this.eventDispatcher.dispatch({
-            type: 'errors.unhandled',
-            error_type: UnhandledErrorType.FetchingOwnCapabilitiesOnNewActivity,
-            error,
+  private setGetBatchOwnFieldsThrottlingInterval = (throttlingMs: number) => {
+    const { throttledFn: throttledGetBatchOwnFields, cancelTimer: cancel } =
+      throttle<GetBatchedOwnFieldsThrottledCallback>(
+        (feeds, callback) => {
+          this.ownBatch({
+            feeds,
+          }).catch((error) => {
+            this.eventDispatcher.dispatch({
+              type: 'errors.unhandled',
+              error_type:
+                UnhandledErrorType.FetchingOwnCapabilitiesOnNewActivity,
+              error,
+            });
           });
-        });
-        callback(feeds);
-      },
-      throttlingMs,
-      { trailing: true },
-    );
-    this.throttledGetBatchOwnCapabilities = throttledGetBatchOwnCapabilities;
-    this.cancelGetBatchOwnCapabilitiesTimer = cancel;
+          callback(feeds);
+        },
+        throttlingMs,
+        { trailing: true },
+      );
+    this.throttledGetBatchOwnFields = throttledGetBatchOwnFields;
+    this.cancelGetBatchOwnFieldsTimer = cancel;
   };
 
   private recoverOnReconnect = async () => {
@@ -369,34 +367,6 @@ export class FeedsClient extends FeedsApi {
     }
   }
 
-  public hydrateCapabilitiesCache(
-    feedResponses: Array<Pick<FeedResponse, 'feed' | 'own_capabilities'>>,
-  ) {
-    let ownCapabilitiesCache =
-      this.state.getLatestValue().own_capabilities_by_fid;
-
-    const capabilitiesToFetchQueue: string[] = [];
-
-    for (const feedResponse of feedResponses) {
-      const { feed, own_capabilities } = feedResponse;
-
-      if (!Object.prototype.hasOwnProperty.call(ownCapabilitiesCache, feed)) {
-        if (own_capabilities) {
-          ownCapabilitiesCache = {
-            ...ownCapabilitiesCache,
-            [feed]: own_capabilities,
-          };
-        } else {
-          capabilitiesToFetchQueue.push(feed);
-        }
-      }
-    }
-
-    queueBatchedOwnCapabilities.bind(this)({ feeds: capabilitiesToFetchQueue });
-
-    this.state.partialNext({ own_capabilities_by_fid: ownCapabilitiesCache });
-  }
-
   connectUser = async (user: UserRequest, tokenProvider?: TokenOrProvider) => {
     if (
       this.state.getLatestValue().connected_user !== undefined ||
@@ -407,8 +377,8 @@ export class FeedsClient extends FeedsApi {
 
     this.tokenManager.setTokenOrProvider(tokenProvider);
 
-    this.setGetBatchOwnCapabilitiesThrottlingInterval(
-      this.query_batch_own_capabilties_throttling_interval,
+    this.setGetBatchOwnFieldsThrottlingInterval(
+      this.query_batch_own_fields_throttling_interval,
     );
 
     try {
@@ -649,10 +619,9 @@ export class FeedsClient extends FeedsApi {
     this.state.partialNext({
       connected_user: undefined,
       is_ws_connection_healthy: false,
-      own_capabilities_by_fid: {},
     });
 
-    this.cancelGetBatchOwnCapabilitiesTimer();
+    this.cancelGetBatchOwnFieldsTimer();
     clearQueuedFeeds();
   };
 
@@ -680,6 +649,7 @@ export class FeedsClient extends FeedsApi {
       group: groupId,
       id,
       options,
+      fieldsToUpdate: [],
     });
   };
 
@@ -711,11 +681,15 @@ export class FeedsClient extends FeedsApi {
         id: feedResponse.id,
         data: feedResponse,
         watch: request?.watch,
+        fieldsToUpdate: [
+          'own_capabilities',
+          'own_follows',
+          'own_membership',
+          'own_followings',
+        ],
       }),
     );
 
-    this.hydrateCapabilitiesCache(feedResponses);
-
     return {
       feeds,
       next: response.next,
@@ -727,13 +701,12 @@ export class FeedsClient extends FeedsApi {
 
   async ownBatch(request: OwnBatchRequest) {
     const response = await super.ownBatch(request);
-    const feedResponses = Object.entries(response.data).map(
-      ([feed, ownFields]) => ({
-        feed,
-        own_capabilities: ownFields.own_capabilities,
-      }),
-    );
-    this.hydrateCapabilitiesCache(feedResponses);
+    Object.entries(response.data).forEach(([fid, ownFields]) => {
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        feed.state.partialNext(ownFields);
+      }
+    });
     return response;
   }
 
@@ -826,7 +799,6 @@ export class FeedsClient extends FeedsApi {
     },
   ) {
     const response = await super.getOrCreateFeed(request);
-    this.hydrateCapabilitiesCache([response.feed]);
 
     if (request.watch) {
       const feeds = this.findAllActiveFeedsByFid(
@@ -848,6 +820,12 @@ export class FeedsClient extends FeedsApi {
         group: suggestion.group_id,
         id: suggestion.id,
         data: suggestion,
+        fieldsToUpdate: [
+          'own_capabilities',
+          'own_follows',
+          'own_membership',
+          'own_followings',
+        ],
       });
     });
 
@@ -861,7 +839,7 @@ export class FeedsClient extends FeedsApi {
     data,
     watch,
     options,
-    fromWebSocket = false,
+    fieldsToUpdate,
   }: {
     group: string;
     id: string;
@@ -871,7 +849,9 @@ export class FeedsClient extends FeedsApi {
       addNewActivitiesTo?: 'start' | 'end';
       activityAddedEventFilter?: (event: ActivityAddedEvent) => boolean;
     };
-    fromWebSocket?: boolean;
+    fieldsToUpdate: Array<
+      'own_capabilities' | 'own_follows' | 'own_followings' | 'own_membership'
+    >;
   }) => {
     const fid = `${group}:${id}`;
     let isCreated = false;
@@ -909,18 +889,35 @@ export class FeedsClient extends FeedsApi {
           handleFeedUpdated.call(feed, { feed: data });
         } else if (
           (feed.currentState.updated_at?.getTime() ?? 0) ===
-            data.updated_at.getTime() &&
-          !fromWebSocket
+          data.updated_at.getTime()
         ) {
-          const fieldsToUpdate: Array<keyof FeedResponse> = [];
-          if (!isOwnFollowsEqual(feed.currentState, data)) {
-            fieldsToUpdate.push('own_follows');
-          }
-          if (!isOwnMembershipEqual(feed.currentState, data)) {
-            fieldsToUpdate.push('own_membership');
-          }
-          if (fieldsToUpdate.length > 0) {
-            const fieldsToUpdateData = fieldsToUpdate.reduce(
+          const fieldsToUpdateData: Array<keyof FeedResponse> = [];
+          const fieldChecks: Array<
+            [
+              (
+                | 'own_capabilities'
+                | 'own_follows'
+                | 'own_membership'
+                | 'own_followings'
+              ),
+              (currentState: FeedState, newState: FeedResponse) => boolean,
+            ]
+          > = [
+            ['own_capabilities', isOwnCapabilitiesEqual],
+            ['own_follows', isOwnFollowsEqual],
+            ['own_membership', isOwnMembershipEqual],
+            ['own_followings', isOwnFollowingsEqual],
+          ];
+          fieldChecks.forEach(([field, isEqual]) => {
+            if (
+              fieldsToUpdate.includes(field) &&
+              !isEqual(feed.currentState, data)
+            ) {
+              fieldsToUpdateData.push(field);
+            }
+          });
+          if (fieldsToUpdateData.length > 0) {
+            const fieldsToUpdatePayload = fieldsToUpdateData.reduce(
               (acc: Partial<FeedResponse>, field) => {
                 // @ts-expect-error TODO: fix this
                 acc[field] = data[field];
@@ -928,7 +925,7 @@ export class FeedsClient extends FeedsApi {
               },
               {},
             );
-            feed.state.partialNext(fieldsToUpdateData);
+            feed.state.partialNext(fieldsToUpdatePayload);
           }
         }
       }

package/src/gen/models/index.ts

@@ -614,6 +614,8 @@ export interface AddCommentReactionResponse {
   comment: CommentResponse;
 
   reaction: FeedsReactionResponse;
+
+  notification_created?: boolean;
 }
 
 export interface AddCommentRequest {
@@ -644,6 +646,8 @@ export interface AddCommentResponse {
   duration: string;
 
   comment: CommentResponse;
+
+  notification_created?: boolean;
 }
 
 export interface AddCommentsBatchRequest {
@@ -680,6 +684,8 @@ export interface AddReactionResponse {
   activity: ActivityResponse;
 
   reaction: FeedsReactionResponse;
+
+  notification_created?: boolean;
 }
 
 export interface AggregatedActivityResponse {
@@ -5258,6 +5264,8 @@ export interface SingleFollowResponse {
   duration: string;
 
   follow: FollowResponse;
+
+  notification_created?: boolean;
 }
 
 export interface SortParam {