@stream-io/feeds-client 0.2.13 → 0.2.15

package/src/feed/event-handlers/{notification-feed/handle-notification-feed-updated.test.ts → aggregated-feed/handle-aggregated-feed-updated.test.ts}

@@ -8,7 +8,7 @@ import {
   updateNotificationFeedFromEvent,
   addAggregatedActivitiesToState,
   updateNotificationStatus,
-} from './handle-notification-feed-updated';
+} from './handle-aggregated-feed-updated';
 
 const createMockNotificationFeedUpdatedEvent = (
   overrides: Partial<NotificationFeedUpdatedEvent> = {},
@@ -389,6 +389,232 @@ describe('notification-feed-utils', () => {
         ...newActivities,
       ]);
     });
+
+    describe('replace position', () => {
+      it('should replace existing activities with same group', () => {
+        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,
+            updated_at: baseDate,
+          }),
+        ];
+        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,
+            updated_at: new Date('2023-01-02'),
+          }),
+        ];
+
+        const result = addAggregatedActivitiesToState(
+          newActivities,
+          existingActivities,
+          'replace',
+        );
+
+        expect(result.changed).toBe(true);
+        expect(result.aggregated_activities).toHaveLength(3);
+
+        // Check that group1 was replaced
+        const replacedGroup1 = result.aggregated_activities.find(
+          (a) => a.group === 'group1',
+        );
+        expect(replacedGroup1?.activity_count).toBe(3);
+        expect(replacedGroup1?.score).toBe(30);
+        expect(replacedGroup1?.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);
+        expect(unchangedGroup2?.updated_at).toEqual(baseDate);
+
+        // 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);
+        expect(newGroup3?.updated_at).toEqual(new Date('2023-01-02'));
+      });
+
+      it('should preserve order of existing activities when replacing', () => {
+        const existingActivities = [
+          createMockAggregatedActivity({ group: 'group1', activity_count: 1 }),
+          createMockAggregatedActivity({ group: 'group2', activity_count: 2 }),
+          createMockAggregatedActivity({ group: 'group3', activity_count: 3 }),
+        ];
+        const newActivities = [
+          createMockAggregatedActivity({ group: 'group2', activity_count: 20 }),
+          createMockAggregatedActivity({ group: 'group1', activity_count: 10 }),
+        ];
+
+        const result = addAggregatedActivitiesToState(
+          newActivities,
+          existingActivities,
+          'replace',
+        );
+
+        expect(result.changed).toBe(true);
+        expect(result.aggregated_activities).toHaveLength(3);
+
+        // Check that order is preserved
+        expect(result.aggregated_activities[0].group).toBe('group1');
+        expect(result.aggregated_activities[0].activity_count).toBe(10);
+        expect(result.aggregated_activities[1].group).toBe('group2');
+        expect(result.aggregated_activities[1].activity_count).toBe(20);
+        expect(result.aggregated_activities[2].group).toBe('group3');
+        expect(result.aggregated_activities[2].activity_count).toBe(3);
+      });
+
+      it('should add new activities at the end when replacing', () => {
+        const existingActivities = [
+          createMockAggregatedActivity({ group: 'group1', activity_count: 1 }),
+          createMockAggregatedActivity({ group: 'group2', activity_count: 2 }),
+        ];
+        const newActivities = [
+          createMockAggregatedActivity({ group: 'group1', activity_count: 10 }),
+          createMockAggregatedActivity({ group: 'group3', activity_count: 3 }),
+          createMockAggregatedActivity({ group: 'group4', activity_count: 4 }),
+        ];
+
+        const result = addAggregatedActivitiesToState(
+          newActivities,
+          existingActivities,
+          'replace',
+        );
+
+        expect(result.changed).toBe(true);
+        expect(result.aggregated_activities).toHaveLength(4);
+
+        // Check that existing activities are in their original positions
+        expect(result.aggregated_activities[0].group).toBe('group1');
+        expect(result.aggregated_activities[0].activity_count).toBe(10);
+        expect(result.aggregated_activities[1].group).toBe('group2');
+        expect(result.aggregated_activities[1].activity_count).toBe(2);
+
+        // Check that new activities are added at the end
+        expect(result.aggregated_activities[2].group).toBe('group3');
+        expect(result.aggregated_activities[2].activity_count).toBe(3);
+        expect(result.aggregated_activities[3].group).toBe('group4');
+        expect(result.aggregated_activities[3].activity_count).toBe(4);
+      });
+
+      it('should handle empty new activities', () => {
+        const existingActivities = [
+          createMockAggregatedActivity({ group: 'group1', activity_count: 1 }),
+          createMockAggregatedActivity({ group: 'group2', activity_count: 2 }),
+        ];
+
+        const result = addAggregatedActivitiesToState(
+          [],
+          existingActivities,
+          'replace',
+        );
+
+        expect(result.changed).toBe(false);
+        expect(result.aggregated_activities).toStrictEqual(existingActivities);
+      });
+
+      it('should handle both arrays being empty', () => {
+        const result = addAggregatedActivitiesToState([], [], 'replace');
+
+        expect(result.changed).toBe(false);
+        expect(result.aggregated_activities).toStrictEqual([]);
+      });
+
+      it('should replace multiple activities with same groups', () => {
+        const existingActivities = [
+          createMockAggregatedActivity({
+            group: 'group1',
+            activity_count: 1,
+            score: 10,
+          }),
+          createMockAggregatedActivity({
+            group: 'group2',
+            activity_count: 2,
+            score: 20,
+          }),
+          createMockAggregatedActivity({
+            group: 'group3',
+            activity_count: 3,
+            score: 30,
+          }),
+        ];
+        const newActivities = [
+          createMockAggregatedActivity({
+            group: 'group1',
+            activity_count: 10,
+            score: 100,
+          }),
+          createMockAggregatedActivity({
+            group: 'group3',
+            activity_count: 30,
+            score: 300,
+          }),
+          createMockAggregatedActivity({
+            group: 'group4',
+            activity_count: 4,
+            score: 40,
+          }),
+        ];
+
+        const result = addAggregatedActivitiesToState(
+          newActivities,
+          existingActivities,
+          'replace',
+        );
+
+        expect(result.changed).toBe(true);
+        expect(result.aggregated_activities).toHaveLength(4);
+
+        // Check that group1 was replaced
+        const replacedGroup1 = result.aggregated_activities.find(
+          (a) => a.group === 'group1',
+        );
+        expect(replacedGroup1?.activity_count).toBe(10);
+        expect(replacedGroup1?.score).toBe(100);
+
+        // 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 replaced
+        const replacedGroup3 = result.aggregated_activities.find(
+          (a) => a.group === 'group3',
+        );
+        expect(replacedGroup3?.activity_count).toBe(30);
+        expect(replacedGroup3?.score).toBe(300);
+
+        // Check that group4 was added
+        const newGroup4 = result.aggregated_activities.find(
+          (a) => a.group === 'group4',
+        );
+        expect(newGroup4?.activity_count).toBe(4);
+        expect(newGroup4?.score).toBe(40);
+      });
+    });
   });
 
   describe('updateNotificationStatus', () => {

package/src/feed/event-handlers/{notification-feed/handle-notification-feed-updated.ts → aggregated-feed/handle-aggregated-feed-updated.ts}

@@ -1,16 +1,17 @@
-import type { Feed } from '../../../feed';
+import type { Feed } from '../..';
 import type {
   AggregatedActivityResponse,
   NotificationFeedUpdatedEvent,
   NotificationStatusResponse,
+  StoriesFeedUpdatedEvent,
 } from '../../../gen/models';
 import type { EventPayload, UpdateStateResult } from '../../../types-internal';
-import { uniqueArrayMerge } from '../../../utils';
+import { replaceUniqueArrayMerge, uniqueArrayMerge } from '../../../utils';
 
 export const addAggregatedActivitiesToState = (
   newAggregatedActivities: AggregatedActivityResponse[],
   aggregatedActivities: AggregatedActivityResponse[] | undefined,
-  position: 'start' | 'end',
+  position: 'start' | 'end' | 'replace',
 ) => {
   let result: UpdateStateResult<{
     aggregated_activities: AggregatedActivityResponse[];
@@ -27,18 +28,29 @@ export const addAggregatedActivitiesToState = (
     };
   }
 
-  result.aggregated_activities =
-    position === 'start'
-      ? uniqueArrayMerge(
-          newAggregatedActivities,
-          aggregatedActivities ?? [],
-          (a) => a.group,
-        )
-      : uniqueArrayMerge(
-          aggregatedActivities ?? [],
-          newAggregatedActivities,
-          (a) => a.group,
-        );
+  switch (position) {
+    case 'start':
+      result.aggregated_activities = uniqueArrayMerge(
+        newAggregatedActivities,
+        aggregatedActivities ?? [],
+        (a) => a.group,
+      );
+      break;
+    case 'end':
+      result.aggregated_activities = uniqueArrayMerge(
+        aggregatedActivities ?? [],
+        newAggregatedActivities,
+        (a) => a.group,
+      );
+      break;
+    case 'replace':
+      result.aggregated_activities = replaceUniqueArrayMerge(
+        aggregatedActivities ?? [],
+        newAggregatedActivities,
+        (a) => a.group,
+      );
+      break;
+  }
 
   return result;
 };
@@ -135,3 +147,47 @@ export function handleNotificationFeedUpdated(
     });
   }
 }
