@stream-io/feeds-client 0.2.12 → 0.2.14

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

@@ -0,0 +1,193 @@
+import type { Feed } from '../..';
+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;
+};
+
+export const updateNotificationStatus = (
+  newNotificationStatus?: NotificationStatusResponse,
+  currentNotificationStatus?: NotificationStatusResponse,
+) => {
+  if (!newNotificationStatus && !currentNotificationStatus) {
+    return {
+      changed: false,
+      notification_status: undefined,
+    };
+  } else if (!newNotificationStatus) {
+    return {
+      changed: false,
+      notification_status: currentNotificationStatus,
+    };
+  } else {
+    return {
+      changed: true,
+      notification_status: {
+        ...newNotificationStatus,
+      },
+    };
+  }
+};
+
+export const updateNotificationFeedFromEvent = (
+  event: NotificationFeedUpdatedEvent,
+  currentAggregatedActivities?: AggregatedActivityResponse[],
+  currentNotificationStatus?: NotificationStatusResponse,
+): UpdateStateResult<{
+  data?: {
+    notification_status?: NotificationStatusResponse;
+    aggregated_activities?: AggregatedActivityResponse[];
+  };
+}> => {
+  const updates: {
+    notification_status?: NotificationStatusResponse;
+    aggregated_activities?: AggregatedActivityResponse[];
+  } = {};
+
+  if (event.notification_status && currentNotificationStatus) {
+    const notificationStatusResult = updateNotificationStatus(
+      event.notification_status,
+      currentNotificationStatus,
+    );
+
+    if (notificationStatusResult.changed) {
+      updates.notification_status =
+        notificationStatusResult.notification_status;
+    }
+  }
+
+  if (event.aggregated_activities && currentAggregatedActivities) {
+    const aggregatedActivitiesResult = addAggregatedActivitiesToState(
+      event.aggregated_activities,
+      currentAggregatedActivities,
+      'start',
+    );
+
+    if (aggregatedActivitiesResult.changed) {
+      updates.aggregated_activities =
+        aggregatedActivitiesResult.aggregated_activities;
+    }
+  }
+
+  if (Object.keys(updates).length > 0) {
+    return {
+      changed: true,
+      data: updates,
+    };
+  }
+
+  return {
+    changed: false,
+  };
+};
+
+export function handleNotificationFeedUpdated(
+  this: Feed,
+  event: EventPayload<'feeds.notification_feed.updated'>,
+) {
+  const result = updateNotificationFeedFromEvent(
+    event,
+    this.currentState.aggregated_activities,
+    this.currentState.notification_status,
+  );
+  if (result.changed) {
+    this.state.partialNext({
+      notification_status: result.data?.notification_status,
+      aggregated_activities: result.data?.aggregated_activities,
+    });
+  }
+}
+
+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

@@ -44,6 +44,9 @@ import {
   handleActivityReactionDeleted,
   handleCommentReactionAdded,
   handleCommentReactionDeleted,
+  addAggregatedActivitiesToState,
+  updateNotificationStatus,
+  handleStoriesFeedUpdated,
 } from './event-handlers';
 import { capitalize } from '../common/utils';
 import type {
@@ -175,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,
@@ -279,9 +283,27 @@ export class Feed extends FeedApi {
           'end',
         );
 
-        if (result.changed) {
+        const aggregatedActivitiesResult = addAggregatedActivitiesToState(
+          response.aggregated_activities,
+          this.currentState.aggregated_activities,
+          'end',
+        );
+
+        const notificationStatusResult = updateNotificationStatus(
+          response.notification_status,
+          this.currentState.notification_status,
+        );
+
+        if (
+          result.changed ||
+          aggregatedActivitiesResult.changed ||
+          notificationStatusResult.changed
+        ) {
           this.state.partialNext({
             activities: result.activities,
+            aggregated_activities:
+              aggregatedActivitiesResult.aggregated_activities,
+            notification_status: notificationStatusResult.notification_status,
             next: response.next,
             prev: response.prev,
           });

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;
+};