@stream-io/feeds-client 0.2.17 → 0.2.18

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

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest';
+import {
+  updateNotificationFeedFromEvent,
+  updateNotificationStatus,
+} from './handle-notification-feed-updated';
+import {
+  createMockAggregatedActivity,
+  createMockNotificationFeedUpdatedEvent,
+  createMockNotificationStatus,
+} from '../../../test-utils';
+
+describe('notification-feed-utils', () => {
+  describe('updateNotificationFeedFromEvent', () => {
+    it('should return unchanged if event has no notification_status or aggregated_activities', () => {
+      const event = createMockNotificationFeedUpdatedEvent();
+
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(false);
+    });
+
+    it(`should update notification_status when event has notification_status and currentNotificationStatus is undefined`, () => {
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: createMockNotificationStatus(),
+      });
+      const result = updateNotificationFeedFromEvent(event, [], undefined);
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toStrictEqual(
+        event.notification_status,
+      );
+    });
+
+    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);
+    });
+
+    it('should update notification_status when event has notification_status', () => {
+      const notificationStatus = createMockNotificationStatus({
+        unread: 5,
+        unseen: 3,
+        read_activities: ['activity1', 'activity2'],
+        seen_activities: [],
+      });
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: notificationStatus,
+      });
+
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toStrictEqual(
+        notificationStatus,
+      );
+      expect(result.data?.aggregated_activities).toBeUndefined();
+    });
+
+    it('should update aggregated_activities when event has aggregated_activities', () => {
+      const aggregatedActivities = [
+        createMockAggregatedActivity({ group: 'group1' }),
+        createMockAggregatedActivity({ group: 'group2' }),
+      ];
+      const event = createMockNotificationFeedUpdatedEvent({
+        aggregated_activities: aggregatedActivities,
+      });
+
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.aggregated_activities).toStrictEqual(
+        aggregatedActivities,
+      );
+      expect(result.data?.notification_status).toBeUndefined();
+    });
+
+    it('should update both notification_status and aggregated_activities when event has both', () => {
+      const notificationStatus = createMockNotificationStatus({
+        unread: 2,
+        unseen: 1,
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity({ group: 'group1' }),
+      ];
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: notificationStatus,
+        aggregated_activities: aggregatedActivities,
+      });
+
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(true);
+      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', () => {
+      const notificationStatus = createMockNotificationStatus({
+        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, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toStrictEqual(
+        notificationStatus,
+      );
+    });
+  });
+
+  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/{aggregated-feed/handle-aggregated-feed-updated.ts → notification-feed/handle-notification-feed-updated.ts}

@@ -3,57 +3,9 @@ import type {
   AggregatedActivityResponse,
   NotificationFeedUpdatedEvent,
   NotificationStatusResponse,
-  StoriesFeedUpdatedEvent,
 } from '../../../gen/models';
 import type { EventPayload, UpdateStateResult } from '../../../types-internal';
