@stream-io/feeds-client 0.2.1 → 0.2.3

package/src/feed/event-handlers/feed-member/handle-feed-member-updated.test.ts

@@ -0,0 +1,84 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleFeedMemberUpdated } from './handle-feed-member-updated';
+import {
+  generateFeedResponse,
+  generateFeedMemberUpdatedEvent,
+  generateFeedMemberResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleFeedMemberUpdated.name, () => {
+  let feed: Feed;
+  let client: FeedsClient;
+  let currentUserId: string;
+
+  beforeEach(() => {
+    client = new FeedsClient('mock-api-key');
+    currentUserId = getHumanId();
+    client.state.partialNext({
+      connected_user: generateOwnUser({ id: currentUserId }),
+    });
+    const feedResponse = generateFeedResponse({
+      id: 'main',
+      group_id: 'user',
+      created_by: { id: currentUserId },
+    });
+    feed = new Feed(
+      client,
+      feedResponse.group_id,
+      feedResponse.id,
+      feedResponse,
+    );
+  });
+
+  it('updates an existing member in members array', () => {
+    const member1 = generateFeedMemberResponse();
+    const member2 = generateFeedMemberResponse();
+    feed.state.partialNext({ members: [member1, member2] });
+
+    const event = generateFeedMemberUpdatedEvent({
+      member: { user: { id: member1.user.id }, role: 'admin' },
+    });
+
+    handleFeedMemberUpdated.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.members).toHaveLength(2);
+    expect(stateAfter.members?.[0]).toBe(event.member);
+    expect(stateAfter.members?.[1]).toBe(member2);
+  });
+
+  it('does not modify members when target is not present', () => {
+    const existingMember = generateFeedMemberResponse();
+    feed.state.partialNext({ members: [existingMember] });
+
+    const event = generateFeedMemberUpdatedEvent();
+
+    const stateBefore = feed.currentState;
+    handleFeedMemberUpdated.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+
+  it('sets own_membership when the updated member is the connected user', () => {
+    const event = generateFeedMemberUpdatedEvent({
+      member: {
+        user: { id: currentUserId },
+        role: 'owner',
+        status: 'member',
+      },
+    });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.own_membership).toBeUndefined();
+
+    handleFeedMemberUpdated.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.own_membership).toBe(event.member);
+  });
+});

package/src/feed/event-handlers/follow/handle-follow-created.test.ts

@@ -78,10 +78,10 @@ describe('handle-follow-created', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.following).toHaveLength(1);
-      expect(result.data.following?.[0]).toEqual(follow);
+      expect(result.data.following?.[0]).toBe(follow);
       expect(result.data).toMatchObject(follow.source_feed);
       expect(result.data.own_follows).toBeUndefined();
-      expect(result.data.following_count).toEqual(1);
+      expect(result.data.following_count).toBe(1);
     });
 
     it('should handle when someone follows this feed', () => {
@@ -120,10 +120,10 @@ describe('handle-follow-created', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.followers).toHaveLength(1);
-      expect(result.data.followers?.[0]).toEqual(follow);
+      expect(result.data.followers?.[0]).toBe(follow);
       expect(result.data).toMatchObject(follow.target_feed);
       expect(result.data.own_follows).toBeUndefined();
-      expect(result.data.follower_count).toEqual(1);
+      expect(result.data.follower_count).toBe(1);
     });
 
     it('should add to own_follows when connected user is the source', () => {
@@ -161,7 +161,7 @@ describe('handle-follow-created', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.own_follows).toHaveLength(1);
-      expect(result.data.own_follows?.[0]).toEqual(follow);
+      expect(result.data.own_follows?.[0]).toBe(follow);
     });
 
     it('should not update followers/following when they are undefined', () => {
@@ -243,8 +243,8 @@ describe('handle-follow-created', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.followers).toHaveLength(2);
-      expect(result.data.followers?.[0]).toEqual(follow);
-      expect(result.data.followers?.[1]).toEqual(existingFollow);
+      expect(result.data.followers?.[0]).toBe(follow);
+      expect(result.data.followers?.[1]).toBe(existingFollow);
     });
   });
 });

package/src/feed/event-handlers/follow/handle-follow-deleted.test.ts

@@ -95,7 +95,7 @@ describe('handle-follow-deleted', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.followers).toHaveLength(0);
-      expect(result.data.own_follows).toEqual(currentState.own_follows);
+      expect(result.data.own_follows).toBe(currentState.own_follows);
       expect(result.data).toMatchObject(follow.target_feed);
     });
 
@@ -262,7 +262,7 @@ describe('handle-follow-deleted', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.following).toHaveLength(1);
-      expect(result.data.following?.[0]).toEqual(followToKeep);
+      expect(result.data.following?.[0]).toBe(followToKeep);
     });
   });
 });

package/src/feed/event-handlers/follow/handle-follow-updated.test.ts

