@stream-io/feeds-client 0.1.10 → 0.1.11

package/index.ts

@@ -1,5 +1,5 @@
-export * from './src/FeedsClient';
-export * from './src/Feed';
+export * from './src/feeds-client';
+export * from './src/feed/feed';
 export * from './src/gen/models';
 export * from './src/types';
 export * from './src/common/types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/feeds-client",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "packageManager": "yarn@3.2.4",
   "main": "./dist/index.node.js",
   "exports": {
@@ -67,6 +67,7 @@
     "@types/react": "^19.1.8",
     "@vitest/coverage-v8": "3.2.4",
     "dotenv": "^16.4.5",
+    "human-id": "^4.1.1",
     "react": "19.0.0",
     "rimraf": "^6.0.1",
     "rollup": "^4.24.0",

package/src/common/ActivitySearchSource.ts

@@ -1,7 +1,7 @@
 import { BaseSearchSource } from './BaseSearchSource';
 import type { SearchSourceOptions } from './BaseSearchSource';
 
-import { FeedsClient } from '../FeedsClient';
+import { FeedsClient } from '../feeds-client';
 import { ActivityResponse } from '../gen/models';
 
 export class ActivitySearchSource extends BaseSearchSource<ActivityResponse> {

package/src/common/FeedSearchSource.ts

@@ -1,8 +1,8 @@
 import { BaseSearchSource } from './BaseSearchSource';
 import type { SearchSourceOptions } from './BaseSearchSource';
 
-import { FeedsClient } from '../FeedsClient';
-import { Feed } from '../Feed';
+import { FeedsClient } from '../feeds-client';
+import { Feed } from '../feed';
 
 export type FeedSearchSourceOptions = SearchSourceOptions & {
   groupId?: string;

package/src/common/Poll.ts

@@ -1,5 +1,5 @@
 import { StateStore } from './StateStore';
-import type { FeedsClient } from '../FeedsClient';
+import type { FeedsClient } from '../feeds-client';
 import type {
   PollVote,
   QueryPollVotesRequest,

package/src/common/UserSearchSource.ts

@@ -1,7 +1,7 @@
 import { BaseSearchSource } from './BaseSearchSource';
 import type { SearchSourceOptions } from './BaseSearchSource';
 
-import { FeedsClient } from '../FeedsClient';
+import { FeedsClient } from '../feeds-client';
 import { UserResponse } from '../gen/models';
 
 export class UserSearchSource extends BaseSearchSource<UserResponse> {

package/src/{state-updates → feed/event-handlers/activity}/activity-reaction-utils.test.ts

@@ -4,13 +4,13 @@ import {
   ActivityReactionDeletedEvent,
   ActivityResponse,
   FeedsReactionResponse,
-} from '../gen/models';
+} from '../../../gen/models';
 import {
   addReactionToActivity,
   removeReactionFromActivity,
   addReactionToActivities,
   removeReactionFromActivities,
-} from './activity-reaction-utils';
+} from './';
 
 const createMockActivity = (id: string): ActivityResponse => ({
   id,
@@ -109,6 +109,7 @@ describe('activity-reaction-utils', () => {
           count: 1,
           first_reaction_at: reaction.created_at,
           last_reaction_at: reaction.created_at,
+          sum_scores: 0,
         },
       };
 
@@ -123,6 +124,7 @@ describe('activity-reaction-utils', () => {
         count: 1,
         first_reaction_at: reaction.created_at,
         last_reaction_at: reaction.created_at,
+        sum_scores: 0,
       });
     });
 
@@ -136,6 +138,7 @@ describe('activity-reaction-utils', () => {
           count: 1,
           first_reaction_at: reaction.created_at,
           last_reaction_at: reaction.created_at,
+          sum_scores: 0,
         },
       };
       const event = createMockAddedEvent(reaction, eventActivity);
@@ -150,6 +153,7 @@ describe('activity-reaction-utils', () => {
         count: 1,
         first_reaction_at: reaction.created_at,
         last_reaction_at: reaction.created_at,
+        sum_scores: 0,
       });
     });
   });
@@ -165,6 +169,7 @@ describe('activity-reaction-utils', () => {
           count: 1,
           first_reaction_at: reaction.created_at,
           last_reaction_at: reaction.created_at,
+          sum_scores: 0,
         },
       };
       const event = createMockAddedEvent(reaction, eventActivity);