+
+export function updateStoriesFeedFromEvent(
+  aggregatedActivities: AggregatedActivityResponse[] | undefined,
+  event: StoriesFeedUpdatedEvent,
+): UpdateStateResult<{
+  data?: {
+    aggregated_activities?: AggregatedActivityResponse[];
+  };
+}> {
+  if (!aggregatedActivities) {
+    return {
+      changed: false,
+    };
+  }
+
+  if (event.aggregated_activities) {
+    const result = addAggregatedActivitiesToState(
+      event.aggregated_activities,
+      aggregatedActivities,
+      'replace',
+    );
+
+    return result;
+  }
+
+  return {
+    changed: false,
+  };
+}
+
+export function handleStoriesFeedUpdated(
+  this: Feed,
+  event: EventPayload<'feeds.stories_feed.updated'>,
+) {
+  const result = updateStoriesFeedFromEvent(
+    this.currentState.aggregated_activities,
+    event,
+  );
+  if (result.changed) {
+    this.state.partialNext({
+      aggregated_activities: result.data?.aggregated_activities,
+    });
+  }
+}

package/src/feed/event-handlers/aggregated-feed/index.ts

@@ -0,0 +1 @@
+export * from './handle-aggregated-feed-updated';

package/src/feed/event-handlers/index.ts

