@stream-io/feeds-client 0.2.11 → 0.2.13

package/src/feed/event-handlers/comment/utils/update-comment-count.test.ts

@@ -5,7 +5,7 @@ import * as commentHandlers from '../handle-comment-updated';
 import * as activityHandlers from '../../activity';
 import { FeedsClient } from '../../../../feeds-client';
 import { Feed } from '../../../feed';
-import { ActivityResponse, CommentResponse } from '../../../../gen/models';
+import type { ActivityResponse, CommentResponse } from '../../../../gen/models';
 import {
   generateCommentResponse,
   generateFeedResponse,
@@ -14,6 +14,7 @@ import {
 } from '../../../../test-utils';
 
 vi.mock('../../activity', async (importOriginal) => {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
   const actual = await importOriginal<typeof import('../../activity')>();
   return {
     ...actual,
@@ -22,6 +23,7 @@ vi.mock('../../activity', async (importOriginal) => {
 });
 
 vi.mock('../handle-comment-updated', async (importOriginal) => {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
   const actual = await importOriginal<typeof import('../handle-comment-updated')>();
   return {
     ...actual,

package/src/feed/event-handlers/comment/utils/update-comment-count.ts

@@ -1,5 +1,5 @@
-import { ActivityResponse, Feed } from '@self';
-import { CommentResponse } from '@self';
+import type { ActivityResponse, Feed } from '@self';
+import type { CommentResponse } from '@self';
 import { handleCommentUpdated } from '../handle-comment-updated';
 import { handleActivityUpdated } from '../../activity';
 

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

@@ -1,5 +1,5 @@
-import { Feed } from '../../../feed';
-import { EventPayload, PartializeAllBut } from '../../../types-internal';
+import type { Feed } from '../../../feed';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 
 export function handleFeedUpdated(
   this: Feed,

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

@@ -1,5 +1,5 @@
-import { Feed, FeedState } from '../../../feed';
-import { EventPayload } from '../../../types-internal';
+import type { Feed, FeedState } from '../../../feed';
+import type { EventPayload } from '../../../types-internal';
 
 export function handleFeedMemberAdded(
   this: Feed,

package/src/feed/event-handlers/feed-member/handle-feed-member-removed.ts

@@ -1,5 +1,5 @@
-import { Feed, FeedState } from '../../../feed';
-import { EventPayload } from '../../../types-internal';
+import type { Feed, FeedState } from '../../../feed';
+import type { EventPayload } from '../../../types-internal';
 
 export function handleFeedMemberRemoved(
   this: Feed,

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

@@ -1,5 +1,5 @@
-import { Feed, FeedState } from '../../../feed';
-import { EventPayload } from '../../../types-internal';
+import type { Feed, FeedState } from '../../../feed';
+import type { EventPayload } from '../../../types-internal';
 
 export function handleFeedMemberUpdated(
   this: Feed,

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

@@ -1,4 +1,4 @@
-import {
+import type {
   FeedResponse,
   FollowResponse,
   UserResponse,

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

@@ -1,4 +1,4 @@
-import {
+import type {
   FollowResponse,
   FeedResponse,
   UserResponse,

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

@@ -8,7 +8,7 @@ import {
   getHumanId,
   generateOwnUser,
 } from '../../../test-utils/response-generators';
-import { FollowResponse } from '../../../gen/models';
+import type { FollowResponse } from '../../../gen/models';
 
 describe(handleFollowUpdated.name, () => {
   let feed: Feed;

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

@@ -1,6 +1,6 @@
 import type { Feed, FeedState } from '../../feed';
 import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
-import { EventPayload, PartializeAllBut } from '../../../types-internal';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 
 export function handleFollowUpdated(
   this: Feed,

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

@@ -1,10 +1,14 @@
 import { describe, it, expect } from 'vitest';
-import {
+import type {
   NotificationFeedUpdatedEvent,
   NotificationStatusResponse,
   AggregatedActivityResponse,
 } from '../../../gen/models';
-import { updateNotificationFeedFromEvent } from './handle-notification-feed-updated';
+import {
+  updateNotificationFeedFromEvent,
+  addAggregatedActivitiesToState,
+  updateNotificationStatus,
+} from './handle-notification-feed-updated';
 
 const createMockNotificationFeedUpdatedEvent = (
   overrides: Partial<NotificationFeedUpdatedEvent> = {},
@@ -30,6 +34,7 @@ const createMockAggregatedActivity = (
   activity_count: 1,
   created_at: new Date(),
   group: 'test-group',
+  user_count_truncated: false,
   score: 1,
   updated_at: new Date(),
   user_count: 1,
@@ -42,7 +47,34 @@ describe('notification-feed-utils', () => {
     it('should return unchanged if event has no notification_status or aggregated_activities', () => {
       const event = createMockNotificationFeedUpdatedEvent();
 
-      const result = updateNotificationFeedFromEvent(event);
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(false);
+    });
+
+    it(`shouldn't update notification_status when event has notification_status but currentNotificationStatus is undefined`, () => {
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: createMockNotificationStatus(),
+      });
+      const result = updateNotificationFeedFromEvent(event, [], undefined);
+
+      expect(result.changed).toBe(false);
+    });
+
+    it(`shouldn't update aggregated_activities when event has aggregated_activities but currentAggregatedActivities is undefined`, () => {
+      const event = createMockNotificationFeedUpdatedEvent({
+        aggregated_activities: [createMockAggregatedActivity()],
+      });
+      const result = updateNotificationFeedFromEvent(
+        event,
+        undefined,
+        createMockNotificationStatus(),
+      );
 
       expect(result.changed).toBe(false);
     });
@@ -52,15 +84,23 @@ describe('notification-feed-utils', () => {
         unread: 5,
         unseen: 3,
         read_activities: ['activity1', 'activity2'],
+        seen_activities: [],
       });
       const event = createMockNotificationFeedUpdatedEvent({
         notification_status: notificationStatus,
       });
 
-      const result = updateNotificationFeedFromEvent(event);
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
 
       expect(result.changed).toBe(true);
-      expect(result.data?.notification_status).toBe(notificationStatus);
+      expect(result.data?.notification_status).toStrictEqual(
+        notificationStatus,
+      );
       expect(result.data?.aggregated_activities).toBeUndefined();
     });
 
@@ -73,10 +113,17 @@ describe('notification-feed-utils', () => {
         aggregated_activities: aggregatedActivities,
       });
 
-      const result = updateNotificationFeedFromEvent(event);
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
 
       expect(result.changed).toBe(true);
-      expect(result.data?.aggregated_activities).toBe(aggregatedActivities);
+      expect(result.data?.aggregated_activities).toStrictEqual(
+        aggregatedActivities,
+      );
       expect(result.data?.notification_status).toBeUndefined();
     });
 
@@ -93,11 +140,23 @@ describe('notification-feed-utils', () => {
         aggregated_activities: aggregatedActivities,
       });
 
-      const result = updateNotificationFeedFromEvent(event);
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
 
       expect(result.changed).toBe(true);
-      expect(result.data?.notification_status).toBe(notificationStatus);
-      expect(result.data?.aggregated_activities).toBe(aggregatedActivities);
+      expect(result.data?.notification_status?.unread).toBe(
+        notificationStatus.unread,
+      );
+      expect(result.data?.notification_status?.unseen).toBe(
+        notificationStatus.unseen,
+      );
+      expect(result.data?.aggregated_activities).toStrictEqual(
+        aggregatedActivities,
+      );
     });
 
     it('should handle notification_status with all fields', () => {
@@ -105,16 +164,255 @@ describe('notification-feed-utils', () => {
         unread: 10,
         unseen: 5,
         last_seen_at: new Date('2023-01-01'),
+        seen_activities: [],
         read_activities: ['activity1', 'activity2', 'activity3'],
       });
       const event = createMockNotificationFeedUpdatedEvent({
         notification_status: notificationStatus,
       });
 
-      const result = updateNotificationFeedFromEvent(event);
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toStrictEqual(
+        notificationStatus,
+      );
+    });
+  });
+
+  describe('addAggregatedActivitiesToState', () => {
+    it('should add new activities when none exist', () => {
+      const newActivities = [
+        createMockAggregatedActivity({ group: 'group1' }),
+        createMockAggregatedActivity({ group: 'group2' }),
+      ];
+
+      const result = addAggregatedActivitiesToState(
+        newActivities,
+        undefined,
+        'start',
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.aggregated_activities).toStrictEqual(newActivities);
+    });
+
+    it('should add new activities to existing ones', () => {
+      const existingActivities = [
+        createMockAggregatedActivity({ group: 'existing1' }),
+      ];
+      const newActivities = [
+        createMockAggregatedActivity({ group: 'new1' }),
+        createMockAggregatedActivity({ group: 'new2' }),
+      ];
+
+      const result = addAggregatedActivitiesToState(
+        newActivities,
+        existingActivities,
+        'start',
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.aggregated_activities).toStrictEqual([
+        ...newActivities,
+        ...existingActivities,
+      ]);
+    });
+
+    it('should add new activities at the end when position is end', () => {
+      const existingActivities = [
+        createMockAggregatedActivity({ group: 'existing1' }),
+      ];
+      const newActivities = [createMockAggregatedActivity({ group: 'new1' })];
+
+      const result = addAggregatedActivitiesToState(
+        newActivities,
+        existingActivities,
+        'end',
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.aggregated_activities).toStrictEqual([
+        ...existingActivities,
+        ...newActivities,
+      ]);
+    });
+
+    it('should update existing activities with same group (upsert)', () => {
+      const baseDate = new Date('2023-01-01');
+      const existingActivities = [
+        createMockAggregatedActivity({
+          group: 'group1',
+          activity_count: 1,
+          score: 10,
+          updated_at: baseDate,
+        }),
+        createMockAggregatedActivity({
+          group: 'group2',
+          activity_count: 2,
+          score: 20,
+        }),
+      ];
+      const newActivities = [
+        createMockAggregatedActivity({
+          group: 'group1',
+          activity_count: 3,
+          score: 30,
+          updated_at: new Date('2023-01-02'),
+        }),
+        createMockAggregatedActivity({
+          group: 'group3',
+          activity_count: 4,
+          score: 40,
+        }),
+      ];
+
+      const result = addAggregatedActivitiesToState(
+        newActivities,
+        existingActivities,
+        'start',
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.aggregated_activities).toHaveLength(3);
+
+      // Check that group1 was updated
+      const updatedGroup1 = result.aggregated_activities.find(
+        (a) => a.group === 'group1',
+      );
+      expect(updatedGroup1?.activity_count).toBe(3);
+      expect(updatedGroup1?.score).toBe(30);
+      expect(updatedGroup1?.updated_at).toEqual(new Date('2023-01-02'));
+
+      // Check that group2 remains unchanged
+      const unchangedGroup2 = result.aggregated_activities.find(
+        (a) => a.group === 'group2',
+      );
+      expect(unchangedGroup2?.activity_count).toBe(2);
+      expect(unchangedGroup2?.score).toBe(20);
+
+      // Check that group3 was added
+      const newGroup3 = result.aggregated_activities.find(
+        (a) => a.group === 'group3',
+      );
+      expect(newGroup3?.activity_count).toBe(4);
+      expect(newGroup3?.score).toBe(40);
+    });
+
+    it('should handle mixed new and existing activities', () => {
+      const existingActivities = [
+        createMockAggregatedActivity({ group: 'existing1' }),
+        createMockAggregatedActivity({ group: 'existing2' }),
+      ];
+      const newActivities = [
+        createMockAggregatedActivity({ group: 'existing1', activity_count: 5 }), // Update existing
+        createMockAggregatedActivity({ group: 'new1' }), // Add new
+        createMockAggregatedActivity({ group: 'existing2', score: 100 }), // Update existing
+        createMockAggregatedActivity({ group: 'new2' }), // Add new
+      ];
+
+      const result = addAggregatedActivitiesToState(
+        newActivities,
+        existingActivities,
+        'start',
+      );
 
       expect(result.changed).toBe(true);
-      expect(result.data?.notification_status).toBe(notificationStatus);
+      expect(result.aggregated_activities).toHaveLength(4);
+
+      // Check that existing1 was updated
+      const updatedExisting1 = result.aggregated_activities.find(
+        (a) => a.group === 'existing1',
+      );
+      expect(updatedExisting1?.activity_count).toBe(5);
+
+      // Check that existing2 was updated
+      const updatedExisting2 = result.aggregated_activities.find(
+        (a) => a.group === 'existing2',
+      );
+      expect(updatedExisting2?.score).toBe(100);
+
+      // Check that new activities were added
+      expect(
+        result.aggregated_activities.find((a) => a.group === 'new1'),
+      ).toBeDefined();
+      expect(
+        result.aggregated_activities.find((a) => a.group === 'new2'),
+      ).toBeDefined();
+    });
+
+    it('should preserve order when adding at start', () => {
+      const existingActivities = [
+        createMockAggregatedActivity({ group: 'existing1' }),
+        createMockAggregatedActivity({ group: 'existing2' }),
+      ];
+      const newActivities = [
+        createMockAggregatedActivity({ group: 'new1' }),
+        createMockAggregatedActivity({ group: 'new2' }),
+      ];
+
+      const result = addAggregatedActivitiesToState(
+        newActivities,
+        existingActivities,
+        'start',
+      );
+
+      expect(result.aggregated_activities).toStrictEqual([
+        ...newActivities,
+        ...existingActivities,
+      ]);
+    });
+
+    it('should preserve order when adding at end', () => {
+      const existingActivities = [
+        createMockAggregatedActivity({ group: 'existing1' }),
+        createMockAggregatedActivity({ group: 'existing2' }),
+      ];
+      const newActivities = [
+        createMockAggregatedActivity({ group: 'new1' }),
+        createMockAggregatedActivity({ group: 'new2' }),
+      ];
+
+      const result = addAggregatedActivitiesToState(
+        newActivities,
+        existingActivities,
+        'end',
+      );
+
+      expect(result.aggregated_activities).toStrictEqual([
+        ...existingActivities,
+        ...newActivities,
+      ]);
+    });
+  });
+
+  describe('updateNotificationStatus', () => {
+    it('should replace old state with new one', () => {
+      const newNotificationStatus = createMockNotificationStatus({
+        unread: 5,
+        unseen: 3,
+        read_activities: ['activity1', 'activity2'],
+        seen_activities: ['activity3', 'activity4'],
+      });
+
+      const currentNotificationStatus = createMockNotificationStatus({
+        unread: 2,
+        unseen: 1,
+        read_activities: ['activity5', 'activity6'],
+        seen_activities: ['activity7', 'activity8'],
+      });
+
+      const result = updateNotificationStatus(
+        newNotificationStatus,
+        currentNotificationStatus,
+      );
+
+      expect(result.notification_status).toStrictEqual(newNotificationStatus);
     });
   });
 });

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

@@ -1,13 +1,76 @@
 import type { Feed } from '../../../feed';
-import {
+import type {
   AggregatedActivityResponse,
   NotificationFeedUpdatedEvent,
   NotificationStatusResponse,
 } from '../../../gen/models';
 import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+import { uniqueArrayMerge } from '../../../utils';
+
+export const addAggregatedActivitiesToState = (
+  newAggregatedActivities: AggregatedActivityResponse[],
+  aggregatedActivities: AggregatedActivityResponse[] | undefined,
+  position: 'start' | 'end',
+) => {
+  let result: UpdateStateResult<{
+    aggregated_activities: AggregatedActivityResponse[];
+  }>;
+  if (newAggregatedActivities.length === 0) {
+    result = {
+      changed: false,
+      aggregated_activities: [],
+    };
+  } else {
+    result = {
+      changed: true,
+      aggregated_activities: [],
+    };
+  }
+
+  result.aggregated_activities =
+    position === 'start'
+      ? uniqueArrayMerge(
+          newAggregatedActivities,
+          aggregatedActivities ?? [],
+          (a) => a.group,
+        )
+      : uniqueArrayMerge(
+          aggregatedActivities ?? [],
+          newAggregatedActivities,
+          (a) => a.group,
+        );
+
+  return result;
+};
+
+export const updateNotificationStatus = (
+  newNotificationStatus?: NotificationStatusResponse,
+  currentNotificationStatus?: NotificationStatusResponse,
+) => {
+  if (!newNotificationStatus && !currentNotificationStatus) {
+    return {
+      changed: false,
+      notification_status: undefined,
+    };
+  } else if (!newNotificationStatus) {
+    return {
+      changed: false,
+      notification_status: currentNotificationStatus,
+    };
+  } else {
+    return {
+      changed: true,
+      notification_status: {
+        ...newNotificationStatus,
+      },
+    };
+  }
+};
 
 export const updateNotificationFeedFromEvent = (
   event: NotificationFeedUpdatedEvent,
+  currentAggregatedActivities?: AggregatedActivityResponse[],
+  currentNotificationStatus?: NotificationStatusResponse,
 ): UpdateStateResult<{
   data?: {
     notification_status?: NotificationStatusResponse;
@@ -19,15 +82,31 @@ export const updateNotificationFeedFromEvent = (
     aggregated_activities?: AggregatedActivityResponse[];
   } = {};
 
-  if (event.notification_status) {
-    updates.notification_status = event.notification_status;
+  if (event.notification_status && currentNotificationStatus) {
+    const notificationStatusResult = updateNotificationStatus(
+      event.notification_status,
+      currentNotificationStatus,
+    );
+
+    if (notificationStatusResult.changed) {
+      updates.notification_status =
+        notificationStatusResult.notification_status;
+    }
   }
 
-  if (event.aggregated_activities) {
-    updates.aggregated_activities = event.aggregated_activities;
+  if (event.aggregated_activities && currentAggregatedActivities) {
+    const aggregatedActivitiesResult = addAggregatedActivitiesToState(
+      event.aggregated_activities,
+      currentAggregatedActivities,
+      'start',
+    );
+
+    if (aggregatedActivitiesResult.changed) {
+      updates.aggregated_activities =
+        aggregatedActivitiesResult.aggregated_activities;
+    }
   }
 
-  // Only return changed if we have actual updates
   if (Object.keys(updates).length > 0) {
     return {
       changed: true,
@@ -44,7 +123,11 @@ export function handleNotificationFeedUpdated(
   this: Feed,
   event: EventPayload<'feeds.notification_feed.updated'>,
 ) {
-  const result = updateNotificationFeedFromEvent(event);
+  const result = updateNotificationFeedFromEvent(
+    event,
+    this.currentState.aggregated_activities,
+    this.currentState.notification_status,
+  );
   if (result.changed) {
     this.state.partialNext({
       notification_status: result.data?.notification_status,

package/src/feed/event-handlers/watch/handle-watch-started.ts

@@ -1,4 +1,4 @@
-import { Feed } from '../../feed';
+import type { Feed } from '../../feed';
 
 export function handleWatchStarted(this: Feed) {
   this.state.partialNext({ watch: true });

package/src/feed/event-handlers/watch/handle-watch-stopped.ts

@@ -1,4 +1,4 @@
-import { Feed } from '../../feed';
+import type { Feed } from '../../feed';
 
 export function handleWatchStopped(this: Feed) {
   this.state.partialNext({ watch: false });

package/src/feed/feed.test.ts

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, it } from 'vitest';
 import { FeedsClient } from '../feeds-client';
 import { Feed } from './feed';
-import { ActivityResponse } from '../gen/models';
+import type { ActivityResponse } from '../gen/models';
 import { generateActivityResponse, generateFeedResponse } from '../test-utils';
 
 describe('Feed derived state updates', () => {