@stream-io/feeds-client 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/feeds-client",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "packageManager": "yarn@3.2.4",
   "main": "./dist/index.node.js",
   "exports": {

package/src/feed/event-handlers/activity/activity-marked-utils.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect } from 'vitest';
+import {
+  ActivityMarkEvent,
+  NotificationStatusResponse,
+} from '../../../gen/models';
+import { updateNotificationStatusFromActivityMarked } from './handle-activity-marked';
+
+const createMockActivityMarkEvent = (
+  overrides: Partial<ActivityMarkEvent> = {},
+): ActivityMarkEvent => ({
+  created_at: new Date(),
+  fid: 'user:notification',
+  custom: {},
+  type: 'feeds.activity.marked',
+  ...overrides,
+});
+
+const createMockNotificationStatus = (
+  overrides: Partial<NotificationStatusResponse> = {},
+): NotificationStatusResponse => ({
+  unread: 0,
+  unseen: 0,
+  ...overrides,
+});
+
+const createMockAggregatedActivity = (group: string) => ({ group });
+
+describe('activity-marked-utils', () => {
+  describe('updateNotificationStatusFromActivityMarked', () => {
+    it('should return unchanged if notification_status is undefined', () => {
+      const event = createMockActivityMarkEvent({ mark_all_read: true });
+      const currentStatus = undefined;
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(false);
+    });
+
+    it('should handle mark_all_read by adding all aggregated activity groups', () => {
+      const event = createMockActivityMarkEvent({ mark_all_read: true });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1'],
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity('group1'),
+        createMockAggregatedActivity('group2'),
+        createMockAggregatedActivity('group3'),
+      ];
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+        aggregatedActivities,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'group1',
+        'group2',
+        'group3',
+      ]);
+    });
+
+    it('should handle mark_read by adding specific activity IDs', () => {
+      const event = createMockActivityMarkEvent({
+        mark_read: ['activity1', 'activity2'],
+      });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1'],
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'activity1',
+        'activity2',
+      ]);
+    });
+
+    it('should handle mark_all_seen by setting last_seen_at to current date', () => {
+      const event = createMockActivityMarkEvent({ mark_all_seen: true });
+      const currentStatus = createMockNotificationStatus({
+        last_seen_at: new Date('2023-01-01'),
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.last_seen_at).toBeInstanceOf(
+        Date,
+      );
+      expect(
+        result.data?.notification_status.last_seen_at!.getTime(),
+      ).toBeGreaterThan(new Date('2023-01-01').getTime());
+    });
+
+    it('should handle multiple mark flags simultaneously', () => {
+      const event = createMockActivityMarkEvent({
+        mark_all_read: true,
+        mark_all_seen: true,
+      });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1'],
+        last_seen_at: new Date('2023-01-01'),
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity('group1'),
+        createMockAggregatedActivity('group2'),
+      ];
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+        aggregatedActivities,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'group1',
+        'group2',
+      ]);
+      expect(result.data?.notification_status.last_seen_at).toBeInstanceOf(
+        Date,
+      );
+    });
+
+    it('should deduplicate read activities when adding new ones', () => {
+      const event = createMockActivityMarkEvent({
+        mark_read: ['activity1', 'activity1', 'activity2'],
+      });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1', 'activity1'],
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'activity1',
+        'activity2',
+      ]);
+    });
+
+    it('should preserve existing notification status fields', () => {
+      const event = createMockActivityMarkEvent({ mark_all_seen: true });
+      const currentStatus = createMockNotificationStatus({
+        unread: 5,
+        unseen: 3,
+        read_activities: ['existing1'],
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.unread).toBe(5);
+      expect(result.data?.notification_status.unseen).toBe(3);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+      ]);
+      expect(result.data?.notification_status.last_seen_at).toBeInstanceOf(
+        Date,
+      );
+    });
+
+    it('should handle mark_all_read with no existing read_activities', () => {
+      const event = createMockActivityMarkEvent({ mark_all_read: true });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: undefined,
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity('group1'),
+        createMockAggregatedActivity('group2'),
+      ];
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+        aggregatedActivities,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'group1',
+        'group2',
+      ]);
+    });
+  });
+});

package/src/feed/event-handlers/activity/activity-reaction-utils.test.ts

@@ -5,73 +5,45 @@ import {
   ActivityResponse,
   FeedsReactionResponse,
 } from '../../../gen/models';