@@ -196,6 +201,7 @@ describe('activity-reaction-utils', () => {
           count: 1,
           first_reaction_at: reaction.created_at,
           last_reaction_at: reaction.created_at,
+          sum_scores: 0,
         },
       };
       const event = createMockAddedEvent(reaction, eventActivity);
@@ -230,6 +236,7 @@ describe('activity-reaction-utils', () => {
           count: 1,
           first_reaction_at: reaction.created_at,
           last_reaction_at: reaction.created_at,
+          sum_scores: 0,
         },
       };
       const event = createMockAddedEvent(reaction, eventActivity);
@@ -253,6 +260,7 @@ describe('activity-reaction-utils', () => {
           count: 1,
           first_reaction_at: reaction.created_at,
           last_reaction_at: reaction.created_at,
+          sum_scores: 0,
         },
       };
       const event = createMockAddedEvent(reaction, eventActivity);
@@ -274,6 +282,7 @@ describe('activity-reaction-utils', () => {
           count: 1,
           first_reaction_at: reaction.created_at,
           last_reaction_at: reaction.created_at,
+          sum_scores: 0,
         },
       };
       const event = createMockAddedEvent(reaction, eventActivity);
@@ -296,6 +305,7 @@ describe('activity-reaction-utils', () => {
           count: 1,
           first_reaction_at: reaction.created_at,
           last_reaction_at: reaction.created_at,
+          sum_scores: 0,
         },
       };
       const event = createMockAddedEvent(reaction, eventActivity);

package/src/{state-updates → feed/event-handlers/activity}/activity-utils.test.ts

@@ -1,10 +1,10 @@
 import { describe, it, expect } from 'vitest';