@@ -4,5 +4,5 @@ export * from './feed-member';
 export * from './bookmark';
 export * from './activity';
 export * from './feed';
-export * from './notification-feed';
+export * from './aggregated-feed';
 export * from './watch';

package/src/feed/feed.ts

@@ -46,6 +46,7 @@ import {
   handleCommentReactionDeleted,
   addAggregatedActivitiesToState,
   updateNotificationStatus,
+  handleStoriesFeedUpdated,
 } from './event-handlers';
 import { capitalize } from '../common/utils';
 import type {
@@ -177,6 +178,7 @@ export class Feed extends FeedApi {
     'feeds.feed_member.removed': handleFeedMemberRemoved.bind(this),
     'feeds.feed_member.updated': handleFeedMemberUpdated.bind(this),
     'feeds.notification_feed.updated': handleNotificationFeedUpdated.bind(this),
+    'feeds.stories_feed.updated': handleStoriesFeedUpdated.bind(this),
     // the poll events should be removed from here
     'feeds.poll.closed': Feed.noop,
     'feeds.poll.deleted': Feed.noop,

package/src/feeds-client/feeds-client.ts

@@ -65,11 +65,8 @@ import {
   handleWatchStopped,
 } from '../feed';
 import { handleUserUpdated } from './event-handlers';
-import type {
-  SyncFailure} from '../common/real-time/event-models';
-import {
-  UnhandledErrorType,
-} from '../common/real-time/event-models';
+import type { SyncFailure } from '../common/real-time/event-models';
+import { UnhandledErrorType } from '../common/real-time/event-models';
 import { updateCommentCount } from '../feed/event-handlers/comment/utils';
 import { configureLoggers } from '../utils/logger';
 
@@ -415,18 +412,29 @@ export class FeedsClient extends FeedsApi {
     return response;
   };
 
-  addReaction = async (
+  addActivityReaction = async (
     request: AddReactionRequest & {
       activity_id: string;
     },
   ) => {
-    const response = await super.addReaction(request);
+    const response = await super.addActivityReaction(request);
     for (const feed of Object.values(this.activeFeeds)) {
       handleActivityReactionAdded.bind(feed)(response, false);
     }
     return response;
   };
 
+  /**
+   * @deprecated Use addActivityReaction instead
+   */
+  addReaction = (
+    request: AddReactionRequest & {
+      activity_id: string;
+    },
+  ) => {
+    return this.addActivityReaction(request);
+  };
+
   deleteActivityReaction = async (request: {
     activity_id: string;
     type: string;

package/src/gen/feeds/FeedsApi.ts

@@ -571,7 +571,7 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
-  async addReaction(
+  async addActivityReaction(
     request: AddReactionRequest & { activity_id: string },
   ): Promise<StreamResponse<AddReactionResponse>> {
     const pathParams = {
@@ -888,9 +888,9 @@ export class FeedsApi {
     request: AddCommentRequest,
   ): Promise<StreamResponse<AddCommentResponse>> {
     const body = {
-      comment: request?.comment,
       object_id: request?.object_id,
       object_type: request?.object_type,
+      comment: request?.comment,
       create_notification_activity: request?.create_notification_activity,
       parent_id: request?.parent_id,
       skip_push: request?.skip_push,

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

@@ -1739,6 +1739,20 @@ decoders.SingleFollowResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.StoriesFeedUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    aggregated_activities: {
+      type: 'AggregatedActivityResponse',
+      isSingle: false,
+    },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.SubmitActionResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     item: { type: 'ReviewQueueItemResponse', isSingle: true },

package/src/gen/model-decoders/event-decoder-mapping.ts

@@ -124,6 +124,9 @@ const eventDecoderMapping: Record<
   'feeds.poll.vote_removed': (data: Record<string, any>) =>
     decoders.PollVoteRemovedFeedEvent(data),
 
+  'feeds.stories_feed.updated': (data: Record<string, any>) =>
+    decoders.StoriesFeedUpdatedEvent(data),
+
   'health.check': (data: Record<string, any>) =>
     decoders.HealthCheckEvent(data),
 

package/src/gen/models/index.ts

@@ -463,6 +463,8 @@ export interface ActivityResponse {
 
   hidden?: boolean;
 
+  is_watched?: boolean;
+
   text?: string;
 
   visibility_tag?: string;
@@ -680,6 +682,8 @@ export interface AggregatedActivityResponse {
   user_count_truncated: boolean;
 
   activities: ActivityResponse[];
+
+  is_watched?: boolean;
 }
 
 export interface AggregationConfig {
@@ -5548,9 +5552,27 @@ export interface SpeechSegmentConfig {
 }
 
 export interface StoriesConfig {
-  expiration_behaviour?: 'hide_for_everyone' | 'visible_for_author';
-
   skip_watched?: boolean;
+
+  track_watched?: boolean;
+}
+
+export interface StoriesFeedUpdatedEvent {
+  created_at: Date;
+
+  fid: string;
+
+  custom: Record<string, any>;
+
+  type: string;
+
+  feed_visibility?: string;
+
+  received_at?: Date;
+
+  aggregated_activities?: AggregatedActivityResponse[];
+
+  user?: UserResponseCommonFields;
 }
 
 export interface SubmitActionRequest {
@@ -6571,6 +6593,7 @@ export type WSClientEvent =
   | ({ type: 'feeds.poll.vote_casted' } & PollVoteCastedFeedEvent)
   | ({ type: 'feeds.poll.vote_changed' } & PollVoteChangedFeedEvent)
   | ({ type: 'feeds.poll.vote_removed' } & PollVoteRemovedFeedEvent)
+  | ({ type: 'feeds.stories_feed.updated' } & StoriesFeedUpdatedEvent)
   | ({ type: 'health.check' } & HealthCheckEvent)
   | ({ type: 'user.updated' } & UserUpdatedEvent);
 
@@ -6617,6 +6640,7 @@ export type WSEvent =
   | ({ type: 'feeds.poll.vote_casted' } & PollVoteCastedFeedEvent)
   | ({ type: 'feeds.poll.vote_changed' } & PollVoteChangedFeedEvent)
   | ({ type: 'feeds.poll.vote_removed' } & PollVoteRemovedFeedEvent)
+  | ({ type: 'feeds.stories_feed.updated' } & StoriesFeedUpdatedEvent)
   | ({ type: 'health.check' } & HealthCheckEvent)
   | ({ type: 'moderation.custom_action' } & ModerationCustomActionEvent)
   | ({ type: 'moderation.flagged' } & ModerationFlaggedEvent)

package/src/utils/unique-array-merge.ts

@@ -17,3 +17,33 @@ export const uniqueArrayMerge = <T>(
 
   return existingArray.concat(filteredArrayToMerge);
 };
+
+export const replaceUniqueArrayMerge = <T>(
+  existingArray: T[],
+  arrayToMerge: T[],
+  getKey: (v: T) => string,
+) => {
+  const existingMap = new Map<string, T>();
+  (existingArray ?? []).forEach((item) => {
+    existingMap.set(getKey(item), item);
+  });
+
+  const result: T[] = [];
+  arrayToMerge.forEach((item) => {
+    existingMap.set(getKey(item), item);
+  });
+
+  existingArray.forEach((originalItem) => {
+    const updatedItem = existingMap.get(getKey(originalItem));
+    if (updatedItem) {
+      result.push(updatedItem);
+      existingMap.delete(getKey(originalItem));
+    }
+  });
+
+  existingMap.forEach((item) => {
+    result.push(item);
+  });
+
+  return result;
+};