-import { replaceUniqueArrayMerge, uniqueArrayMerge } from '../../../utils';
-
-export const addAggregatedActivitiesToState = (
-  newAggregatedActivities: AggregatedActivityResponse[],
-  aggregatedActivities: AggregatedActivityResponse[] | undefined,
-  position: 'start' | 'end' | 'replace',
-) => {
-  let result: UpdateStateResult<{
-    aggregated_activities: AggregatedActivityResponse[];
-  }>;
-  if (newAggregatedActivities.length === 0) {
-    result = {
-      changed: false,
-      aggregated_activities: [],
-    };
-  } else {
-    result = {
-      changed: true,
-      aggregated_activities: [],
-    };
-  }
-
-  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;
-};
+import { addAggregatedActivitiesToState } from '../add-aggregated-activities-to-state';
 
 export const updateNotificationStatus = (
   newNotificationStatus?: NotificationStatusResponse,
@@ -94,7 +46,7 @@ export const updateNotificationFeedFromEvent = (
     aggregated_activities?: AggregatedActivityResponse[];
   } = {};
 
-  if (event.notification_status && currentNotificationStatus) {
+  if (event.notification_status) {
     const notificationStatusResult = updateNotificationStatus(
       event.notification_status,
       currentNotificationStatus,
@@ -147,47 +99,3 @@ 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/notification-feed/index.ts

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

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

@@ -0,0 +1,45 @@
+import {
+  generateActivityResponse,
+  generateFeedReactionResponse,
+} from '../../../test-utils';
+import { updateActivities } from './handle-story-feeds-updated';
+import { describe, expect, it } from 'vitest';
+
+describe('updateActivities', () => {
+  it('should return unchanged if new activities is empty', () => {
+    const currentActivities = [generateActivityResponse({ id: 'activity1' })];
+    const result = updateActivities([], currentActivities);
+    expect(result.changed).toBe(false);
+  });
+
+  it('should return unchanged if current activities is undefined', () => {
+    const newActivities = [generateActivityResponse({ id: 'activity1' })];
+    const result = updateActivities(newActivities, undefined);
+    expect(result.changed).toBe(false);
+  });
+
+  it('should update existing activities, ignore new ones', () => {
+    const newActivities = [
+      generateActivityResponse({ id: 'activity1', is_watched: true }),
+      generateActivityResponse({ id: 'activity3' }),
+    ];
+    const currentActivities = [
+      generateActivityResponse({
+        id: 'activity1',
+        own_reactions: [generateFeedReactionResponse({ type: 'like' })],
+      }),
+      generateActivityResponse({
+        id: 'activity2',
+      }),
+    ];
+
+    const result = updateActivities(newActivities, currentActivities);
+
+    expect(result.changed).toBe(true);
+    expect(result.activities).toHaveLength(2);
+    expect(result.activities[0].own_reactions).toHaveLength(1);
+    expect(result.activities[0].own_reactions[0].type).toBe('like');
+    expect(result.activities[0].is_watched).toBe(true);
+    expect(result.activities[1].id).toBe('activity2');
+  });
+});

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

@@ -0,0 +1,122 @@
+import type {
+  ActivityResponse,
+  AggregatedActivityResponse,
+  StoriesFeedUpdatedEvent,
+} from '../../../gen/models';
+import type { UpdateStateResult, EventPayload } from '../../../types-internal';
+import type { Feed } from '../../feed';
+import { updateActivity } from '../activity-updater';
+import { addAggregatedActivitiesToState } from '../add-aggregated-activities-to-state';
+
+export const updateActivities = (
+  activitiesToUpsert: ActivityResponse[],
+  currentActivities: ActivityResponse[] | undefined,
+) => {
+  if (
+    !activitiesToUpsert ||
+    activitiesToUpsert.length === 0 ||
+    !currentActivities
+  ) {
+    return {
+      changed: false,
+      activities: currentActivities ?? [],
+    };
+  }
+
+  const result: ActivityResponse[] = [];
+  for (let i = 0; i < currentActivities.length; i++) {
+    const activity = currentActivities[i];
+    const updatedActivity = activitiesToUpsert.find(
+      (a) => a.id === activity.id,
+    );
+    if (updatedActivity) {
+      result.push(
+        updateActivity({
+          currentActivity: activity,
+          newActivtiy: updatedActivity,
+        }),
+      );
+    } else {
+      result.push(activity);
+    }
+  }
+
+  return {
+    changed: true,
+    activities: result,
+  };
+};
+
+export function updateStoriesFeedFromEvent(
+  aggregatedActivities: AggregatedActivityResponse[] | undefined,
+  activities: ActivityResponse[] | undefined,
+  event: StoriesFeedUpdatedEvent,
+): UpdateStateResult<{
+  data?: {
+    aggregated_activities?: AggregatedActivityResponse[];
+    activities?: ActivityResponse[];
+  };
+}> {
+  if (
+    (!aggregatedActivities &&
+      event.aggregated_activities &&
+      event.aggregated_activities?.length > 0) ||
+    (!activities && event.activities && event.activities?.length > 0)
+  ) {
+    return {
+      changed: false,
+    };
+  }
+
+  const result = {
+    changed: true,
+    data: {
+      aggregated_activities: aggregatedActivities,
+      activities: activities,
+    },
+  };
+  if (event.aggregated_activities) {
+    const aggregatedActivitiesResult = addAggregatedActivitiesToState(
+      event.aggregated_activities,
+      aggregatedActivities,
+      'replace',
+    );
+
+    if (aggregatedActivitiesResult.changed) {
+      result.data.aggregated_activities =
+        aggregatedActivitiesResult.aggregated_activities;
+    }
+  }
+
+  if (event.activities) {
+    const activitiesResult = updateActivities(event.activities, activities);
+    if (activitiesResult.changed) {
+      result.data.activities = activitiesResult.activities;
+    }
+  }
+
+  if (event.aggregated_activities || event.activities) {
+    return result;
+  }
+
+  return {
+    changed: false,
+  };
+}
+
+export function handleStoriesFeedUpdated(
+  this: Feed,
+  event: EventPayload<'feeds.stories_feed.updated'>,
+) {
+  const result = updateStoriesFeedFromEvent(
+    this.currentState.aggregated_activities,
+    this.currentState.activities,
+    event,
+  );
+  if (result.changed) {
+    this.state.partialNext({
+      aggregated_activities: result.data?.aggregated_activities,
+      activities: result.data?.activities,
+    });
+  }
+}

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

@@ -0,0 +1 @@
+export * from './handle-story-feeds-updated';

package/src/feed/feed.ts

@@ -131,6 +131,12 @@ export type FeedState = Omit<
    * `true` if the feed is receiving real-time updates via WebSocket
    */
   watch: boolean;
+
+  /**
+   * When a new activity is received from a WebSocket event by default it's added to the start of the list. You can change this to `end` to add it to the end of the list.
+   * Useful for story feeds.
+   */
+  addNewActivitiesTo: 'start' | 'end';
 };
 
 type EventHandlerByEventType = {
@@ -212,6 +218,7 @@ export class Feed extends FeedApi {
     id: string,
     data?: FeedResponse,
     watch = false,
+    addNewActivitiesTo: 'start' | 'end' = 'start',
   ) {
     super(client, groupId, id);
     this.state = new StateStore<FeedState>({
@@ -223,6 +230,7 @@ export class Feed extends FeedApi {
       is_loading_activities: false,
       comments_by_entity_id: {},
       watch,
+      addNewActivitiesTo,
     });
     this.client = client;
 
@@ -250,6 +258,10 @@ export class Feed extends FeedApi {
     return this.state.getLatestValue();
   }
 
+  set addNewActivitiesTo(value: 'start' | 'end') {
+    this.state.partialNext({ addNewActivitiesTo: value });
+  }
+
   hasActivity(activityId: string) {
     return this.indexedActivityIds.has(activityId);
   }

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

@@ -525,8 +525,18 @@ export class FeedsClient extends FeedsApi {
   on = this.eventDispatcher.on;
   off = this.eventDispatcher.off;
 
-  feed = (groupId: string, id: string) => {
-    return this.getOrCreateActiveFeed(groupId, id);
+  feed = (
+    groupId: string,
+    id: string,
+    options?: { addNewActivitiesTo?: 'start' | 'end' },
+  ) => {
+    return this.getOrCreateActiveFeed(
+      groupId,
+      id,
+      undefined,
+      undefined,
+      options?.addNewActivitiesTo,
+    );
   };
 
   async queryFeeds(request?: QueryFeedsRequest) {
@@ -640,11 +650,19 @@ export class FeedsClient extends FeedsApi {
     id: string,
     data?: FeedResponse,
     watch?: boolean,
+    addNewActivitiesTo?: 'start' | 'end',
   ) => {
     const fid = `${group}:${id}`;
 
     if (!this.activeFeeds[fid]) {
-      this.activeFeeds[fid] = new Feed(this, group, id, data, watch);
+      this.activeFeeds[fid] = new Feed(
+        this,
+        group,
+        id,
+        data,
+        watch,
+        addNewActivitiesTo,
+      );
     }
 
     const feed = this.activeFeeds[fid];

package/src/gen/feeds/FeedsApi.ts

@@ -170,6 +170,8 @@ export class FeedsApi {
     const body = {
       name: request?.name,
       words: request?.words,
+      is_leet_check_enabled: request?.is_leet_check_enabled,
+      is_plural_check_enabled: request?.is_plural_check_enabled,
       team: request?.team,
       type: request?.type,
     };
@@ -220,6 +222,8 @@ export class FeedsApi {
       name: request?.name,
     };
     const body = {
+      is_leet_check_enabled: request?.is_leet_check_enabled,
+      is_plural_check_enabled: request?.is_plural_check_enabled,
       team: request?.team,
       words: request?.words,
     };
@@ -499,6 +503,7 @@ export class FeedsApi {
       reason: request?.reason,
       report: request?.report,
       show_less: request?.show_less,
+      show_more: request?.show_more,
     };
 
     const response = await this.apiClient.sendRequest<

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

@@ -1233,9 +1233,11 @@ decoders.ModerationCustomActionEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    message: { type: 'Message', isSingle: true },
+    review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
 
-    user: { type: 'User', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    message: { type: 'MessageResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1266,9 +1268,11 @@ decoders.ModerationMarkReviewedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    message: { type: 'Message', isSingle: true },
+    item: { type: 'ReviewQueueItemResponse', isSingle: true },
 
-    user: { type: 'User', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    message: { type: 'MessageResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1745,6 +1749,8 @@ decoders.StoriesFeedUpdatedEvent = (input?: Record<string, any>) => {
 
     received_at: { type: 'DatetimeType', isSingle: true },
 
+    activities: { type: 'ActivityResponse', isSingle: false },
+
     aggregated_activities: {
       type: 'AggregatedActivityResponse',
       isSingle: false,