@stream-io/feeds-client 0.1.11 → 0.2.1

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

@@ -1,75 +1,113 @@
 import type { Feed } from '../../../feed';
-import type {
+import {
+  ActivityPinResponse,
   ActivityReactionDeletedEvent,
   ActivityResponse,
 } from '../../../gen/models';
-import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+import type { EventPayload } from '../../../types-internal';
+import { updateEntityInArray } from '../../../utils';
 
-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;
+const sharedUpdateActivity = ({
+  currentActivity,
+  event,
+  eventBelongsToCurrentUser,
+}: {
+  currentActivity: ActivityResponse;
+  event: ActivityReactionDeletedEvent;
+  eventBelongsToCurrentUser: boolean;
+}) => {
+  let newOwnReactions = currentActivity.own_reactions;
+
+  if (eventBelongsToCurrentUser) {
+    newOwnReactions = currentActivity.own_reactions.filter(
+      (reaction) =>
+        !(
+          reaction.type === event.reaction.type &&
+          reaction.user.id === event.reaction.user.id
+        ),
+    );
+  }
 
   return {
-    ...activity,
-    own_reactions: ownReactions,
-    latest_reactions: event.activity.latest_reactions,
-    reaction_groups: event.activity.reaction_groups,
-    changed: true,
+    ...event.activity,
+    own_reactions: newOwnReactions,
+    own_bookmarks: currentActivity.own_bookmarks,
   };
 };
 
 export const removeReactionFromActivities = (
   event: ActivityReactionDeletedEvent,
   activities: ActivityResponse[] | undefined,
-  isCurrentUser: boolean,
-): UpdateStateResult<{ activities: ActivityResponse[] }> => {
-  if (!activities) {
-    return { changed: false, activities: [] };
-  }
+  eventBelongsToCurrentUser: boolean,
+) =>
+  updateEntityInArray({
+    entities: activities,
+    matcher: (activity) => activity.id === event.activity.id,
+    updater: (matchedActivity) =>
+      sharedUpdateActivity({
+        currentActivity: matchedActivity,
+        event,
+        eventBelongsToCurrentUser,
+      }),
+  });
 
-  const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
-  if (activityIndex === -1) {
-    return { changed: false, activities };
-  }
+export const removeReactionFromPinnedActivities = (
+  event: ActivityReactionDeletedEvent,
+  activities: ActivityPinResponse[] | undefined,
+  eventBelongsToCurrentUser: boolean,
+) =>
+  updateEntityInArray({
+    entities: activities,
+    matcher: (pinnedActivity) =>
+      pinnedActivity.activity.id === event.activity.id,
+    updater: (matchedPinnedActivity) => {
+      const newActivity = sharedUpdateActivity({
+        currentActivity: matchedPinnedActivity.activity,
+        event,
+        eventBelongsToCurrentUser,
+      });
 
-  const activity = activities[activityIndex];
-  const updatedActivity = removeReactionFromActivity(
-    event,
-    activity,
-    isCurrentUser,
-  );
-  return updateActivityInState(updatedActivity, activities, true);
-};
+      if (newActivity === matchedPinnedActivity.activity) {
+        return matchedPinnedActivity;
+      }
+
+      return {
+        ...matchedPinnedActivity,
+        activity: newActivity,
+      };
+    },
+  });
 
 export function handleActivityReactionDeleted(
   this: Feed,
   event: EventPayload<'feeds.activity.reaction.deleted'>,
 ) {
-  const currentActivities = this.currentState.activities;
+  const {
+    activities: currentActivities,
+    pinned_activities: currentPinnedActivities,
+  } = this.currentState;
   const connectedUser = this.client.state.getLatestValue().connected_user;
-  const isCurrentUser = Boolean(
-    connectedUser && event.reaction.user.id === connectedUser.id,
-  );
+  const eventBelongsToCurrentUser =
+    typeof connectedUser !== 'undefined' &&
+    event.reaction.user.id === connectedUser.id;
+
+  const [result1, result2] = [
+    removeReactionFromActivities(
+      event,
+      currentActivities,
+      eventBelongsToCurrentUser,
+    ),
+    removeReactionFromPinnedActivities(
+      event,
+      currentPinnedActivities,
+      eventBelongsToCurrentUser,
+    ),
+  ];
 
-  const result = removeReactionFromActivities(
-    event,
-    currentActivities,
-    isCurrentUser,
-  );
-  if (result.changed) {
-    this.state.partialNext({ activities: result.activities });
+  if (result1.changed || result2.changed) {
+    this.state.partialNext({
+      activities: result1.entities,
+      pinned_activities: result2.entities,
+    });
   }
 }

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

@@ -0,0 +1,94 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleActivityUnpinned } from './handle-activity-unpinned';
+import {
+  generateActivityPinResponse,
+  generateFeedResponse,
+} from '../../../test-utils/response-generators';
+import { ActivityPinResponse } from '../../../gen/models';
+import { EventPayload } from '../../../types-internal';
+
+// Helper to construct the event payload for 'feeds.activity.unpinned'
+function makeUnpinnedEvent(
+  pinnedActivity: ActivityPinResponse,
+): EventPayload<'feeds.activity.unpinned'> {
+  return {
+    type: 'feeds.activity.unpinned',
+    created_at: pinnedActivity.created_at,
+    fid: pinnedActivity.feed,
+    custom: {},
+    pinned_activity: {
+      created_at: pinnedActivity.created_at,
+      duration: '0',
+      fid: pinnedActivity.feed,
+      user_id: pinnedActivity.user.id,
+      activity: pinnedActivity.activity,
+    },
+    user: pinnedActivity.user,
+  };
+}
+
+describe(handleActivityUnpinned.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: [pinnedActivity, otherPinnedActivity],
+    }));
+  });
+
+  it('removes the correct activity from pinned_activities', () => {
+    const event = makeUnpinnedEvent(pinnedActivity);
+    handleActivityUnpinned.call(feed, event);
+    const { pinned_activities } = feed.currentState;
+    expect(pinned_activities).toHaveLength(1);
+    expect(pinned_activities![0]).toBe(otherPinnedActivity);
+  });
+
+  it('does nothing if the activity is not found', () => {
+    const unrelatedActivity = generateActivityPinResponse();
+    const event = makeUnpinnedEvent(unrelatedActivity);
+    const stateBefore = feed.currentState;
+    handleActivityUnpinned.call(feed, event);
+    const stateAfter = feed.currentState;
+    expect(stateAfter.pinned_activities).toEqual(stateBefore.pinned_activities);
+  });
+
+  it('does nothing if pinned_activities is empty', () => {
+    feed.state.next((currentState) => ({
+      ...currentState,
+      pinned_activities: [],
+    }));
+    const event = makeUnpinnedEvent(pinnedActivity);
+    handleActivityUnpinned.call(feed, event);
+    const stateAfter = feed.currentState;
+    expect(stateAfter.pinned_activities).toEqual([]);
+  });
+
+  it('does nothing if pinned_activities is undefined', () => {
+    feed.state.next((currentState) => ({
+      ...currentState,
+      pinned_activities: undefined,
+    }));
+    const event = makeUnpinnedEvent(pinnedActivity);
+    handleActivityUnpinned.call(feed, event);
+    const stateAfter = feed.currentState;
+    expect(stateAfter.pinned_activities).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,30 @@
+import { EventPayload } from '../../../types-internal';
+import { Feed, FeedState } from '../../feed';
+
+export function handleActivityUnpinned(
+  this: Feed,
+  event: EventPayload<'feeds.activity.unpinned'>,
+) {
+  this.state.next((currentState) => {
+    let newState: FeedState | undefined;
+
+    const index =
+      currentState.pinned_activities?.findIndex(
+        (pinnedActivity) =>
+          pinnedActivity.activity.id === event.pinned_activity.activity.id,
+      ) ?? -1;
+
+    if (index >= 0) {
+      newState ??= {
+        ...currentState,
+      };
+
+      const newPinnedActivities = [...currentState.pinned_activities!];
+      newPinnedActivities.splice(index, 1);
+
+      newState.pinned_activities = newPinnedActivities;
+    }
+
+    return newState ?? currentState;
+  });
+}

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

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleActivityUpdated } from './handle-activity-updated';
+import {
+  generateActivityPinResponse,
+  generateActivityResponse,
+  generateActivityUpdatedEvent,
+  generateBookmarkResponse,
+  generateFeedReactionResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleActivityUpdated.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 the correct activity in state when event matches, preserves own_reactions & own_bookmarks', () => {
+    const activity = generateActivityResponse({
+      id: 'activity-1',
+      text: 'original text',
+      own_reactions: [generateFeedReactionResponse()],
+      own_bookmarks: [generateBookmarkResponse()],
+    });
+
+    const activityPin = generateActivityPinResponse({
+      activity: { ...activity },
+    });
+
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [activityPin],
+    });
+
+    const event = generateActivityUpdatedEvent({
+      activity: {
+        ...activity,
+        text: 'updated text',
+        own_reactions: [],
+        own_bookmarks: [],
+      },
+    });
+
+    const stateBefore = feed.currentState;
+
+    handleActivityUpdated.call(feed, event);
+
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter.activities![0]).toMatchObject({
+      id: 'activity-1',
+      text: 'updated text',
+    });
+    expect(stateAfter.pinned_activities![0].activity).toMatchObject({
+      id: 'activity-1',
+      text: 'updated text',
+    });
+    expect(stateAfter.activities![0].own_reactions).toEqual(
+      stateBefore.activities![0].own_reactions,
+    );
+    expect(stateAfter.activities![0].own_bookmarks).toEqual(
+      stateBefore.activities![0].own_bookmarks,
+    );
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toEqual(
+      stateBefore.pinned_activities![0].activity.own_reactions,
+    );
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toEqual(
+      stateBefore.pinned_activities![0].activity.own_bookmarks,
+    );
+  });
+
+  it('does nothing if activity is not found in activities or pinned_activities', () => {
+    const activity = generateActivityResponse({});
+    const activityPin = generateActivityPinResponse({
+      activity: { ...activity },
+    });
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [activityPin],
+    });
+
+    const event = generateActivityUpdatedEvent({
+      activity: {
+        id: 'not-found-id',
+      },
+    });
+
+    const stateBefore = feed.currentState;
+    handleActivityUpdated.call(feed, event);
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+});

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

