@stream-io/feeds-client 0.2.17 → 0.2.19

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

@@ -1,84 +1,32 @@
-import { useMemo } from 'react';
-import { type Feed, type FeedState, FeedOwnCapability } from '@self';
+import type { FeedOwnCapability, Feed, FeedsClientState } from '@self';
 import { useStateStore } from '@stream-io/state-store/react-bindings';
 import { useFeedContext } from '../../contexts/StreamFeedContext';
+import { useFeedsClient } from '../../contexts/StreamFeedsContext';
+import { useCallback } from 'react';
 
 const stableEmptyArray: readonly FeedOwnCapability[] = [];
 
-const selector = (currentState: FeedState) => ({
-  oc: currentState.own_capabilities ?? stableEmptyArray,
-});
-
-type KebabToSnakeCase<S extends string> = S extends `${infer T}-${infer U}`
-  ? `${T}_${KebabToSnakeCase<U>}`
-  : S;
-
 export const useOwnCapabilities = (feedFromProps?: Feed) => {
+  const client = useFeedsClient();
   const feedFromContext = useFeedContext();
   const feed = feedFromProps ?? feedFromContext;
+  const fid = feed?.feed;
+
+  const selector = useCallback((currentState: FeedsClientState) => {
+    if (!fid) {
+      return { feedOwnCapabilities: stableEmptyArray };
+    }
+
+    return {
+      feedOwnCapabilities:
+        currentState.own_capabilities_by_fid[fid] ?? stableEmptyArray,
+    };
+  }, [fid]);
+
+  const { feedOwnCapabilities = stableEmptyArray } =
+    useStateStore(client?.state, selector) ?? {};
 
-  const { oc = stableEmptyArray } = useStateStore(feed?.state, selector) ?? {};
+  // console.log('GETTING CAPA: ', feed?.feed, feedOwnCapabilities);
 
-  return useMemo(
-    () => {
-      const capabilitiesSet = new Set(oc);
-      return ({
-        can_add_activity: capabilitiesSet.has(FeedOwnCapability.ADD_ACTIVITY),
-        can_add_activity_bookmark:
-          capabilitiesSet.has(FeedOwnCapability.ADD_ACTIVITY_BOOKMARK),
-        can_add_activity_reaction:
-          capabilitiesSet.has(FeedOwnCapability.ADD_ACTIVITY_REACTION),
-        can_add_comment: capabilitiesSet.has(FeedOwnCapability.ADD_COMMENT),
-        can_add_comment_reaction:
-          capabilitiesSet.has(FeedOwnCapability.ADD_COMMENT_REACTION),
-        can_create_feed: capabilitiesSet.has(FeedOwnCapability.CREATE_FEED),
-        can_delete_any_activity:
-          capabilitiesSet.has(FeedOwnCapability.DELETE_ANY_ACTIVITY),
-        can_delete_any_comment:
-          capabilitiesSet.has(FeedOwnCapability.DELETE_ANY_COMMENT),
-        can_delete_feed: capabilitiesSet.has(FeedOwnCapability.DELETE_FEED),
-        can_delete_own_activity:
-          capabilitiesSet.has(FeedOwnCapability.DELETE_OWN_ACTIVITY),
-        can_delete_own_activity_bookmark:
-          capabilitiesSet.has(FeedOwnCapability.DELETE_OWN_ACTIVITY_BOOKMARK),
-        can_delete_own_activity_reaction:
-          capabilitiesSet.has(FeedOwnCapability.DELETE_OWN_ACTIVITY_REACTION),
-        can_delete_own_comment:
-          capabilitiesSet.has(FeedOwnCapability.DELETE_OWN_COMMENT),
-        can_delete_own_comment_reaction:
-          capabilitiesSet.has(FeedOwnCapability.DELETE_OWN_COMMENT_REACTION),
-        can_follow: capabilitiesSet.has(FeedOwnCapability.FOLLOW),
-        can_pin_activity: capabilitiesSet.has(FeedOwnCapability.PIN_ACTIVITY),
-        can_query_feed_members:
-          capabilitiesSet.has(FeedOwnCapability.QUERY_FEED_MEMBERS),
-        can_query_follows:
-          capabilitiesSet.has(FeedOwnCapability.QUERY_FOLLOWS),
-        can_read_activities:
-          capabilitiesSet.has(FeedOwnCapability.READ_ACTIVITIES),
-        can_read_feed: capabilitiesSet.has(FeedOwnCapability.READ_FEED),
-        can_unfollow: capabilitiesSet.has(FeedOwnCapability.UNFOLLOW),
-        can_update_any_activity:
-          capabilitiesSet.has(FeedOwnCapability.UPDATE_ANY_ACTIVITY),
-        can_update_any_comment:
-          capabilitiesSet.has(FeedOwnCapability.UPDATE_ANY_COMMENT),
-        can_update_feed: capabilitiesSet.has(FeedOwnCapability.UPDATE_FEED),
-        can_update_feed_followers:
-          capabilitiesSet.has(FeedOwnCapability.UPDATE_FEED_FOLLOWERS),
-        can_update_feed_members:
-          capabilitiesSet.has(FeedOwnCapability.UPDATE_FEED_MEMBERS),
-        can_update_own_activity:
-          capabilitiesSet.has(FeedOwnCapability.UPDATE_OWN_ACTIVITY),
-        can_update_own_activity_bookmark:
-          capabilitiesSet.has(FeedOwnCapability.UPDATE_OWN_ACTIVITY_BOOKMARK),
-        can_update_own_comment:
-          capabilitiesSet.has(FeedOwnCapability.UPDATE_OWN_COMMENT),
-      }) satisfies Record<
-        `can_${KebabToSnakeCase<
-          (typeof FeedOwnCapability)[keyof typeof FeedOwnCapability]
-        >}`,
-        boolean
-      >;
-    },
-    [oc],
-  );
+  return feedOwnCapabilities;
 };