-import { ActivityResponse, FeedsReactionResponse } from '../gen/models';
+import { ActivityResponse, FeedsReactionResponse } from '../../../gen/models';
 import {
   addActivitiesToState,
   updateActivityInState,
   removeActivityFromState,
-} from './activity-utils';
+} from './';
 
 const createMockActivity = (id: string, text?: string): ActivityResponse =>
   ({
@@ -181,6 +181,7 @@ describe('activity-utils', () => {
       ];
       originalActivity.reaction_groups = {
         like: {
+          sum_scores: 0,
           count: 1,
           first_reaction_at: new Date(),
           last_reaction_at: new Date(),

package/src/{state-updates/activity-utils.ts → feed/event-handlers/activity/handle-activity-added.ts}

@@ -1,5 +1,6 @@
-import { ActivityResponse } from '../gen/models';
-import { UpdateStateResult } from '../types-internal';
+import { Feed } from '../../../feed';
+import { ActivityResponse } from '../../../gen/models';
+import { EventPayload, UpdateStateResult } from '../../../types-internal';
 
 export const addActivitiesToState = (
   newActivities: ActivityResponse[],
@@ -42,39 +43,18 @@ export const addActivitiesToState = (
   return result;
 };
 
-export const updateActivityInState = (
-  updatedActivityResponse: ActivityResponse,
-  activities: ActivityResponse[],
-) => {
-  const index = activities.findIndex(
-    (a) => a.id === updatedActivityResponse.id,
+export function handleActivityAdded(
+  this: Feed,
+  event: EventPayload<'feeds.activity.added'>,
+) {
+  const currentActivities = this.currentState.activities;
+  const result = addActivitiesToState(
+    [event.activity],
+    currentActivities,
+    'start',
   );
-  if (index !== -1) {
-    const newActivities = [...activities];
-    const activity = activities[index];
-    newActivities[index] = {
-      ...updatedActivityResponse,
-      own_reactions: activity.own_reactions,
-      own_bookmarks: activity.own_bookmarks,
-      latest_reactions: activity.latest_reactions,
-      reaction_groups: activity.reaction_groups,
-    };
-    return { changed: true, activities: newActivities };
-  } else {
-    return { changed: false, activities };
+  if (result.changed) {
+    this.client.hydratePollCache([event.activity]);
+    this.state.partialNext({ activities: result.activities });
   }
-};
-
-export const removeActivityFromState = (
-  activityResponse: ActivityResponse,
-  activities: ActivityResponse[],
-) => {
-  const index = activities.findIndex((a) => a.id === activityResponse.id);
-  if (index !== -1) {
-    const newActivities = [...activities];
-    newActivities.splice(index, 1);
-    return { changed: true, activities: newActivities };
-  } else {
-    return { changed: false, activities };
-  }
-};
+}

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

@@ -0,0 +1,30 @@
+import type { Feed } from '../../../feed';
+import type { ActivityResponse } from '../../../gen/models';
+import type { EventPayload } from '../../../types-internal';
+
+export const removeActivityFromState = (
+  activityResponse: ActivityResponse,
+  activities: ActivityResponse[],
+) => {
+  const index = activities.findIndex((a) => a.id === activityResponse.id);
+  if (index !== -1) {
+    const newActivities = [...activities];
+    newActivities.splice(index, 1);
+    return { changed: true, activities: newActivities };
+  } else {
+    return { changed: false, activities };
+  }
+};
+
+export function handleActivityDeleted(
+  this: Feed,
+  event: EventPayload<'feeds.activity.deleted'>,
+) {
+  const currentActivities = this.currentState.activities;
+  if (currentActivities) {
+    const result = removeActivityFromState(event.activity, currentActivities);
+    if (result.changed) {
+      this.state.partialNext({ activities: result.activities });
+    }
+  }
+}

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

@@ -0,0 +1,67 @@
+import type { Feed } from '../../../feed';
+import type {
+  ActivityReactionAddedEvent,
+  ActivityResponse,
+} from '../../../gen/models';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+
+import { updateActivityInState } from './handle-activity-updated';
+
+export const addReactionToActivity = (
+  event: ActivityReactionAddedEvent,
+  activity: ActivityResponse,
+  isCurrentUser: boolean,
+): UpdateStateResult<ActivityResponse> => {
+  // Update own_reactions if the reaction is from the current user
+  const ownReactions = [...(activity.own_reactions || [])];
+  if (isCurrentUser) {
+    ownReactions.push(event.reaction);
+  }
+
+  return {
+    ...activity,
+    own_reactions: ownReactions,
+    latest_reactions: event.activity.latest_reactions,
+    reaction_groups: event.activity.reaction_groups,
+    changed: true,
+  };
+};
+
+export const addReactionToActivities = (
+  event: ActivityReactionAddedEvent,
+  activities: ActivityResponse[] | undefined,
+  isCurrentUser: boolean,
+): UpdateStateResult<{ activities: ActivityResponse[] }> => {
+  if (!activities) {
+    return { changed: false, activities: [] };
+  }
+
+  const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
+  if (activityIndex === -1) {
+    return { changed: false, activities };
+  }
+
+  const activity = activities[activityIndex];
+  const updatedActivity = addReactionToActivity(event, activity, isCurrentUser);
+  return updateActivityInState(updatedActivity, activities, true);
+};
+
+export function handleActivityReactionAdded(
+  this: Feed,
+  event: EventPayload<'feeds.activity.reaction.added'>,
+) {
+  const currentActivities = this.currentState.activities;
+  const connectedUser = this.client.state.getLatestValue().connected_user;
+  const isCurrentUser = Boolean(
+    connectedUser && event.reaction.user.id === connectedUser.id,
+  );
+
+  const result = addReactionToActivities(
+    event,
+    currentActivities,
+    isCurrentUser,
+  );
+  if (result.changed) {
+    this.state.partialNext({ activities: result.activities });
+  }
+}

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

@@ -0,0 +1,75 @@
+import type { Feed } from '../../../feed';
+import type {
+  ActivityReactionDeletedEvent,
+  ActivityResponse,
+} from '../../../gen/models';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+
+import { updateActivityInState } from './handle-activity-updated';
+export const removeReactionFromActivity = (
+  event: ActivityReactionDeletedEvent,
+  activity: ActivityResponse,
+  isCurrentUser: boolean,
+): UpdateStateResult<ActivityResponse> => {
+  // Update own_reactions if the reaction is from the current user
+  const ownReactions = isCurrentUser
+    ? (activity.own_reactions || []).filter(
+        (r) =>
+          !(
+            r.type === event.reaction.type &&
+            r.user.id === event.reaction.user.id
+          ),
+      )
+    : activity.own_reactions;
+
+  return {
+    ...activity,
+    own_reactions: ownReactions,
+    latest_reactions: event.activity.latest_reactions,
+    reaction_groups: event.activity.reaction_groups,
+    changed: true,
+  };
+};
+
+export const removeReactionFromActivities = (
+  event: ActivityReactionDeletedEvent,
+  activities: ActivityResponse[] | undefined,
+  isCurrentUser: boolean,
+): UpdateStateResult<{ activities: ActivityResponse[] }> => {
+  if (!activities) {
+    return { changed: false, activities: [] };
+  }
+
+  const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
+  if (activityIndex === -1) {
+    return { changed: false, activities };
+  }
+
+  const activity = activities[activityIndex];
+  const updatedActivity = removeReactionFromActivity(
+    event,
+    activity,
+    isCurrentUser,
+  );
+  return updateActivityInState(updatedActivity, activities, true);
+};
+
+export function handleActivityReactionDeleted(
+  this: Feed,
+  event: EventPayload<'feeds.activity.reaction.deleted'>,
+) {
+  const currentActivities = this.currentState.activities;
+  const connectedUser = this.client.state.getLatestValue().connected_user;
+  const isCurrentUser = Boolean(
+    connectedUser && event.reaction.user.id === connectedUser.id,
+  );
+
+  const result = removeReactionFromActivities(
+    event,
+    currentActivities,
+    isCurrentUser,
+  );
+  if (result.changed) {
+    this.state.partialNext({ activities: result.activities });
+  }
+}

package/src/feed/event-handlers/activity/handle-activity-removed-from-feed.ts

@@ -0,0 +1,16 @@
+import { Feed } from '../../../feed';
+import { EventPayload } from '../../../types-internal';
+import { removeActivityFromState } from './handle-activity-deleted';
+
+export function handleActivityRemovedFromFeed(
+  this: Feed,
+  event: EventPayload<'feeds.activity.removed_from_feed'>,
+) {
+  const currentActivities = this.currentState.activities;
+  if (currentActivities) {
+    const result = removeActivityFromState(event.activity, currentActivities);
+    if (result.changed) {
+      this.state.partialNext({ activities: result.activities });
+    }
+  }
+}

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

@@ -0,0 +1,47 @@
+import { Feed } from '../../../feed';
+import { ActivityResponse } from '../../../gen/models';
+import { EventPayload } from '../../../types-internal';
+
+export const updateActivityInState = (
+  updatedActivityResponse: ActivityResponse,
+  activities: ActivityResponse[],
+  replaceCompletely: boolean = false,
+) => {
+  const index = activities.findIndex(
+    (a) => a.id === updatedActivityResponse.id,
+  );
+  if (index !== -1) {
+    const newActivities = [...activities];
+    const activity = activities[index];
+
+    if (replaceCompletely) {
+      newActivities[index] = updatedActivityResponse;
+    } else {
+      newActivities[index] = {
+        ...updatedActivityResponse,
+        own_reactions: activity.own_reactions,
+        own_bookmarks: activity.own_bookmarks,
+        latest_reactions: activity.latest_reactions,
+        reaction_groups: activity.reaction_groups,
+      };
+    }
+
+    return { changed: true, activities: newActivities };
+  } else {
+    return { changed: false, activities };
+  }
+};
+
+export function handleActivityUpdated(
+  this: Feed,
+  event: EventPayload<'feeds.activity.updated'>,
+) {
+  const currentActivities = this.currentState.activities;
+  if (currentActivities) {
+    const result = updateActivityInState(event.activity, currentActivities);
+    if (result.changed) {
+      this.client.hydratePollCache([event.activity]);
+      this.state.partialNext({ activities: result.activities });
+    }
+  }
+}

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

@@ -0,0 +1,6 @@
+export * from './handle-activity-added';
+export * from './handle-activity-deleted';
+export * from './handle-activity-removed-from-feed';
+export * from './handle-activity-updated';
+export * from './handle-activity-reaction-added';
+export * from './handle-activity-reaction-deleted';

package/src/{state-updates → feed/event-handlers/bookmark}/bookmark-utils.test.ts

@@ -6,7 +6,7 @@ import {
   ActivityResponse,
   BookmarkResponse,
   UserResponse,
-} from '../gen/models';
+} from '../../../gen/models';
 import {
   addBookmarkToActivity,
   removeBookmarkFromActivity,
@@ -14,7 +14,7 @@ import {
   addBookmarkToActivities,
   removeBookmarkFromActivities,
   updateBookmarkInActivities,
-} from './bookmark-utils';
+} from './';
 
 const createMockUser = (id: string): UserResponse => ({
   id,

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

@@ -0,0 +1,63 @@
+import type { Feed } from '../../../feed';
+import type { ActivityResponse, BookmarkAddedEvent } from '../../../gen/models';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+
+import { updateActivityInState } from '../activity';
+
+export const addBookmarkToActivity = (
+  event: BookmarkAddedEvent,
+  activity: ActivityResponse,
+  isCurrentUser: boolean,
+): UpdateStateResult<ActivityResponse> => {
+  // Update own_bookmarks if the bookmark is from the current user
+  const ownBookmarks = [...(activity.own_bookmarks || [])];
+  if (isCurrentUser) {
+    ownBookmarks.push(event.bookmark);
+  }
+
+  return {
+    ...activity,
+    own_bookmarks: ownBookmarks,
+    changed: true,
+  };
+};
+
+export const addBookmarkToActivities = (
+  event: BookmarkAddedEvent,
+  activities: ActivityResponse[] | undefined,
+  isCurrentUser: boolean,
+): UpdateStateResult<{ activities: ActivityResponse[] }> => {
+  if (!activities) {
+    return { changed: false, activities: [] };
+  }
+
+  const activityIndex = activities.findIndex(
+    (a) => a.id === event.bookmark.activity.id,
+  );
+  if (activityIndex === -1) {
+    return { changed: false, activities };
+  }
+
+  const activity = activities[activityIndex];
+  const updatedActivity = addBookmarkToActivity(event, activity, isCurrentUser);
+  return updateActivityInState(updatedActivity, activities, true);
+};
+
+export function handleBookmarkAdded(
+  this: Feed,
+  event: EventPayload<'feeds.bookmark.added'>,
+) {
+  const currentActivities = this.currentState.activities;
+  const { connected_user: connectedUser } = this.client.state.getLatestValue();
+  const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
+
+  const result = addBookmarkToActivities(
+    event,
+    currentActivities,
+    isCurrentUser,
+  );
+
+  if (result.changed) {
+    this.state.partialNext({ activities: result.activities });
+  }
+}

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

@@ -0,0 +1,84 @@
+import type { Feed } from '../../../feed';
+import type {
+  ActivityResponse,
+  BookmarkDeletedEvent,
+  BookmarkResponse,
+} from '../../../gen/models';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+
+import { updateActivityInState } from '../activity';
+
+// Helper function to check if two bookmarks are the same
+// A bookmark is identified by activity_id + folder_id + user_id
+export const isSameBookmark = (
+  bookmark1: BookmarkResponse,
+  bookmark2: BookmarkResponse,
+): boolean => {
+  return (
+    bookmark1.user.id === bookmark2.user.id &&
+    bookmark1.activity.id === bookmark2.activity.id &&
+    bookmark1.folder?.id === bookmark2.folder?.id
+  );
+};
+
+export const removeBookmarkFromActivities = (
+  event: BookmarkDeletedEvent,
+  activities: ActivityResponse[] | undefined,
+  isCurrentUser: boolean,
+): UpdateStateResult<{ activities: ActivityResponse[] }> => {
+  if (!activities) {
+    return { changed: false, activities: [] };
+  }
+
+  const activityIndex = activities.findIndex(
+    (a) => a.id === event.bookmark.activity.id,
+  );
+  if (activityIndex === -1) {
+    return { changed: false, activities };
+  }
+
+  const activity = activities[activityIndex];
+  const updatedActivity = removeBookmarkFromActivity(
+    event,
+    activity,
+    isCurrentUser,
+  );
+  return updateActivityInState(updatedActivity, activities, true);
+};
+
+export const removeBookmarkFromActivity = (
+  event: BookmarkDeletedEvent,
+  activity: ActivityResponse,
+  isCurrentUser: boolean,
+): UpdateStateResult<ActivityResponse> => {
+  // Update own_bookmarks if the bookmark is from the current user
+  const ownBookmarks = isCurrentUser
+    ? (activity.own_bookmarks || []).filter(
+        (bookmark) => !isSameBookmark(bookmark, event.bookmark),
+      )
+    : activity.own_bookmarks;
+
+  return {
+    ...activity,
+    own_bookmarks: ownBookmarks,
+    changed: true,
+  };
+};
+
+export function handleBookmarkDeleted(
+  this: Feed,
+  event: EventPayload<'feeds.bookmark.deleted'>,
+) {
+  const currentActivities = this.currentState.activities;
+  const { connected_user: connectedUser } = this.client.state.getLatestValue();
+  const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
+
+  const result = removeBookmarkFromActivities(
+    event,
+    currentActivities,
+    isCurrentUser,
+  );
+  if (result.changed) {
+    this.state.partialNext({ activities: result.activities });
+  }
+}