@stream-io/feeds-client 0.2.0 → 0.2.2

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

@@ -1,55 +1,19 @@
 import { describe, it, expect } from 'vitest';
-import { ActivityResponse, FeedsReactionResponse } from '../../../gen/models';
+import { ActivityResponse } from '../../../gen/models';
 import {
   addActivitiesToState,
   updateActivityInState,
   removeActivityFromState,
 } from './';
-
-const createMockActivity = (id: string, text?: 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: {},
-    text: text,
-    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: {},
-    },
-  }) as ActivityResponse;
+import {
+  generateActivityResponse,
+  generateFeedReactionResponse,
+} from '../../../test-utils';
 
 describe('activity-utils', () => {
   describe('addActivitiesToState', () => {
-    const activity1 = createMockActivity('activity1');
-    const activity2 = createMockActivity('activity2');
+    const activity1 = generateActivityResponse({ id: 'activity1' });
+    const activity2 = generateActivityResponse({ id: 'activity2' });
 
     it('should add activities to empty state', () => {
       const result = addActivitiesToState([activity1], undefined, 'start');
@@ -101,7 +65,7 @@ describe('activity-utils', () => {
     });
 
     it('should handle multiple new activities correctly', () => {
-      const activity3 = createMockActivity('activity3');
+      const activity3 = generateActivityResponse({ id: 'activity3' });
 
       const existingActivities = [activity1];
       const result = addActivitiesToState(
@@ -120,109 +84,107 @@ describe('activity-utils', () => {
 
   describe('updateActivityInState', () => {
     it('should update an activity in the state', () => {
-      const originalActivity = createMockActivity('activity1', 'original text');
-      const updatedActivity = createMockActivity('activity1', 'updated text');
+      const originalActivity = generateActivityResponse({
+        id: 'activity1',
+        text: 'original text',
+      });
+      const updatedActivity = { ...originalActivity, text: 'updated text' };
       const originalActivities = [originalActivity];
 
-      const result = updateActivityInState(updatedActivity, originalActivities);
+      const result = updateActivityInState(
+        {
+          activity: updatedActivity,
+          created_at: new Date(),
+          fid: '',
+          type: '',
+          custom: {},
+        },
+        originalActivities,
+      );
 
       expect(result.changed).toBe(true);
-      expect(result.activities).toHaveLength(1);
-      expect(result.activities[0].id).toBe('activity1');
-      expect(result.activities[0].text).toBe('updated text');
+      expect(result.entities).toHaveLength(1);
+      expect(result.entities![0].id).toBe('activity1');
+      expect(result.entities![0].text).toBe('updated text');
 
       // Make sure we create a new array
-      expect(originalActivities === result.activities).toBe(false);
+      expect(originalActivities === result.entities).toBe(false);
     });
 
-    it('should preserve reaction data when updating an activity', () => {
-      const originalActivity = createMockActivity('activity1', 'original text');
-      // Mock the reaction structure with proper types
-      originalActivity.own_reactions = [
-        {
-          type: 'like',
-          user: {
-            id: 'user1',
-            created_at: new Date(),
-            updated_at: new Date(),
-            banned: false,
-            language: 'en',
-            online: false,
-            role: 'user',
-            blocked_user_ids: [],
-            teams: [],
-            custom: {},
-          },
-          activity_id: 'activity1',
-          created_at: new Date(),
-          updated_at: new Date(),
+    it('should preserve reaction data (own_reaction) when updating an activity', () => {
+      const r = generateFeedReactionResponse({
+        activity_id: 'activity1',
+        user: {
+          id: 'user1',
         },
-      ];
-      originalActivity.latest_reactions = {} as FeedsReactionResponse[];
-      (originalActivity.latest_reactions as any).like = [
+      });
+      const originalActivity = generateActivityResponse({
+        id: 'activity1',
+        text: 'original text',
+        own_reactions: [r],
+        latest_reactions: [r],
+      });
+
+      const updatedActivity = generateActivityResponse({
+        id: 'activity1',
+        text: 'updated text',
+        own_reactions: [],
+        latest_reactions: [
+          r,
+          generateFeedReactionResponse({
+            activity_id: 'activity1',
+            user: { id: 'user2' },
+          }),
+        ],
+      });
+
+      const result = updateActivityInState(
         {
-          type: 'like',
-          user: {
-            id: 'user1',
-            created_at: new Date(),
-            updated_at: new Date(),
-            banned: false,
-            language: 'en',
-            online: false,
-            role: 'user',
-            blocked_user_ids: [],
-            teams: [],
-            custom: {},
-          },
-          activity_id: 'activity1',
+          activity: updatedActivity,
           created_at: new Date(),
-          updated_at: new Date(),
-        },
-      ];
-      originalActivity.reaction_groups = {
-        like: {
-          sum_scores: 0,
-          count: 1,
-          first_reaction_at: new Date(),
-          last_reaction_at: new Date(),
+          fid: '',
+          type: '',
+          custom: {},
         },
-      };
-
-      const updatedActivity = createMockActivity('activity1', 'updated text');
-      // Reactions are not included in the updated activity from server
-
-      const result = updateActivityInState(updatedActivity, [originalActivity]);
+        [originalActivity],
+      );
 
       expect(result.changed).toBe(true);
-      expect(result.activities[0].text).toBe('updated text');
+      expect(result.entities![0].text).toBe('updated text');
       // Check that reactions were preserved
-      expect(result.activities[0].own_reactions).toEqual(
+      expect(result.entities![0].own_reactions).toEqual(
         originalActivity.own_reactions,
       );
-      expect(result.activities[0].latest_reactions).toEqual(
-        originalActivity.latest_reactions,
-      );
-      expect(result.activities[0].reaction_groups).toEqual(
-        originalActivity.reaction_groups,
-      );
     });
 
     it('should return unchanged state if activity not found', () => {
-      const existingActivity = createMockActivity('activity1');
-      const updatedActivity = createMockActivity('activity2', 'some text');
+      const existingActivity = generateActivityResponse({ id: 'activity1' });
+      const updatedActivity = generateActivityResponse({
+        id: 'activity2',
+        text: 'some text',
+      });
 
-      const result = updateActivityInState(updatedActivity, [existingActivity]);
+      const result = updateActivityInState(
+        {
+          activity: updatedActivity,
+          created_at: new Date(),
+          fid: '',
+          type: '',
+          custom: {},
+        },
+        [existingActivity],
+      );
 
       expect(result.changed).toBe(false);
-      expect(result.activities).toHaveLength(1);
-      expect(result.activities[0].id).toBe('activity1');
+      expect(result.entities).toHaveLength(1);
+      expect(result.entities![0].id).toBe('activity1');
     });
   });
 
   describe('removeActivityFromState', () => {
     it('should remove an activity from the state', () => {
-      const activity1 = createMockActivity('activity1');
-      const activity2 = createMockActivity('activity2');
+      const activity1 = generateActivityResponse({ id: 'activity1' });
+      const activity2 = generateActivityResponse({ id: 'activity2' });
       const activities = [activity1, activity2];
 
       const result = removeActivityFromState(activity1, activities);
@@ -235,8 +197,8 @@ describe('activity-utils', () => {
     });
 
     it('should return unchanged state if activity not found', () => {
-      const activity1 = createMockActivity('activity1');
-      const activity2 = createMockActivity('activity2');
+      const activity1 = generateActivityResponse({ id: 'activity1' });
+      const activity2 = generateActivityResponse({ id: 'activity2' });
       const activities = [activity1];
 
       const result = removeActivityFromState(activity2, activities);
@@ -247,7 +209,7 @@ describe('activity-utils', () => {
     });
 
     it('should handle empty activities array', () => {
-      const activity = createMockActivity('activity1');
+      const activity = generateActivityResponse({ id: 'activity1' });
       const activities: ActivityResponse[] = [];
 
       const result = removeActivityFromState(activity, activities);

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

@@ -1,14 +1,20 @@
 import type { Feed } from '../../../feed';
-import type { ActivityResponse } from '../../../gen/models';
+import type {
+  ActivityPinResponse,
+  ActivityResponse,
+} from '../../../gen/models';
 import type { EventPayload } from '../../../types-internal';
 
 export const removeActivityFromState = (
   activityResponse: ActivityResponse,
-  activities: ActivityResponse[],
+  activities: ActivityResponse[] | undefined,
 ) => {
-  const index = activities.findIndex((a) => a.id === activityResponse.id);
+  const index =
+    activities?.findIndex((activity) => activity.id === activityResponse.id) ??
+    -1;
+
   if (index !== -1) {
-    const newActivities = [...activities];
+    const newActivities = [...activities!];
     newActivities.splice(index, 1);
     return { changed: true, activities: newActivities };
   } else {
@@ -16,15 +22,42 @@ export const removeActivityFromState = (
   }
 };
 
+export const removePinnedActivityFromState = (
+  activityResponse: ActivityResponse,
+  pinnedActivities: ActivityPinResponse[] | undefined,
+) => {
+  const index =
+    pinnedActivities?.findIndex(
+      (pinnedActivity) => pinnedActivity.activity.id === activityResponse.id,
+    ) ?? -1;
+
+  if (index !== -1) {
+    const newActivities = [...pinnedActivities!];
+    newActivities.splice(index, 1);
+    return { changed: true, activities: newActivities };
+  } else {
+    return { changed: false, pinned_activities: pinnedActivities };
+  }
+};
+
 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 });
-    }
+  const {
+    activities: currentActivities,
+    pinned_activities: currentPinnedActivities,
+  } = this.currentState;
+
+  const [result1, result2] = [
+    removeActivityFromState(event.activity, currentActivities),
+    removePinnedActivityFromState(event.activity, currentPinnedActivities),
+  ];
+
+  if (result1.changed || result2.changed) {
+    this.state.partialNext({
+      activities: result1.activities,
+      pinned_activities: result2.pinned_activities,
+    });
   }
 }

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

@@ -0,0 +1,68 @@
+import {
+  ActivityMarkEvent,
+  NotificationStatusResponse,
+} from '../../../gen/models';
+import { EventPayload, UpdateStateResult } from '../../../types-internal';
+import { Feed } from '../../feed';
+
+export const updateNotificationStatusFromActivityMarked = (
+  event: ActivityMarkEvent,
+  currentNotificationStatus: NotificationStatusResponse | undefined,
+  aggregatedActivities: Array<{ group: string }> = [],
+): UpdateStateResult<{
+  data?: { notification_status: NotificationStatusResponse };
+}> => {
+  if (!currentNotificationStatus) {
+    return {
+      changed: false,
+    };
+  }
+
+  const newState = {
+    ...currentNotificationStatus,
+  };
+
+  if (event.mark_all_read) {
+    const allGroupIds = aggregatedActivities.map((activity) => activity.group);
+    newState.read_activities = [
+      ...new Set([
+        ...(currentNotificationStatus.read_activities ?? []),
+        ...allGroupIds,
+      ]),
+    ];
+  }
+
+  if (event.mark_read && event.mark_read.length > 0) {
+    newState.read_activities = [
+      ...new Set([
+        ...(currentNotificationStatus?.read_activities ?? []),
+        ...event.mark_read,
+      ]),
+    ];
+  }
+
+  if (event.mark_all_seen) {
+    newState.last_seen_at = new Date();
+  }
+
+  return {
+    changed: true,
+    data: { notification_status: newState },
+  };
+};
+
+export function handleActivityMarked(
+  this: Feed,
+  event: EventPayload<'feeds.activity.marked'>,
+) {
+  const result = updateNotificationStatusFromActivityMarked(
+    event,
+    this.currentState.notification_status,
+    this.currentState.aggregated_activities,
+  );
+  if (result.changed) {
+    this.state.partialNext({
+      notification_status: result.data?.notification_status,
+    });
+  }
+}

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

@@ -0,0 +1,60 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleActivityPinned } from './handle-activity-pinned';
+import {
+  generateActivityPinnedEvent,
+  generateActivityPinResponse,
+  generateFeedResponse,
+} from '../../../test-utils/response-generators';
+import { ActivityPinResponse } from '../../../gen/models';
+
+describe(handleActivityPinned.name, () => {
+  let feed: Feed;
+  let client: FeedsClient;
+  let pinnedActivity: ActivityPinResponse;
+  let otherPinnedActivity: ActivityPinResponse;
+
+  beforeEach(() => {
+    client = new FeedsClient('mock-api-key');
+    const feedResponse = generateFeedResponse({ id: 'main', group_id: 'user' });
+    feed = new Feed(
+      client,
+      feedResponse.group_id,
+      feedResponse.id,
+      feedResponse,
+    );
+    pinnedActivity = generateActivityPinResponse();
+    otherPinnedActivity = generateActivityPinResponse();
+    feed.state.next((currentState) => ({
+      ...currentState,
+      pinned_activities: [otherPinnedActivity],
+    }));
+  });
+
+  it('adds a new activity to pinned_activities', () => {
+    const event = generateActivityPinnedEvent({
+      pinned_activity: pinnedActivity,
+    });
+    handleActivityPinned.call(feed, event);
+    const { pinned_activities } = feed.currentState;
+    expect(pinned_activities).toHaveLength(2);
+    expect(pinned_activities![0].activity.id).toBe(pinnedActivity.activity.id);
+    expect(pinned_activities![1]).toBe(otherPinnedActivity);
+  });
+
+  it('creates pinned_activities if it was undefined', () => {
+    feed.state.next((currentState) => ({
+      ...currentState,
+      pinned_activities: undefined,
+    }));
+    const event = generateActivityPinnedEvent({
+      pinned_activity: pinnedActivity,
+    });
+    handleActivityPinned.call(feed, event);
+    const { pinned_activities } = feed.currentState;
+    expect(pinned_activities).toHaveLength(1);
+    expect(pinned_activities![0].activity.id).toBe(pinnedActivity.activity.id);
+  });
+});

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

@@ -0,0 +1,30 @@
+import { ActivityPinResponse } from '../../../gen/models';
+import { EventPayload } from '../../../types-internal';
+import { Feed } from '../../feed';
+
+export function handleActivityPinned(
+  this: Feed,
+  event: EventPayload<'feeds.activity.pinned'>,
+) {
+  this.state.next((currentState) => {
+    const newState = {
+      ...currentState,
+    };
+
+    // FIXME: type mismatch PinActivityResponse vs ActivityPinResponse (almost identical but not quite)
+
+    // re-map the event value to match the ActivityPinResponse type
+    const pinnedActivity: ActivityPinResponse = {
+      ...event.pinned_activity,
+      user: event.user!,
+      feed: event.fid,
+      updated_at: new Date(),
+    };
+
+    newState.pinned_activities = currentState.pinned_activities
+      ? [pinnedActivity, ...currentState.pinned_activities]
+      : [pinnedActivity];
+
+    return newState;
+  });
+}

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

@@ -0,0 +1,157 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleActivityReactionAdded } from './handle-activity-reaction-added';
+import {
+  generateActivityPinResponse,
+  generateActivityResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  generateActivityReactionAddedEvent,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleActivityReactionAdded.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('adds a reaction to the correct activity for current user & updates activities with event.activity', () => {
+    const event = generateActivityReactionAddedEvent({
+      reaction: {
+        user: { id: currentUserId },
+      },
+      activity: {
+        reaction_count: 1,
+      },
+    });
+    const activity = generateActivityResponse({
+      id: event.activity.id,
+      reaction_count: 0,
+    });
+    const activityPin = generateActivityPinResponse({
+      activity: { ...activity },
+    });
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [activityPin],
+    });
+
+    const stateBefore = feed.currentState;
+
+    expect(stateBefore.activities![0].reaction_count).toBe(0);
+    expect(stateBefore.pinned_activities![0].activity.reaction_count).toBe(
+      0,
+    );
+
+    handleActivityReactionAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter.activities![0].own_reactions).toContain(event.reaction);
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toContain(
+      event.reaction,
+    );
+    expect(stateAfter.activities![0].own_bookmarks).toBe(
+      stateBefore.activities![0].own_bookmarks,
+    );
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toBe(
+      stateBefore.pinned_activities![0].activity.own_bookmarks,
+    );
+    expect(stateAfter.activities![0].reaction_count).toBe(1);
+    expect(stateAfter.pinned_activities![0].activity.reaction_count).toBe(1);
+  });
+
+  it('does not add to own_reactions if reaction is from another user but still updates activity', () => {
+    const event = generateActivityReactionAddedEvent({
+      reaction: { user: { id: 'other-user-id' } },
+      activity: {
+        reaction_count: 1,
+      },
+    });
+    const activity = generateActivityResponse({
+      id: event.activity.id,
+      reaction_count: 0,
+    });
+    const activityPin = generateActivityPinResponse({
+      activity: { ...activity },
+    });
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [activityPin],
+    });
+
+    const stateBefore = feed.currentState;
+
+    expect(stateBefore.activities![0].reaction_count).toBe(0);
+    expect(stateBefore.pinned_activities![0].activity.reaction_count).toBe(
+      0,
+    );
+
+    handleActivityReactionAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter.activities![0].own_reactions).toHaveLength(0);
+    expect(
+      stateAfter.pinned_activities![0].activity.own_reactions,
+    ).toHaveLength(0);
+    expect(stateAfter.activities![0].reaction_count).toBe(1);
+    expect(stateAfter.pinned_activities![0].activity.reaction_count).toBe(1);
+    expect(stateAfter.activities![0].own_bookmarks).toBe(
+      stateBefore.activities![0].own_bookmarks,
+    );
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toBe(
+      stateBefore.pinned_activities![0].activity.own_bookmarks,
+    );
+    expect(stateAfter.activities![0].own_reactions).toBe(
+      stateBefore.activities![0].own_reactions,
+    );
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toBe(
+      stateBefore.pinned_activities![0].activity.own_reactions,
+    );
+  });
+
+  it('does nothing if activity is not found', () => {
+    const event = generateActivityReactionAddedEvent({
+      reaction: { user: { id: currentUserId } },
+    });
+    const activity = generateActivityResponse({
+      id: 'unrelated',
+    });
+    const activityPin = generateActivityPinResponse({
+      activity: { ...activity },
+    });
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [activityPin],
+    });
+
+    const stateBefore = feed.currentState;
+
+    handleActivityReactionAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter).toBe(stateBefore);
+  });
+});