@@ -148,7 +148,7 @@ describe(handleFollowUpdated.name, () => {
 
       // State should not change
       const stateAfter = feed.currentState;
-      expect(stateAfter).toEqual(stateBefore);
+      expect(stateAfter).toBe(stateBefore);
     });
 
     it('allows update again after clearing stateUpdateQueue', () => {

package/src/feed/event-handlers/notification-feed/handle-notification-feed-updated.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect } from 'vitest';
+import {
+  NotificationFeedUpdatedEvent,
+  NotificationStatusResponse,
+  AggregatedActivityResponse,
+} from '../../../gen/models';
+import { updateNotificationFeedFromEvent } from './handle-notification-feed-updated';
+
+const createMockNotificationFeedUpdatedEvent = (
+  overrides: Partial<NotificationFeedUpdatedEvent> = {},
+): NotificationFeedUpdatedEvent => ({
+  created_at: new Date(),
+  fid: 'user:notification',
+  custom: {},
+  type: 'feeds.notification_feed.updated',
+  ...overrides,
+});
+
+const createMockNotificationStatus = (
+  overrides: Partial<NotificationStatusResponse> = {},
+): NotificationStatusResponse => ({
+  unread: 0,
+  unseen: 0,
+  ...overrides,
+});
+
+const createMockAggregatedActivity = (
+  overrides: Partial<AggregatedActivityResponse> = {},
+): AggregatedActivityResponse => ({
+  activity_count: 1,
+  created_at: new Date(),
+  group: 'test-group',
+  score: 1,
+  updated_at: new Date(),
+  user_count: 1,
+  activities: [],
+  ...overrides,
+});
+
+describe('notification-feed-utils', () => {
+  describe('updateNotificationFeedFromEvent', () => {
+    it('should return unchanged if event has no notification_status or aggregated_activities', () => {
+      const event = createMockNotificationFeedUpdatedEvent();
+
+      const result = updateNotificationFeedFromEvent(event);
+
+      expect(result.changed).toBe(false);
+    });
+
+    it('should update notification_status when event has notification_status', () => {
+      const notificationStatus = createMockNotificationStatus({
+        unread: 5,
+        unseen: 3,
+        read_activities: ['activity1', 'activity2'],
+      });
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: notificationStatus,
+      });
+
+      const result = updateNotificationFeedFromEvent(event);
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toBe(notificationStatus);
+      expect(result.data?.aggregated_activities).toBeUndefined();
+    });
+
+    it('should update aggregated_activities when event has aggregated_activities', () => {
+      const aggregatedActivities = [
+        createMockAggregatedActivity({ group: 'group1' }),
+        createMockAggregatedActivity({ group: 'group2' }),
+      ];
+      const event = createMockNotificationFeedUpdatedEvent({
+        aggregated_activities: aggregatedActivities,
+      });
+
+      const result = updateNotificationFeedFromEvent(event);
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.aggregated_activities).toBe(aggregatedActivities);
+      expect(result.data?.notification_status).toBeUndefined();
+    });
+
+    it('should update both notification_status and aggregated_activities when event has both', () => {
+      const notificationStatus = createMockNotificationStatus({
+        unread: 2,
+        unseen: 1,
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity({ group: 'group1' }),
+      ];
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: notificationStatus,
+        aggregated_activities: aggregatedActivities,
+      });
+
+      const result = updateNotificationFeedFromEvent(event);
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toBe(notificationStatus);
+      expect(result.data?.aggregated_activities).toBe(aggregatedActivities);
+    });
+
+    it('should handle notification_status with all fields', () => {
+      const notificationStatus = createMockNotificationStatus({
+        unread: 10,
+        unseen: 5,
+        last_seen_at: new Date('2023-01-01'),
+        read_activities: ['activity1', 'activity2', 'activity3'],
+      });
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: notificationStatus,
+      });
+
+      const result = updateNotificationFeedFromEvent(event);
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toBe(notificationStatus);
+    });
+  });
+});

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

@@ -1,10 +1,54 @@
 import type { Feed } from '../../../feed';
-import type { EventPayload } from '../../../types-internal';
+import {
+  AggregatedActivityResponse,
+  NotificationFeedUpdatedEvent,
+  NotificationStatusResponse,
+} from '../../../gen/models';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+
+export const updateNotificationFeedFromEvent = (
+  event: NotificationFeedUpdatedEvent,
+): UpdateStateResult<{
+  data?: {
+    notification_status?: NotificationStatusResponse;
+    aggregated_activities?: AggregatedActivityResponse[];
+  };
+}> => {
+  const updates: {
+    notification_status?: NotificationStatusResponse;
+    aggregated_activities?: AggregatedActivityResponse[];
+  } = {};
+
+  if (event.notification_status) {
+    updates.notification_status = event.notification_status;
+  }
+
+  if (event.aggregated_activities) {
+    updates.aggregated_activities = event.aggregated_activities;
+  }
+
+  // Only return changed if we have actual updates
+  if (Object.keys(updates).length > 0) {
+    return {
+      changed: true,
+      data: updates,
+    };
+  }
+
+  return {
+    changed: false,
+  };
+};
 
 export function handleNotificationFeedUpdated(
   this: Feed,
   event: EventPayload<'feeds.notification_feed.updated'>,
 ) {
-  console.info('notification feed updated', event);
-  // TODO: handle notification feed updates
+  const result = updateNotificationFeedFromEvent(event);
+  if (result.changed) {
+    this.state.partialNext({
+      notification_status: result.data?.notification_status,
+      aggregated_activities: result.data?.aggregated_activities,
+    });
+  }
 }