+import { addReactionToActivities, removeReactionFromActivities } from './';
 import {
-  addReactionToActivity,
-  removeReactionFromActivity,
-  addReactionToActivities,
-  removeReactionFromActivities,
-} from './';
-
-const createMockActivity = (id: string): ActivityResponse => ({
-  id,
-  type: 'test',
-  created_at: new Date(),
-  updated_at: new Date(),
-  visibility: 'public',
-  bookmark_count: 0,
-  comment_count: 0,
-  share_count: 0,
-  attachments: [],
-  comments: [],
-  feeds: [],
-  filter_tags: [],
-  interest_tags: [],
-  latest_reactions: [],
-  mentioned_users: [],
-  own_bookmarks: [],
-  own_reactions: [],
-  custom: {},
-  reaction_groups: {},
-  search_data: {},
-  popularity: 0,
-  score: 0,
-  reaction_count: 0,
-  user: {
-    id: 'user1',
-    created_at: new Date(),
-    updated_at: new Date(),
-    banned: false,
-    language: 'en',
-    online: false,
-    role: 'user',
-    blocked_user_ids: [],
-    teams: [],
-    custom: {},
-  },
-});
+  generateActivityResponse,
+  generateFeedReactionResponse,
+} from '../../../test-utils';
 
-const createMockReaction = (
-  type: string,
-  userId: string,
-  activityId: string,
-): FeedsReactionResponse => ({
-  type,
-  user: {
-    id: userId,
-    created_at: new Date(),
-    updated_at: new Date(),
-    banned: false,
-    language: 'en',
-    online: false,
-    role: 'user',
-    blocked_user_ids: [],
-    teams: [],
-    custom: {},
-  },
-  activity_id: activityId,
-  created_at: new Date(),
-  updated_at: new Date(),
-});
+const addReactionToActivity = (
+  event: ActivityReactionAddedEvent,
+  activity: ActivityResponse,
+  eventBelongsToCurrentUser: boolean,
+) => {
+  const result = addReactionToActivities(
+    event,
+    [activity],
+    eventBelongsToCurrentUser,
+  );
+
+  return {
+    changed: result.changed,
+    ...result.entities![0],
+  };
+};
+
+const removeReactionFromActivity = (
+  event: ActivityReactionAddedEvent,
+  activity: ActivityResponse,
+  eventBelongsToCurrentUser: boolean,
+) => {
+  const result = removeReactionFromActivities(
+    event,
+    [activity],
+    eventBelongsToCurrentUser,
+  );
+
+  return {
+    changed: result.changed,
+    ...result.entities![0],
+  };
+};
 
 const createMockAddedEvent = (
   reaction: FeedsReactionResponse,
@@ -100,8 +72,12 @@ const createMockDeletedEvent = (
 describe('activity-reaction-utils', () => {
   describe('addReactionToActivity', () => {
     it('should add reaction to own_reactions when from current user', () => {
-      const activity = createMockActivity('activity1');
-      const reaction = createMockReaction('like', 'user1', 'activity1');
+      const activity = generateActivityResponse({ id: 'activity1' });
+      const reaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: 'user1' },
+        activity_id: 'activity1',
+      });
       const eventActivity = { ...activity };
       eventActivity.latest_reactions = [reaction];
       eventActivity.reaction_groups = {
@@ -129,8 +105,12 @@ describe('activity-reaction-utils', () => {
     });
 
     it('should not add reaction to own_reactions when not from current user', () => {
-      const activity = createMockActivity('activity1');
-      const reaction = createMockReaction('like', 'user2', 'activity1');
+      const activity = generateActivityResponse({ id: 'activity1' });
+      const reaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: 'user2' },
+        activity_id: 'activity1',
+      });
       const eventActivity = { ...activity };
       eventActivity.latest_reactions = [reaction];
       eventActivity.reaction_groups = {
@@ -160,8 +140,12 @@ describe('activity-reaction-utils', () => {
 
   describe('removeReactionFromActivity', () => {
     it('should remove reaction from own_reactions when from current user', () => {
-      const activity = createMockActivity('activity1');
-      const reaction = createMockReaction('like', 'user1', 'activity1');
+      const activity = generateActivityResponse({ id: 'activity1' });
+      const reaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: 'user1' },
+        activity_id: 'activity1',
+      });
       const eventActivity = { ...activity };
       eventActivity.latest_reactions = [reaction];
       eventActivity.reaction_groups = {
@@ -192,8 +176,12 @@ describe('activity-reaction-utils', () => {
     });
 
     it('should not remove reaction from own_reactions when not from current user', () => {
-      const activity = createMockActivity('activity1');
-      const reaction = createMockReaction('like', 'user1', 'activity1');
+      const activity = generateActivityResponse({ id: 'activity1' });
+      const reaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: 'user1' },
+        activity_id: 'activity1',
+      });
       const eventActivity = { ...activity };
       eventActivity.latest_reactions = [reaction];
       eventActivity.reaction_groups = {
@@ -226,9 +214,13 @@ describe('activity-reaction-utils', () => {
 
   describe('addReactionToActivities', () => {
     it('should add reaction to activity in activities array', () => {
-      const activity = createMockActivity('activity1');
+      const activity = generateActivityResponse({ id: 'activity1' });
       const activities = [activity];
-      const reaction = createMockReaction('like', 'user1', 'activity1');
+      const reaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: 'user1' },
+        activity_id: 'activity1',
+      });
       const eventActivity = { ...activity };
       eventActivity.latest_reactions = [reaction];
       eventActivity.reaction_groups = {
@@ -244,16 +236,20 @@ describe('activity-reaction-utils', () => {
       const result = addReactionToActivities(event, activities, true);
 
       expect(result.changed).toBe(true);
-      expect(result.activities).toHaveLength(1);
-      expect(result.activities[0].own_reactions).toHaveLength(1);
-      expect(result.activities[0].own_reactions[0]).toEqual(reaction);
+      expect(result.entities!).toHaveLength(1);
+      expect(result.entities![0].own_reactions).toHaveLength(1);
+      expect(result.entities![0].own_reactions[0]).toEqual(reaction);
     });
 
     it('should return unchanged state if activity not found', () => {
-      const activity = createMockActivity('activity1');
+      const activity = generateActivityResponse({ id: 'activity1' });
       const activities = [activity];
-      const reaction = createMockReaction('like', 'user1', 'activity2');
-      const eventActivity = createMockActivity('activity2');
+      const reaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: 'user1' },
+        activity_id: 'activity2',
+      });
+      const eventActivity = generateActivityResponse({ id: 'activity2' });
       eventActivity.latest_reactions = [reaction];
       eventActivity.reaction_groups = {
         [reaction.type]: {
@@ -268,12 +264,16 @@ describe('activity-reaction-utils', () => {
       const result = addReactionToActivities(event, activities, true);
 
       expect(result.changed).toBe(false);
-      expect(result.activities).toBe(activities);
+      expect(result.entities).toBe(activities);
     });
 
     it('should handle undefined activities', () => {
-      const activity = createMockActivity('activity1');
-      const reaction = createMockReaction('like', 'user1', 'activity1');
+      const activity = generateActivityResponse({ id: 'activity1' });
+      const reaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: 'user1' },
+        activity_id: 'activity1',
+      });
       const eventActivity = { ...activity };
       eventActivity.own_reactions = [reaction];
       eventActivity.latest_reactions = [reaction];
@@ -290,14 +290,18 @@ describe('activity-reaction-utils', () => {
       const result = addReactionToActivities(event, undefined, true);
 
       expect(result.changed).toBe(false);
-      expect(result.activities).toEqual([]);
+      expect(result.entities).toBeUndefined();
     });
   });
 
   describe('removeReactionFromActivities', () => {
     it('should remove reaction from activity in activities array', () => {
-      const activity = createMockActivity('activity1');
-      const reaction = createMockReaction('like', 'user1', 'activity1');
+      const activity = generateActivityResponse({ id: 'activity1' });
+      const reaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: 'user1' },
+        activity_id: 'activity1',
+      });
       const eventActivity = { ...activity };
       eventActivity.latest_reactions = [reaction];
       eventActivity.reaction_groups = {
@@ -323,15 +327,19 @@ describe('activity-reaction-utils', () => {
       );
 
       expect(result.changed).toBe(true);
-      expect(result.activities).toHaveLength(1);
-      expect(result.activities[0].own_reactions).toHaveLength(0);
+      expect(result.entities).toHaveLength(1);
+      expect(result.entities![0].own_reactions).toHaveLength(0);
     });
 
     it('should return unchanged state if activity not found', () => {
-      const activity = createMockActivity('activity1');
+      const activity = generateActivityResponse({ id: 'activity1' });
       const activities = [activity];
-      const reaction = createMockReaction('like', 'user1', 'activity2');
-      const eventActivity = createMockActivity('activity2');
+      const reaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: 'user1' },
+        activity_id: 'activity2',
+      });
+      const eventActivity = generateActivityResponse({ id: 'activity2' });
       eventActivity.latest_reactions = [];
       eventActivity.reaction_groups = {};
       const event = createMockDeletedEvent(reaction, eventActivity);
@@ -339,12 +347,16 @@ describe('activity-reaction-utils', () => {
       const result = removeReactionFromActivities(event, activities, true);
 
       expect(result.changed).toBe(false);
-      expect(result.activities).toBe(activities);
+      expect(result.entities).toBe(activities);
     });
 
     it('should handle undefined activities', () => {
-      const activity = createMockActivity('activity1');
-      const reaction = createMockReaction('like', 'user1', 'activity1');
+      const activity = generateActivityResponse({ id: 'activity1' });
+      const reaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: 'user1' },
+        activity_id: 'activity1',
+      });
       const eventActivity = { ...activity };
       eventActivity.latest_reactions = [];
       eventActivity.reaction_groups = {};
@@ -353,7 +365,7 @@ describe('activity-reaction-utils', () => {
       const result = removeReactionFromActivities(event, undefined, true);
 
       expect(result.changed).toBe(false);
-      expect(result.activities).toEqual([]);
+      expect(result.entities).toBeUndefined();
     });
   });
 });