@@ -1,47 +1,85 @@
 import { Feed } from '../../../feed';
-import { ActivityResponse } from '../../../gen/models';
+import {
+  ActivityPinResponse,
+  ActivityResponse,
+  ActivityUpdatedEvent,
+} from '../../../gen/models';
 import { EventPayload } from '../../../types-internal';
+import { updateEntityInArray } from '../../../utils';
+
+const sharedUpdateActivity = ({
+  currentActivity,
+  event,
+}: {
+  currentActivity: ActivityResponse;
+  event: ActivityUpdatedEvent;
+}) => {
+  return {
+    ...event.activity,
+    own_reactions: currentActivity.own_reactions,
+    own_bookmarks: currentActivity.own_bookmarks,
+  };
+};
 
 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,
-      };
-    }
+  event: ActivityUpdatedEvent,
+  activities: ActivityResponse[] | undefined,
+) =>
+  updateEntityInArray({
+    entities: activities,
+    matcher: (activity) => activity.id === event.activity.id,
+    updater: (matchedActivity) =>
+      sharedUpdateActivity({
+        currentActivity: matchedActivity,
+        event,
+      }),
+  });
 
-    return { changed: true, activities: newActivities };
-  } else {
-    return { changed: false, activities };
-  }
-};
+export const updatePinnedActivityInState = (
+  event: ActivityUpdatedEvent,
+  pinnedActivities: ActivityPinResponse[] | undefined,
+) =>
+  updateEntityInArray({
+    entities: pinnedActivities,
+    matcher: (pinnedActivity) =>
+      pinnedActivity.activity.id === event.activity.id,
+    updater: (matchedPinnedActivity) => {
+      const newActivity = sharedUpdateActivity({
+        currentActivity: matchedPinnedActivity.activity,
+        event,
+      });
+
+      if (newActivity === matchedPinnedActivity.activity) {
+        return matchedPinnedActivity;
+      }
+
+      return {
+        ...matchedPinnedActivity,
+        activity: newActivity,
+      };
+    },
+  });
 
 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 });
-    }
+  const {
+    activities: currentActivities,
+    pinned_activities: currentPinnedActivities,
+  } = this.currentState;
+
+  const [result1, result2] = [
+    updateActivityInState(event, currentActivities),
+    updatePinnedActivityInState(event, currentPinnedActivities),
+  ];
+
+  if (result1.changed || result2.changed) {
+    this.client.hydratePollCache([event.activity]);
+
+    this.state.partialNext({
+      activities: result1.entities,
+      pinned_activities: result2.entities,
+    });
   }
 }