@stream-io/feeds-client 0.2.16 → 0.2.18

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

@@ -42,8 +42,10 @@ import {
   handleActivityMarked,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
+  handleActivityReactionUpdated,
   handleCommentReactionAdded,
   handleCommentReactionDeleted,
+  handleCommentReactionUpdated,
   addAggregatedActivitiesToState,
   updateNotificationStatus,
   handleStoriesFeedUpdated,
@@ -129,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 = {
@@ -151,7 +159,7 @@ export class Feed extends FeedApi {
     'feeds.activity.deleted': handleActivityDeleted.bind(this),
     'feeds.activity.reaction.added': handleActivityReactionAdded.bind(this),
     'feeds.activity.reaction.deleted': handleActivityReactionDeleted.bind(this),
-    'feeds.activity.reaction.updated': Feed.noop,
+    'feeds.activity.reaction.updated': handleActivityReactionUpdated.bind(this),
     'feeds.activity.removed_from_feed':
       handleActivityRemovedFromFeed.bind(this),
     'feeds.activity.updated': handleActivityUpdated.bind(this),
@@ -173,7 +181,7 @@ export class Feed extends FeedApi {
     'feeds.follow.updated': handleFollowUpdated.bind(this),
     'feeds.comment.reaction.added': handleCommentReactionAdded.bind(this),
     'feeds.comment.reaction.deleted': handleCommentReactionDeleted.bind(this),
-    'feeds.comment.reaction.updated': Feed.noop,
+    'feeds.comment.reaction.updated': handleCommentReactionUpdated.bind(this),
     'feeds.feed_member.added': handleFeedMemberAdded.bind(this),
     'feeds.feed_member.removed': handleFeedMemberRemoved.bind(this),
     'feeds.feed_member.updated': handleFeedMemberUpdated.bind(this),
@@ -210,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>({
@@ -221,6 +230,7 @@ export class Feed extends FeedApi {
       is_loading_activities: false,
       comments_by_entity_id: {},
       watch,
+      addNewActivitiesTo,
     });
     this.client = client;
 
@@ -248,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

@@ -51,6 +51,7 @@ import {
   Feed,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
+  handleActivityReactionUpdated,
   handleActivityUpdated,
   handleCommentAdded,
   handleCommentDeleted,
@@ -68,7 +69,8 @@ import { handleUserUpdated } from './event-handlers';
 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';
+import { configureLoggers } from '../utils';
+import { handleCommentReactionUpdated } from '../feed/event-handlers/comment/handle-comment-reaction-updated';
 
 export type FeedsClientState = {
   connected_user: OwnUser | undefined;
@@ -417,9 +419,14 @@ export class FeedsClient extends FeedsApi {
       activity_id: string;
     },
   ) => {
+    const shouldEnforceUnique = request.enforce_unique;
     const response = await super.addActivityReaction(request);
     for (const feed of Object.values(this.activeFeeds)) {
-      handleActivityReactionAdded.bind(feed)(response, false);
+      if (shouldEnforceUnique) {
+        handleActivityReactionUpdated.bind(feed)(response, false);
+      } else {
+        handleActivityReactionAdded.bind(feed)(response, false);
+      }
     }
     return response;
   };
@@ -449,9 +456,14 @@ export class FeedsClient extends FeedsApi {
   addCommentReaction = async (
     request: AddCommentReactionRequest & { id: string },
   ): Promise<StreamResponse<AddCommentReactionResponse>> => {
+    const shouldEnforceUnique = request.enforce_unique;
     const response = await super.addCommentReaction(request);
     for (const feed of Object.values(this.activeFeeds)) {
-      handleCommentReactionAdded.bind(feed)(response, false);
+      if (shouldEnforceUnique) {
+        handleCommentReactionUpdated.bind(feed)(response, false);
+      } else {
+        handleCommentReactionAdded.bind(feed)(response, false);
+      }
     }
     return response;
   };
@@ -513,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) {
@@ -628,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,