package/src/feed/feed.ts

@@ -12,6 +12,7 @@ import {
   SortParamRequest,
   ThreadedCommentResponse,
   FollowRequest,
+  QueryCommentsRequest,
 } from '../gen/models';
 import { StreamResponse } from '../gen-imports';
 import { StateStore } from '../common/StateStore';
@@ -41,6 +42,7 @@ import {
   handleActivityReactionAdded,
   handleFeedUpdated,
   handleNotificationFeedUpdated,
+  handleActivityMarked,
 } from './event-handlers';
 import { capitalize } from '../common/utils';
 import type {
@@ -70,7 +72,7 @@ export type FeedState = Omit<
     | {
         pagination?: PagerResponseWithLoadingStates & {
           // registered on first pagination attempt and then used for real-time updates & subsequent pagination calls
-          sort?: string;
+          sort?: QueryCommentsRequest['sort'] | (string & {});
         };
         /**
          * Id of the "store" where the actual parent is stored in the comments array.
@@ -180,7 +182,7 @@ export class Feed extends FeedApi {
     'feeds.poll.vote_removed': Feed.noop,
     'feeds.activity.pinned': Feed.noop,
     'feeds.activity.unpinned': Feed.noop,
-    'feeds.activity.marked': Feed.noop,
+    'feeds.activity.marked': handleActivityMarked.bind(this),
     'moderation.custom_action': Feed.noop,
     'moderation.flagged': Feed.noop,
     'moderation.mark_reviewed': Feed.noop,

package/src/gen/feeds/FeedsApi.ts

@@ -578,6 +578,7 @@ export class FeedsApi {
     const body = {
       type: request?.type,
       create_notification_activity: request?.create_notification_activity,
+      skip_push: request?.skip_push,
       custom: request?.custom,
     };
 
@@ -888,6 +889,7 @@ export class FeedsApi {
       object_type: request?.object_type,
       create_notification_activity: request?.create_notification_activity,
       parent_id: request?.parent_id,
+      skip_push: request?.skip_push,
       attachments: request?.attachments,
       mentioned_user_ids: request?.mentioned_user_ids,
       custom: request?.custom,
@@ -1003,6 +1005,7 @@ export class FeedsApi {
     };
     const body = {
       comment: request?.comment,
+      skip_push: request?.skip_push,
       custom: request?.custom,
     };
 
@@ -1031,6 +1034,7 @@ export class FeedsApi {
     const body = {
       type: request?.type,
       create_notification_activity: request?.create_notification_activity,
+      skip_push: request?.skip_push,
       custom: request?.custom,
     };
 
@@ -1554,6 +1558,7 @@ export class FeedsApi {
       create_notification_activity: request?.create_notification_activity,
       follower_role: request?.follower_role,
       push_preference: request?.push_preference,
+      skip_push: request?.skip_push,
       custom: request?.custom,
     };
 
@@ -1581,6 +1586,7 @@ export class FeedsApi {
       target: request?.target,
       create_notification_activity: request?.create_notification_activity,
       push_preference: request?.push_preference,
+      skip_push: request?.skip_push,
       custom: request?.custom,
     };
 

package/src/gen/model-decoders/decoders.ts

@@ -584,6 +584,8 @@ decoders.CommentAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
+    activity: { type: 'ActivityResponse', isSingle: true },
+
     comment: { type: 'CommentResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
@@ -606,6 +608,8 @@ decoders.CommentReactionAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
+    activity: { type: 'ActivityResponse', isSingle: true },
+
     comment: { type: 'CommentResponse', isSingle: true },
 
     reaction: { type: 'FeedsReactionResponse', isSingle: true },
@@ -632,6 +636,8 @@ decoders.CommentReactionUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
+    activity: { type: 'ActivityResponse', isSingle: true },
+
     comment: { type: 'CommentResponse', isSingle: true },
 
     reaction: { type: 'FeedsReactionResponse', isSingle: true },
@@ -1128,6 +1134,8 @@ decoders.Message = (input?: Record<string, any>) => {
 
     thread_participants: { type: 'User', isSingle: false },
 
+    member: { type: 'ChannelMember', isSingle: true },
+
     pinned_by: { type: 'User', isSingle: true },
 
     poll: { type: 'Poll', isSingle: true },
@@ -1214,6 +1222,10 @@ decoders.ModerationCustomActionEvent = (input?: Record<string, any>) => {
 
 decoders.ModerationFlagResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
     review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
 
     user: { type: 'UserResponse', isSingle: true },