@stream-io/feeds-client 0.3.51 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/feeds-client",
-  "version": "0.3.51",
+  "version": "1.1.0",
   "packageManager": "yarn@3.2.4",
   "main": "./dist/cjs/index.js",
   "module": "./dist/es/index.mjs",
@@ -50,6 +50,7 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
+    "@stream-io/filter": "^1.0.0",
     "@stream-io/logger": "^2.0.0",
     "@stream-io/state-store": "^1.1.6",
     "axios": "^1.7.7"

package/src/activity-with-state-updates/activity-with-state-updates.ts

@@ -42,7 +42,9 @@ export class ActivityWithStateUpdates {
   constructor(
     public readonly id: string,
     private readonly feedsClient: FeedsClient,
-    { fromResponse }: { fromResponse?: ActivityResponse } = { fromResponse: undefined },
+    { fromResponse }: { fromResponse?: ActivityResponse } = {
+      fromResponse: undefined,
+    },
   ) {
     this.state = new StateStore<ActivityState>({
       activity: undefined,
@@ -104,7 +106,7 @@ export class ActivityWithStateUpdates {
     });
 
     if (this.feed) {
-      this.feed.activityAddedEventFilter = () => false;
+      this.feed.onNewActivity = () => 'ignore';
     }
 
     if (comments) {
@@ -177,6 +179,10 @@ export class ActivityWithStateUpdates {
       [initialState],
       [],
       'start',
+      {
+        hasOwnFields: initialState.current_feed?.own_capabilities !== undefined,
+        backfillOwnFields: false,
+      },
     );
     this.feed?.state.partialNext({
       activities,

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

@@ -1,30 +1,16 @@
-import { useMemo } from 'react';
-
-import { useFeedContext } from '../../contexts/StreamFeedContext';
-import { useNotificationStatus } from './useNotificationStatus';
 import type { Feed } from '../../../../feed';
 import type { AggregatedActivityResponse } from '../../../../gen/models';
 
+/**
+ * @deprecated use aggregatedActivity.is_read instead
+ * @returns
+ */
 export const useIsAggregatedActivityRead = ({
-  feed: feedFromProps,
+  feed: _,
   aggregatedActivity,
 }: {
   feed?: Feed;
   aggregatedActivity: AggregatedActivityResponse;
 }) => {
-  const feedFromContext = useFeedContext();
-  const feed = feedFromProps ?? feedFromContext;
-
-  const { read_activities: readActivities, last_read_at: lastReadAt } =
-    useNotificationStatus(feed) ?? {};
-
-  const group = aggregatedActivity.group;
-
-  return useMemo(
-    () =>
-      (lastReadAt &&
-        aggregatedActivity.updated_at.getTime() <= lastReadAt.getTime()) ||
-      (readActivities ?? []).includes(group),
-    [lastReadAt, aggregatedActivity.updated_at, readActivities, group],
-  );
+  return aggregatedActivity.is_read;
 };

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

@@ -1,30 +1,16 @@
-import { useMemo } from 'react';
-
-import { useFeedContext } from '../../contexts/StreamFeedContext';
-import { useNotificationStatus } from './useNotificationStatus';
 import type { Feed } from '../../../../feed';
 import type { AggregatedActivityResponse } from '../../../../gen/models';
 
+/**
+ * @deprecated use aggregatedActivity.is_seen instead
+ * @returns
+ */
 export const useIsAggregatedActivitySeen = ({
-  feed: feedFromProps,
+  feed: _,
   aggregatedActivity,
 }: {
   feed?: Feed;
   aggregatedActivity: AggregatedActivityResponse;
 }) => {
-  const feedFromContext = useFeedContext();
-  const feed = feedFromProps ?? feedFromContext;
-
-  const { seen_activities: seenActivities, last_seen_at: lastSeenAt } =
-    useNotificationStatus(feed) ?? {};
-
-  const group = aggregatedActivity.group;
-
-  return useMemo(
-    () =>
-      (lastSeenAt &&
-        aggregatedActivity.updated_at.getTime() < lastSeenAt.getTime()) ||
-      (seenActivities ?? []).includes(group),
-    [lastSeenAt, aggregatedActivity.updated_at, seenActivities, group],
-  );
+  return aggregatedActivity.is_seen;
 };

package/src/feed/activity-filter.ts

@@ -0,0 +1,44 @@
+import { itemMatchesFilter, resolveDotPathValue } from '@stream-io/filter';
+import type { ActivityResponse, GetOrCreateFeedRequest } from '../gen/models';
+
+/**
+ * Resolvers that map feed filter field names to activity properties.
+ * - activity_type: API filter key maps to activity.type
+ * - within_bounds: API filter key maps to activity.location (for bounds check)
+ */
+const activityResolvers = [
+  {
+    matchesField: (field: string) => field === 'activity_type',
+    resolve: (activity: ActivityResponse) => activity.type,
+  },
+  {
+    matchesField: (field: string) => field === 'within_bounds',
+    resolve: (activity: ActivityResponse) => activity.location,
+  },
+  {
+    matchesField: () => true,
+    resolve: (item: any, path: any) => resolveDotPathValue(item, path),
+  },
+] as const;
+
+/**
+ * Returns true if the activity matches the feed's getOrCreate filter (e.g. filter_tags, activity_type, within_bounds).
+ * Use this inside onNewActivity to only add activities that match the current feed filter.
+ *
+ * @param activity - The activity to check
+ * @param requestConfig - The last getOrCreate request config (contains the filter). If omitted or filter is empty, returns true.
+ * @returns true if the activity matches the filter or there is no filter
+ */
+export function activityFilter(
+  activity: ActivityResponse,
+  requestConfig?: GetOrCreateFeedRequest,
+): boolean {
+  const filter = requestConfig?.filter;
+  if (!filter || typeof filter !== 'object') {
+    return true;
+  }
+  return itemMatchesFilter(activity, filter, {
+    resolvers: [...activityResolvers],
+    arrayEqMode: 'contains',
+  });
+}

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

@@ -7,7 +7,13 @@ export function addActivitiesToState(
   newActivities: ActivityResponse[],
   activities: ActivityResponse[] | undefined,
   position: 'start' | 'end',
-  { fromWebSocket }: { fromWebSocket: boolean } = { fromWebSocket: false },
+  {
+    hasOwnFields,
+    backfillOwnFields,
+  }: { hasOwnFields: boolean; backfillOwnFields: boolean } = {
+    hasOwnFields: true,
+    backfillOwnFields: true,
+  },
 ) {
   if (activities === undefined) {
     return {
@@ -34,7 +40,10 @@ export function addActivitiesToState(
       ...activities,
       ...(position === 'end' ? newActivitiesDeduplicated : []),
     ];
-    this.newActivitiesAdded(newActivitiesDeduplicated, { fromWebSocket });
+    this.activitiesAddedOrUpdated(newActivitiesDeduplicated, {
+      hasOwnFields,
+      backfillOwnFields,
+    });
 
     result = { changed: true, activities: updatedActivities };
   }
@@ -46,17 +55,22 @@ export function handleActivityAdded(
   this: Feed,
   event: EventPayload<'feeds.activity.added'>,
 ) {
-  if (this.activityAddedEventFilter) {
-    if (!this.activityAddedEventFilter(event)) {
-      return;
-    }
+  const currentUser = this.client.state.getLatestValue().connected_user;
+  const decision = this.resolveNewActivityDecision(
+    event.activity,
+    currentUser,
+    false,
+  );
+  if (decision === 'ignore') {
+    return;
   }
+  const position = decision === 'add-to-end' ? 'end' : 'start';
   const currentActivities = this.currentState.activities;
   const result = addActivitiesToState.bind(this)(
     [event.activity],
     currentActivities,
-    this.currentState.addNewActivitiesTo,
-    { fromWebSocket: true },
+    position,
+    { hasOwnFields: false, backfillOwnFields: true },
   );
   if (result.changed) {
     const activity = event.activity;

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

@@ -3,7 +3,13 @@ import type {
   ActivityPinResponse,
   ActivityResponse,
 } from '../../../gen/models';
-import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+import type {
+  EventPayload,
+  PartializeAllBut,
+  UpdateStateResult,
+} from '../../../types-internal';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+import { eventTriggeredByConnectedUser } from '../../../utils/event-triggered-by-connected-user';
 
 export function removeActivityFromState(
   this: Feed,
@@ -45,10 +51,30 @@ export const removePinnedActivityFromState = (
   }
 };
 
+export type ActivityDeletedPayload = PartializeAllBut<
+  EventPayload<'feeds.activity.deleted'>,
+  'activity'
+>;
+
 export function handleActivityDeleted(
   this: Feed,
-  event: EventPayload<'feeds.activity.deleted'>,
+  event: ActivityDeletedPayload,
+  fromWs?: boolean,
 ) {
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(event, 'activity-deleted'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+        this,
+        event,
+      ),
+    })
+  ) {
+    return;
+  }
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities,

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

@@ -2,12 +2,16 @@ import { updateEntityInArray } from '../../../utils';
 import { isPin } from '../is-activity-pin';
 import type { Feed } from '../../feed';
 import type { EventPayload } from '../../../types-internal';
-import type { ActivityFeedbackEventPayload, ActivityPinResponse, ActivityResponse } from '../../../gen/models';
+import type {
+  ActivityFeedbackEventPayload,
+  ActivityPinResponse,
+  ActivityResponse,
+} from '../../../gen/models';
 
-const updateActivityFromFeedback = <
+export const updateActivityFromFeedback = <
   T extends ActivityResponse | ActivityPinResponse,
 >(
-  feedback: ActivityFeedbackEventPayload,
+  feedback: Pick<ActivityFeedbackEventPayload, 'activity_id' | 'value'>,
   activities: T[] | undefined,
 ) => {
   if (!activities) {
@@ -18,10 +22,16 @@ const updateActivityFromFeedback = <
   }
   return updateEntityInArray<T>({
     entities: activities,
-    matcher: (e) =>
-      isPin(e)
-        ? e.activity.id === feedback.activity_id
-        : e.id === feedback.activity_id,
+    matcher: (e) => {
+      const newHidden = feedback.value === 'true';
+      if (isPin(e)) {
+        return (
+          e.activity.id === feedback.activity_id &&
+          e.activity.hidden !== newHidden
+        );
+      }
+      return e.id === feedback.activity_id && e.hidden !== newHidden;
+    },
     updater: (e) => {
       if (isPin(e)) {
         return {

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

@@ -1,11 +1,34 @@
 import type { ActivityPinResponse } from '../../../gen/models';
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 import type { Feed } from '../../feed';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+import { eventTriggeredByConnectedUser } from '../../../utils/event-triggered-by-connected-user';
+
+export type ActivityPinnedPayload = PartializeAllBut<
+  EventPayload<'feeds.activity.pinned'>,
+  'pinned_activity'
+>;
 
 export function handleActivityPinned(
   this: Feed,
-  event: EventPayload<'feeds.activity.pinned'>,
+  event: ActivityPinnedPayload,
+  fromWs?: boolean,
 ) {
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(event, 'activity-pinned'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+        this,
+        event,
+      ),
+    })
+  ) {
+    return;
+  }
+
   this.state.next((currentState) => {
     const newState = {
       ...currentState,
@@ -17,7 +40,6 @@ export function handleActivityPinned(
     const pinnedActivity: ActivityPinResponse = {
       ...event.pinned_activity,
       user: event.user!,
-      feed: event.fid,
       updated_at: new Date(),
     };
 

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

@@ -1,10 +1,33 @@
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 import type { Feed, FeedState } from '../../feed';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+import { eventTriggeredByConnectedUser } from '../../../utils/event-triggered-by-connected-user';
+
+export type ActivityUnpinnedPayload = PartializeAllBut<
+  EventPayload<'feeds.activity.unpinned'>,
+  'pinned_activity'
+>;
 
 export function handleActivityUnpinned(
   this: Feed,
-  event: EventPayload<'feeds.activity.unpinned'>,
+  event: ActivityUnpinnedPayload,
+  fromWs?: boolean,
 ) {
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(event, 'activity-unpinned'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+        this,
+        event,
+      ),
+    })
+  ) {
+    return;
+  }
+
   this.state.next((currentState) => {
     let newState: FeedState | undefined;
 

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

@@ -90,7 +90,11 @@ export function handleActivityUpdated(
   ];
 
   if (result1?.changed || result2.changed) {
-    this.client.hydratePollCache([payload.activity]);
+    this.activitiesAddedOrUpdated([payload.activity], {
+      hasOwnFields:
+        payload.activity.current_feed?.own_capabilities !== undefined,
+      backfillOwnFields: false,
+    });
 
     this.state.partialNext({
       activities: result1?.changed ? result1.entities : currentActivities,

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

@@ -5,4 +5,6 @@ export * from './handle-activity-updated';
 export * from './handle-activity-reaction-added';
 export * from './handle-activity-reaction-deleted';
 export * from './handle-activity-reaction-updated';
-export * from './handle-activity-marked';
+export * from './handle-activity-pinned';
+export * from './handle-activity-unpinned';
+export * from './handle-activity-feedback';

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

@@ -6,7 +6,7 @@ import { updateActivity } from './activity-updater';
 export const addAggregatedActivitiesToState = (
   newAggregatedActivities: AggregatedActivityResponse[],
   aggregatedActivities: AggregatedActivityResponse[] | undefined,
-  position: 'start' | 'end' | 'replace',
+  position: 'start' | 'end' | 'replace-then-end' | 'replace-then-start',
 ) => {
   let result: UpdateStateResult<{
     aggregated_activities: AggregatedActivityResponse[];
@@ -58,11 +58,20 @@ export const addAggregatedActivitiesToState = (
           (a) => a.group,
         );
         break;
-      case 'replace':
+      case 'replace-then-end':
         result.aggregated_activities = replaceUniqueArrayMerge(
           aggregatedActivities ?? [],
           newAggregatedActivities,
           (a) => a.group,
+          'end',
+        );
+        break;
+      case 'replace-then-start':
+        result.aggregated_activities = replaceUniqueArrayMerge(
+          aggregatedActivities ?? [],
+          newAggregatedActivities,
+          (a) => a.group,
+          'start',
         );
         break;
     }

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

@@ -2,10 +2,15 @@ import type { Feed } from '../../../feed';
 import type {
   ActivityPinResponse,
   ActivityResponse,
-  BookmarkAddedEvent,
 } from '../../../gen/models';
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 import { updateEntityInArray } from '../../../utils';
+import { isSameBookmark } from './handle-bookmark-deleted';
+
+export type BookmarkAddedPayload = PartializeAllBut<
+  EventPayload<'feeds.bookmark.added'>,
+  'bookmark'
+>;
 
 const sharedUpdateActivity = ({
   currentActivity,
@@ -13,7 +18,7 @@ const sharedUpdateActivity = ({
   eventBelongsToCurrentUser,
 }: {
   currentActivity: ActivityResponse;
-  event: BookmarkAddedEvent;
+  event: BookmarkAddedPayload;
   eventBelongsToCurrentUser: boolean;
 }): ActivityResponse => {
   let newOwnBookmarks = currentActivity.own_bookmarks;
@@ -30,13 +35,16 @@ const sharedUpdateActivity = ({
 };
 
 export const addBookmarkToActivities = (
-  event: BookmarkAddedEvent,
+  event: BookmarkAddedPayload,
   activities: ActivityResponse[] | undefined,
   eventBelongsToCurrentUser: boolean,
 ) =>
   updateEntityInArray({
     entities: activities,
-    matcher: (activity) => activity.id === event.bookmark.activity.id,
+    matcher: (activity) =>
+      activity.id === event.bookmark.activity.id &&
+      (!eventBelongsToCurrentUser ||
+        !activity.own_bookmarks.some((b) => isSameBookmark(b, event.bookmark))),
     updater: (matchedActivity) =>
       sharedUpdateActivity({
         currentActivity: matchedActivity,
@@ -46,14 +54,18 @@ export const addBookmarkToActivities = (
   });
 
 export const addBookmarkToPinnedActivities = (
-  event: BookmarkAddedEvent,
+  event: BookmarkAddedPayload,
   pinnedActivities: ActivityPinResponse[] | undefined,
   eventBelongsToCurrentUser: boolean,
 ) =>
   updateEntityInArray({
     entities: pinnedActivities,
     matcher: (pinnedActivity) =>
-      pinnedActivity.activity.id === event.bookmark.activity.id,
+      pinnedActivity.activity.id === event.bookmark.activity.id &&
+      (!eventBelongsToCurrentUser ||
+        !pinnedActivity.activity.own_bookmarks.some((b) =>
+          isSameBookmark(b, event.bookmark),
+        )),
     updater: (matchedPinnedActivity) => {
       const newActivity = sharedUpdateActivity({
         currentActivity: matchedPinnedActivity.activity,
@@ -72,10 +84,7 @@ export const addBookmarkToPinnedActivities = (
     },
   });
 
-export function handleBookmarkAdded(
-  this: Feed,
-  event: EventPayload<'feeds.bookmark.added'>,
-) {
+export function handleBookmarkAdded(this: Feed, event: BookmarkAddedPayload) {
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities,

package/src/feed/event-handlers/bookmark/handle-bookmark-deleted.ts

@@ -2,14 +2,16 @@ import type { Feed } from '../../../feed';
 import type {
   ActivityPinResponse,
   ActivityResponse,
-  BookmarkDeletedEvent,
   BookmarkResponse,
 } from '../../../gen/models';
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 import { updateEntityInArray } from '../../../utils';
 
-// Helper function to check if two bookmarks are the same
-// A bookmark is identified by activity_id + folder_id + user_id
+export type BookmarkDeletedPayload = PartializeAllBut<
+  EventPayload<'feeds.bookmark.deleted'>,
+  'bookmark'
+>;
+
 export const isSameBookmark = (
   bookmark1: BookmarkResponse,
   bookmark2: BookmarkResponse,
@@ -17,7 +19,8 @@ export const isSameBookmark = (
   return (
     bookmark1.user.id === bookmark2.user.id &&
     bookmark1.activity.id === bookmark2.activity.id &&
-    bookmark1.folder?.id === bookmark2.folder?.id
+    bookmark1.folder?.id === bookmark2.folder?.id &&
+    bookmark1.updated_at.getTime() === bookmark2.updated_at.getTime()
   );
 };
 
@@ -27,7 +30,7 @@ const sharedUpdateActivity = ({
   eventBelongsToCurrentUser,
 }: {
   currentActivity: ActivityResponse;
-  event: BookmarkDeletedEvent;
+  event: BookmarkDeletedPayload;
   eventBelongsToCurrentUser: boolean;
 }): ActivityResponse => {
   let newOwnBookmarks = currentActivity.own_bookmarks;
@@ -46,13 +49,16 @@ const sharedUpdateActivity = ({
 };
 
 export const removeBookmarkFromActivities = (
-  event: BookmarkDeletedEvent,
+  event: BookmarkDeletedPayload,
   activities: ActivityResponse[] | undefined,
   eventBelongsToCurrentUser: boolean,
 ) =>
   updateEntityInArray({
     entities: activities,
-    matcher: (activity) => activity.id === event.bookmark.activity.id,
+    matcher: (activity) =>
+      activity.id === event.bookmark.activity.id &&
+      (!eventBelongsToCurrentUser ||
+        activity.own_bookmarks.some((b) => isSameBookmark(b, event.bookmark))),
     updater: (matchedActivity) =>
       sharedUpdateActivity({
         currentActivity: matchedActivity,
@@ -62,14 +68,18 @@ export const removeBookmarkFromActivities = (
   });
 
 export const removeBookmarkFromPinnedActivities = (
-  event: BookmarkDeletedEvent,
+  event: BookmarkDeletedPayload,
   pinnedActivities: ActivityPinResponse[] | undefined,
   eventBelongsToCurrentUser: boolean,
 ) =>
   updateEntityInArray({
     entities: pinnedActivities,
     matcher: (pinnedActivity) =>
-      pinnedActivity.activity.id === event.bookmark.activity.id,
+      pinnedActivity.activity.id === event.bookmark.activity.id &&
+      (!eventBelongsToCurrentUser ||
+        pinnedActivity.activity.own_bookmarks.some((b) =>
+          isSameBookmark(b, event.bookmark),
+        )),
     updater: (matchedPinnedActivity) => {
       const newActivity = sharedUpdateActivity({
         currentActivity: matchedPinnedActivity.activity,
@@ -90,7 +100,7 @@ export const removeBookmarkFromPinnedActivities = (
 
 export function handleBookmarkDeleted(
   this: Feed,
-  event: EventPayload<'feeds.bookmark.deleted'>,
+  event: BookmarkDeletedPayload,
 ) {
   const {
     activities: currentActivities,