package/src/common/real-time/event-models.ts

@@ -1,4 +1,5 @@
-import type { OwnUser } from '../../gen/models';
+import type { OwnUser } from '@self';
+import type { StreamApiError } from '@self';
 
 export interface ConnectionChangedEvent {
   type: 'connection.changed';
@@ -39,9 +40,10 @@ export interface ConnectedEvent {
 
 export enum UnhandledErrorType {
   ReconnectionReconciliation = 'reconnection-reconciliation',
+  FetchingOwnCapabilitiesOnNewActivity = 'fetching-own-capabilities-on-new-activity',
 }
 
-export type SyncFailure = { feed: string, reason: unknown };
+export type SyncFailure = { feed: string; reason: unknown };
 
 export type UnhandledErrorEvent = {
   type: 'errors.unhandled';
@@ -51,4 +53,8 @@ export type UnhandledErrorEvent = {
       error_type: UnhandledErrorType.ReconnectionReconciliation;
       failures: SyncFailure[];
     }
+  | {
+      error_type: UnhandledErrorType.FetchingOwnCapabilitiesOnNewActivity;
+      error: StreamApiError;
+    }
 );

package/src/common/types.ts

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

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

@@ -1,6 +1,6 @@
 import type { Feed } from '../../feed';
 import type { ActivityResponse } from '../../../gen/models';
-import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+import type { EventPayload } from '../../../types-internal';
 
 export function addActivitiesToState(
   this: Feed,
@@ -8,20 +8,18 @@ export function addActivitiesToState(
   activities: ActivityResponse[] | undefined,
   position: 'start' | 'end',
 ) {
-  let result: UpdateStateResult<{ activities: ActivityResponse[] }>;
   if (activities === undefined) {
-    activities = [];
-    result = {
-      changed: true,
-      activities,
-    };
-  } else {
-    result = {
+    return {
       changed: false,
-      activities,
+      activities: [],
     };
   }
 
+  let result = {
+    changed: false,
+    activities,
+  };
+
   const newActivitiesDeduplicated: ActivityResponse[] = [];
   newActivities.forEach((newActivityResponse) => {
     if (!this.hasActivity(newActivityResponse.id)) {
@@ -51,10 +49,18 @@ export function handleActivityAdded(
   const result = addActivitiesToState.bind(this)(
     [event.activity],
     currentActivities,
-    'start',
+    this.currentState.addNewActivitiesTo,
   );
   if (result.changed) {
-    this.client.hydratePollCache([event.activity]);
+    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

@@ -1,5 +1,8 @@
 import type { Feed } from '../../../feed';
-import type { ActivityPinResponse, ActivityResponse } from '../../../gen/models';
+import type {
+  ActivityPinResponse,
+  ActivityResponse,
+} from '../../../gen/models';
 import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 import {
   getStateUpdateQueueId,
@@ -7,25 +10,14 @@ import {
   updateEntityInArray,
 } from '../../../utils';
 import { eventTriggeredByConnectedUser } from '../../../utils/event-triggered-by-connected-user';
+import { updateActivity } from '../activity-updater';
 
 export type ActivityUpdatedPayload = PartializeAllBut<
   EventPayload<'feeds.activity.updated'>,
   'activity'
 >;
 
-const sharedUpdateActivity = ({
-  currentActivity,
-  event,
-}: {
-  currentActivity: ActivityResponse;
-  event: ActivityUpdatedPayload;
-}) => {
-  return {
-    ...event.activity,
-    own_reactions: currentActivity.own_reactions,
-    own_bookmarks: currentActivity.own_bookmarks,
-  };
-};
+const sharedUpdateActivity = updateActivity;
 
 export const updateActivityInState = (
   event: ActivityUpdatedPayload,
@@ -37,7 +29,7 @@ export const updateActivityInState = (
     updater: (matchedActivity) =>
       sharedUpdateActivity({
         currentActivity: matchedActivity,
-        event,
+        newActivtiy: event.activity,
       }),
   });
 
@@ -52,7 +44,7 @@ export const updatePinnedActivityInState = (
     updater: (matchedPinnedActivity) => {
       const newActivity = sharedUpdateActivity({
         currentActivity: matchedPinnedActivity.activity,
-        event,
+        newActivtiy: event.activity,
       });
 
       if (newActivity === matchedPinnedActivity.activity) {
@@ -100,6 +92,10 @@ 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/event-handlers/activity-updater.ts

@@ -0,0 +1,15 @@
+import type { ActivityResponse } from '../../gen/models';
+
+export const updateActivity = ({
+  currentActivity,
+  newActivtiy,
+}: {
+  currentActivity: ActivityResponse;
+  newActivtiy: ActivityResponse;
+}) => {
+  return {
+    ...newActivtiy,
+    own_reactions: currentActivity.own_reactions,
+    own_bookmarks: currentActivity.own_bookmarks,
+  };
+};

package/src/feed/event-handlers/add-aggregated-activities-to-state.ts

@@ -0,0 +1,72 @@
+import type { AggregatedActivityResponse } from '../../gen/models';
+import type { UpdateStateResult } from '../../types-internal';
+import { replaceUniqueArrayMerge, uniqueArrayMerge } from '../../utils';
+import { updateActivity } from './activity-updater';
+
+export const addAggregatedActivitiesToState = (
+  newAggregatedActivities: AggregatedActivityResponse[],
+  aggregatedActivities: AggregatedActivityResponse[] | undefined,
+  position: 'start' | 'end' | 'replace',
+) => {
+  let result: UpdateStateResult<{
+    aggregated_activities: AggregatedActivityResponse[];
+  }>;
+  if (newAggregatedActivities.length === 0) {
+    result = {
+      changed: false,
+      aggregated_activities: aggregatedActivities ?? [],
+    };
+  } else {
+    result = {
+      changed: true,
+      aggregated_activities: [],
+    };
+
+    // Merge update activities in the group
+    newAggregatedActivities.forEach((newAggregatedActivity) => {
+      const existingAggregatedActivity = aggregatedActivities?.find(
+        (a) => a.group === newAggregatedActivity.group,
+      );
+      if (existingAggregatedActivity) {
+        for (let i = 0; i < newAggregatedActivity.activities.length; i++) {
+          const activity = newAggregatedActivity.activities[i];
+          const existingActivity = existingAggregatedActivity.activities.find(
+            (a) => a.id === activity.id,
+          );
+          if (existingActivity) {
+            newAggregatedActivity.activities[i] = updateActivity({
+              currentActivity: existingActivity,
+              newActivtiy: activity,
+            });
+          }
+        }
+      }
+    });
+
+    switch (position) {
+      case 'start':
+        result.aggregated_activities = uniqueArrayMerge(
+          newAggregatedActivities,
+          aggregatedActivities ?? [],
+          (a) => a.group,
+        );
+        break;
+      case 'end':
+        result.aggregated_activities = uniqueArrayMerge(
+          aggregatedActivities ?? [],
+          newAggregatedActivities,
+          (a) => a.group,
+        );
+        break;
+      case 'replace':
+        result.aggregated_activities = replaceUniqueArrayMerge(
+          aggregatedActivities ?? [],
+          newAggregatedActivities,
+          (a) => a.group,
+        );
+        break;
+    }
+  }
+
+  return result;
+};

package/src/feed/event-handlers/index.ts

@@ -4,5 +4,7 @@ export * from './feed-member';
 export * from './bookmark';
 export * from './activity';
 export * from './feed';
-export * from './aggregated-feed';
+export * from './notification-feed';
+export * from './story-feeds';
 export * from './watch';
+export * from './add-aggregated-activities-to-state';

package/src/feed/event-handlers/{aggregated-feed/handle-aggregated-feed-updated.ts → notification-feed/handle-notification-feed-updated.ts}

@@ -3,57 +3,9 @@ import type {
   AggregatedActivityResponse,
   NotificationFeedUpdatedEvent,
   NotificationStatusResponse,
-  StoriesFeedUpdatedEvent,
 } from '../../../gen/models';
 import type { EventPayload, UpdateStateResult } from '../../../types-internal';
-import { replaceUniqueArrayMerge, uniqueArrayMerge } from '../../../utils';
-
-export const addAggregatedActivitiesToState = (
-  newAggregatedActivities: AggregatedActivityResponse[],
-  aggregatedActivities: AggregatedActivityResponse[] | undefined,
-  position: 'start' | 'end' | 'replace',
-) => {
-  let result: UpdateStateResult<{
-    aggregated_activities: AggregatedActivityResponse[];
-  }>;
-  if (newAggregatedActivities.length === 0) {
-    result = {
-      changed: false,
-      aggregated_activities: [],
-    };
-  } else {
-    result = {
-      changed: true,
-      aggregated_activities: [],
-    };
-  }
-
-  switch (position) {
-    case 'start':
-      result.aggregated_activities = uniqueArrayMerge(
-        newAggregatedActivities,
-        aggregatedActivities ?? [],
-        (a) => a.group,
-      );
-      break;
-    case 'end':
-      result.aggregated_activities = uniqueArrayMerge(
-        aggregatedActivities ?? [],
-        newAggregatedActivities,
-        (a) => a.group,
-      );
-      break;
-    case 'replace':
-      result.aggregated_activities = replaceUniqueArrayMerge(
-        aggregatedActivities ?? [],
-        newAggregatedActivities,
-        (a) => a.group,
-      );
-      break;
-  }
-
-  return result;
-};
+import { addAggregatedActivitiesToState } from '../add-aggregated-activities-to-state';
 
 export const updateNotificationStatus = (
   newNotificationStatus?: NotificationStatusResponse,
@@ -94,7 +46,7 @@ export const updateNotificationFeedFromEvent = (
     aggregated_activities?: AggregatedActivityResponse[];
   } = {};
 
-  if (event.notification_status && currentNotificationStatus) {
+  if (event.notification_status) {
     const notificationStatusResult = updateNotificationStatus(
       event.notification_status,
       currentNotificationStatus,
@@ -147,47 +99,3 @@ export function handleNotificationFeedUpdated(
     });
   }
 }
-
-export function updateStoriesFeedFromEvent(
-  aggregatedActivities: AggregatedActivityResponse[] | undefined,
-  event: StoriesFeedUpdatedEvent,
-): UpdateStateResult<{
-  data?: {
-    aggregated_activities?: AggregatedActivityResponse[];
-  };
-}> {
-  if (!aggregatedActivities) {
-    return {
-      changed: false,
-    };
-  }
-
-  if (event.aggregated_activities) {
-    const result = addAggregatedActivitiesToState(
-      event.aggregated_activities,
-      aggregatedActivities,
-      'replace',
-    );
-
-    return result;
-  }
-
-  return {
-    changed: false,
-  };
-}
-
-export function handleStoriesFeedUpdated(
-  this: Feed,
-  event: EventPayload<'feeds.stories_feed.updated'>,
-) {
-  const result = updateStoriesFeedFromEvent(
-    this.currentState.aggregated_activities,
-    event,
-  );
-  if (result.changed) {
-    this.state.partialNext({
-      aggregated_activities: result.data?.aggregated_activities,
-    });
-  }
-}

package/src/feed/event-handlers/notification-feed/index.ts

@@ -0,0 +1 @@
+export * from './handle-notification-feed-updated';

package/src/feed/event-handlers/story-feeds/handle-story-feeds-updated.ts

@@ -0,0 +1,122 @@
+import type {
+  ActivityResponse,
+  AggregatedActivityResponse,
+  StoriesFeedUpdatedEvent,
+} from '../../../gen/models';
+import type { UpdateStateResult, EventPayload } from '../../../types-internal';
+import type { Feed } from '../../feed';
+import { updateActivity } from '../activity-updater';
+import { addAggregatedActivitiesToState } from '../add-aggregated-activities-to-state';
+
+export const updateActivities = (
+  activitiesToUpsert: ActivityResponse[],
+  currentActivities: ActivityResponse[] | undefined,
+) => {
+  if (
+    !activitiesToUpsert ||
+    activitiesToUpsert.length === 0 ||
+    !currentActivities
+  ) {
+    return {
+      changed: false,
+      activities: currentActivities ?? [],
+    };
+  }
+
+  const result: ActivityResponse[] = [];
+  for (let i = 0; i < currentActivities.length; i++) {
+    const activity = currentActivities[i];
+    const updatedActivity = activitiesToUpsert.find(
+      (a) => a.id === activity.id,
+    );
+    if (updatedActivity) {
+      result.push(
+        updateActivity({
+          currentActivity: activity,
+          newActivtiy: updatedActivity,
+        }),
+      );
+    } else {
+      result.push(activity);
+    }
+  }
+
+  return {
+    changed: true,
+    activities: result,
+  };
+};
+
+export function updateStoriesFeedFromEvent(
+  aggregatedActivities: AggregatedActivityResponse[] | undefined,
+  activities: ActivityResponse[] | undefined,
+  event: StoriesFeedUpdatedEvent,
+): UpdateStateResult<{
+  data?: {
+    aggregated_activities?: AggregatedActivityResponse[];
+    activities?: ActivityResponse[];
+  };
+}> {
+  if (
+    (!aggregatedActivities &&
+      event.aggregated_activities &&
+      event.aggregated_activities?.length > 0) ||
+    (!activities && event.activities && event.activities?.length > 0)
+  ) {
+    return {
+      changed: false,
+    };
+  }
+
+  const result = {
+    changed: true,
+    data: {
+      aggregated_activities: aggregatedActivities,
+      activities: activities,
+    },
+  };
+  if (event.aggregated_activities) {
+    const aggregatedActivitiesResult = addAggregatedActivitiesToState(
+      event.aggregated_activities,
+      aggregatedActivities,
+      'replace',
+    );
+
+    if (aggregatedActivitiesResult.changed) {
+      result.data.aggregated_activities =
+        aggregatedActivitiesResult.aggregated_activities;
+    }
+  }
+
+  if (event.activities) {
+    const activitiesResult = updateActivities(event.activities, activities);
+    if (activitiesResult.changed) {
+      result.data.activities = activitiesResult.activities;
+    }
+  }
+
+  if (event.aggregated_activities || event.activities) {
+    return result;
+  }
+
+  return {
+    changed: false,
+  };
+}
+
+export function handleStoriesFeedUpdated(
+  this: Feed,
+  event: EventPayload<'feeds.stories_feed.updated'>,
+) {
+  const result = updateStoriesFeedFromEvent(
+    this.currentState.aggregated_activities,
+    this.currentState.activities,
+    event,
+  );
+  if (result.changed) {
+    this.state.partialNext({
+      aggregated_activities: result.data?.aggregated_activities,
+      activities: result.data?.activities,
+    });
+  }
+}

package/src/feed/event-handlers/story-feeds/index.ts

@@ -0,0 +1 @@
+export * from './handle-story-feeds-updated';

package/src/feed/feed.ts

@@ -62,7 +62,7 @@ import { checkHasAnotherPage, Constants, uniqueArrayMerge } from '../utils';
 
 export type FeedState = Omit<
   Partial<GetOrCreateFeedResponse & FeedResponse>,
-  'feed' | 'duration'
+  'feed' | 'own_capabilities' | 'duration'
 > & {
   /**
    * True when loading state using `getOrCreate`
@@ -131,6 +131,12 @@ export type FeedState = Omit<
    * `true` if the feed is receiving real-time updates via WebSocket
    */
   watch: boolean;
+
+  /**
+   * When a new activity is received from a WebSocket event by default it's added to the start of the list. You can change this to `end` to add it to the end of the list.
+   * Useful for story feeds.
+   */
+  addNewActivitiesTo: 'start' | 'end';
 };
 
 type EventHandlerByEventType = {
@@ -212,6 +218,7 @@ export class Feed extends FeedApi {
     id: string,
     data?: FeedResponse,
     watch = false,
+    addNewActivitiesTo: 'start' | 'end' = 'start',
   ) {
     super(client, groupId, id);
     this.state = new StateStore<FeedState>({
@@ -223,6 +230,7 @@ export class Feed extends FeedApi {
       is_loading_activities: false,
       comments_by_entity_id: {},
       watch,
+      addNewActivitiesTo,
     });
     this.client = client;
 
@@ -250,6 +258,10 @@ export class Feed extends FeedApi {
     return this.state.getLatestValue();
   }
 
+  set addNewActivitiesTo(value: 'start' | 'end') {
+    this.state.partialNext({ addNewActivitiesTo: value });
+  }
+
   hasActivity(activityId: string) {
     return this.indexedActivityIds.has(activityId);
   }
@@ -276,6 +288,16 @@ export class Feed extends FeedApi {
 
     try {
       const response = await super.getOrCreate(request);
+
+      const currentActivityFeeds = [];
+      for (const activity of response.activities) {
+        if (activity.current_feed) {
+          currentActivityFeeds.push(activity.current_feed);
+        }
+      }
+
+      this.client.hydrateCapabilitiesCache([response.feed, ...currentActivityFeeds]);
+
       if (request?.next) {
         const { activities: currentActivities = [] } = this.currentState;
 
@@ -837,11 +859,16 @@ export class Feed extends FeedApi {
     });
   }
 
-  addActivity(request: Omit<ActivityRequest, 'feeds'>) {
-    return this.feedsApi.addActivity({
+  async addActivity(request: Omit<ActivityRequest, 'feeds'>) {
+    const response = await this.client.addActivity({
       ...request,
       feeds: [this.feed],
     });
+    const currentFeed = response.activity.current_feed;
+    if (currentFeed) {
+      this.client.hydrateCapabilitiesCache([currentFeed]);
+    }
+    return response;
   }
 
   on = this.eventDispatcher.on;