@stream-io/feeds-client 0.2.0 → 0.2.1

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

@@ -1,76 +1,115 @@
 import type { Feed } from '../../../feed';
 import type {
+  ActivityPinResponse,
   ActivityResponse,
   BookmarkUpdatedEvent,
 } from '../../../gen/models';
-import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+import type { EventPayload } from '../../../types-internal';
+import { updateEntityInArray } from '../../../utils';
 
-import { updateActivityInState } from '../activity';
 import { isSameBookmark } from './handle-bookmark-deleted';
 
-export const updateBookmarkInActivity = (
-  event: BookmarkUpdatedEvent,
-  activity: ActivityResponse,
-  isCurrentUser: boolean,
-): UpdateStateResult<ActivityResponse> => {
-  // Update own_bookmarks if the bookmark is from the current user
-  let ownBookmarks = activity.own_bookmarks || [];
-  if (isCurrentUser) {
-    const bookmarkIndex = ownBookmarks.findIndex((bookmark) =>
+const sharedUpdateActivity = ({
+  currentActivity,
+  event,
+  eventBelongsToCurrentUser,
+}: {
+  currentActivity: ActivityResponse;
+  event: BookmarkUpdatedEvent;
+  eventBelongsToCurrentUser: boolean;
+}): ActivityResponse => {
+  let newOwnBookmarks = currentActivity.own_bookmarks;
+
+  if (eventBelongsToCurrentUser) {
+    const bookmarkIndex = newOwnBookmarks.findIndex((bookmark) =>
       isSameBookmark(bookmark, event.bookmark),
     );
+
     if (bookmarkIndex !== -1) {
-      ownBookmarks = [...ownBookmarks];
-      ownBookmarks[bookmarkIndex] = event.bookmark;
+      newOwnBookmarks = [...newOwnBookmarks];
+      newOwnBookmarks[bookmarkIndex] = event.bookmark;
     }
   }
 
   return {
-    ...activity,
-    own_bookmarks: ownBookmarks,
-    changed: true,
+    ...event.bookmark.activity,
+    own_bookmarks: newOwnBookmarks,
+    own_reactions: currentActivity.own_reactions,
   };
 };
 
 export const updateBookmarkInActivities = (
   event: BookmarkUpdatedEvent,
   activities: ActivityResponse[] | undefined,
-  isCurrentUser: boolean,
-): UpdateStateResult<{ activities: ActivityResponse[] }> => {
-  if (!activities) {
-    return { changed: false, activities: [] };
-  }
+  eventBelongsToCurrentUser: boolean,
+) =>
+  updateEntityInArray({
+    entities: activities,
+    matcher: (activity) => activity.id === event.bookmark.activity.id,
+    updater: (matchedActivity) =>
+      sharedUpdateActivity({
+        currentActivity: matchedActivity,
+        event,
+        eventBelongsToCurrentUser,
+      }),
+  });
 
-  const activityIndex = activities.findIndex(
-    (a) => a.id === event.bookmark.activity.id,
-  );
-  if (activityIndex === -1) {
-    return { changed: false, activities };
-  }
+export const updateBookmarkInPinnedActivities = (
+  event: BookmarkUpdatedEvent,
+  pinnedActivities: ActivityPinResponse[] | undefined,
+  eventBelongsToCurrentUser: boolean,
+) =>
+  updateEntityInArray({
+    entities: pinnedActivities,
+    matcher: (pinnedActivity) =>
+      pinnedActivity.activity.id === event.bookmark.activity.id,
+    updater: (matchedPinnedActivity) => {
+      const newActivity = sharedUpdateActivity({
+        currentActivity: matchedPinnedActivity.activity,
+        event,
+        eventBelongsToCurrentUser,
+      });
 
-  const activity = activities[activityIndex];
-  const updatedActivity = updateBookmarkInActivity(
-    event,
-    activity,
-    isCurrentUser,
-  );
-  return updateActivityInState(updatedActivity, activities, true);
-};
+      if (newActivity === matchedPinnedActivity.activity) {
+        return matchedPinnedActivity;
+      }
+
+      return {
+        ...matchedPinnedActivity,
+        activity: newActivity,
+      };
+    },
+  });
 
 export function handleBookmarkUpdated(
   this: Feed,
   event: EventPayload<'feeds.bookmark.updated'>,
 ) {
-  const currentActivities = this.currentState.activities;
+  const {
+    activities: currentActivities,
+    pinned_activities: currentPinnedActivities,
+  } = this.currentState;
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
-  const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
+  const eventBelongsToCurrentUser =
+    event.bookmark.user.id === connectedUser?.id;
+
+  const [result1, result2] = [
+    updateBookmarkInActivities(
+      event,
+      currentActivities,
+      eventBelongsToCurrentUser,
+    ),
+    updateBookmarkInPinnedActivities(
+      event,
+      currentPinnedActivities,
+      eventBelongsToCurrentUser,
+    ),
+  ];
 
-  const result = updateBookmarkInActivities(
-    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/gen/model-decoders/decoders.ts

@@ -469,6 +469,8 @@ decoders.Channel = (input?: Record<string, any>) => {
 
     last_message_at: { type: 'DatetimeType', isSingle: true },
 
+    message_count_updated_at: { type: 'DatetimeType', isSingle: true },
+
     active_live_locations: { type: 'SharedLocation', isSingle: false },
 
     invites: { type: 'ChannelMember', isSingle: false },
@@ -857,6 +859,8 @@ decoders.FeedMemberResponse = (input?: Record<string, any>) => {
     invite_accepted_at: { type: 'DatetimeType', isSingle: true },
 
     invite_rejected_at: { type: 'DatetimeType', isSingle: true },
+
+    membership_level: { type: 'MembershipLevelResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1091,6 +1095,15 @@ decoders.ListDevicesResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MembershipLevelResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.Message = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },

package/src/gen/models/index.ts

@@ -672,6 +672,8 @@ export interface AggregatedActivityResponse {
 
 export interface AggregationConfig {
   format?: string;
+
+  group_size?: number;
 }
 
 export interface AppEventResponse {
@@ -1516,6 +1518,10 @@ export interface Channel {
 
   member_count?: number;
 
+  message_count?: number;
+
+  message_count_updated_at?: Date;
+
   team?: string;
 
   active_live_locations?: SharedLocation[];
@@ -1540,6 +1546,8 @@ export interface ChannelConfig {
 
   connect_events: boolean;
 
+  count_messages: boolean;
+
   created_at: Date;
 
   custom_events: boolean;
@@ -1606,6 +1614,8 @@ export interface ChannelConfigWithInfo {
 
   connect_events: boolean;
 
+  count_messages: boolean;
+
   created_at: Date;
 
   custom_events: boolean;
@@ -1704,6 +1714,8 @@ export interface ChannelMember {
 
   user_id?: string;
 
+  deleted_messages?: string[];
+
   user?: UserResponse;
 }
 
@@ -1796,6 +1808,8 @@ export interface ChannelResponse {
 
   member_count?: number;
 
+  message_count?: number;
+
   mute_expires_at?: Date;
 
   muted?: boolean;
@@ -2006,6 +2020,8 @@ export interface ConfigOverrides {
 
   blocklist_behavior?: 'flag' | 'block';
 
+  count_messages?: boolean;
+
   max_message_length?: number;
 
   quotes?: boolean;
@@ -2050,6 +2066,8 @@ export interface ConfigResponse {
 
   block_list_config?: BlockListConfig;
 
+  llm_config?: LLMConfig;
+
   rule_builder_config?: RuleBuilderConfig;
 
   velocity_filter_config?: VelocityFilterConfig;
@@ -2743,6 +2761,8 @@ export interface FeedMemberResponse {
   invite_rejected_at?: Date;
 
   custom?: Record<string, any>;
+
+  membership_level?: MembershipLevelResponse;
 }
 
 export interface FeedMemberUpdatedEvent {
@@ -3533,6 +3553,33 @@ export interface IngressVideoLayerResponse {
   min_dimension: number;
 }
 
+export interface LLMConfig {
+  enabled: boolean;
+
+  rules: LLMRule[];
+
+  async?: boolean;
+
+  severity_descriptions?: Record<string, string>;
+}
+
+export interface LLMRule {
+  action:
+    | 'flag'
+    | 'shadow'
+    | 'remove'
+    | 'bounce'
+    | 'bounce_flag'
+    | 'bounce_remove'
+    | 'keep';
+
+  description: string;
+
+  label: string;
+
+  severity_rules: BodyguardSeverityRule[];
+}
+
 export interface LabelThresholds {
   block?: number;
 
@@ -3605,6 +3652,24 @@ export interface MemberLookup {
   limit: number;
 }
 
+export interface MembershipLevelResponse {
+  created_at: Date;
+
+  id: string;
+
+  name: string;
+
+  priority: number;
+
+  updated_at: Date;
+
+  tags: string[];
+
+  description?: string;
+
+  custom?: Record<string, any>;
+}
+
 export interface Message {
   cid: string;
 
@@ -3654,6 +3719,8 @@ export interface Message {
 
   deleted_at?: Date;
 
+  deleted_for_me?: boolean;
+
   message_text_updated_at?: Date;
 
   mml?: string;
@@ -3760,6 +3827,8 @@ export interface MessageResponse {
 
   deleted_at?: Date;
 
+  deleted_for_me?: boolean;
+
   message_text_updated_at?: Date;
 
   mml?: string;
@@ -3838,6 +3907,8 @@ export interface ModerationFlagResponse {
 
   user_id: string;
 
+  result: Array<Record<string, any>>;
+
   entity_creator_id?: string;
 
   reason?: string;
@@ -3846,8 +3917,6 @@ export interface ModerationFlagResponse {
 
   labels?: string[];
 
-  result?: Array<Record<string, any>>;
-
   custom?: Record<string, any>;
 
   moderation_payload?: ModerationPayload;
@@ -5872,6 +5941,8 @@ export interface UpsertConfigRequest {
 
   google_vision_config?: GoogleVisionConfig;
 
+  llm_config?: LLMConfig;
+
   rule_builder_config?: RuleBuilderConfig;
 
   velocity_filter_config?: VelocityFilterConfig;

package/src/gen/moderation/ModerationApi.ts

@@ -69,6 +69,7 @@ export class ModerationApi {
       block_list_config: request?.block_list_config,
       bodyguard_config: request?.bodyguard_config,
       google_vision_config: request?.google_vision_config,
+      llm_config: request?.llm_config,
       rule_builder_config: request?.rule_builder_config,
       velocity_filter_config: request?.velocity_filter_config,
       video_call_rule_config: request?.video_call_rule_config,

package/src/test-utils/response-generators.ts

@@ -1,11 +1,18 @@
 import {
+  ActivityPinResponse,
+  ActivityResponse,
+  BookmarkFolderResponse,
+  BookmarkResponse,
   FeedResponse,
+  FeedsReactionResponse,
   FollowResponse,
   OwnUser,
   OwnUserResponse,
+  PinActivityResponse,
   UserResponse,
 } from '../gen/models';
 import { humanId } from 'human-id';
+import { EventPayload } from '../types-internal';
 
 export const getHumanId = () => humanId({ capitalize: false, separator: '-' });
 
@@ -99,3 +106,256 @@ export const generateFollowResponse = (
     ...overrides,
   };
 };
+
+export const generateActivityResponse = (
+  overrides: Omit<Partial<ActivityResponse>, 'user'> & {
+    user?: Partial<UserResponse>;
+  } = {},
+): ActivityResponse => {
+  return {
+    id: getHumanId(),
+    type: 'test',
+    created_at: new Date(),
+    updated_at: new Date(),
+    visibility: 'public',
+    bookmark_count: 0,
+    comment_count: 0,
+    reaction_count: 0,
+    share_count: 0,
+    attachments: [],
+    comments: [],
+    feeds: [],
+    filter_tags: [],
+    interest_tags: [],
+    latest_reactions: [],
+    mentioned_users: [],
+    own_bookmarks: [],
+    own_reactions: [],
+    custom: {},
+    reaction_groups: {},
+    search_data: {},
+    popularity: 0,
+    score: 0,
+    ...overrides,
+    user: generateUserResponse(overrides.user),
+  };
+};
+
+export const generateFeedReactionResponse = (
+  overrides: Omit<Partial<FeedsReactionResponse>, 'user'> & {
+    user?: Partial<UserResponse>;
+  } = {},
+): FeedsReactionResponse => {
+  const user = generateUserResponse(overrides.user);
+  return {
+    type: 'like',
+    activity_id: getHumanId(),
+    created_at: new Date(),
+    updated_at: new Date(),
+    ...overrides,
+    user,
+  };
+};
+
+export const generateActivityPinResponse = (
+  overrides: Omit<Partial<ActivityPinResponse>, 'activity' | 'user'> & {
+    activity?: Partial<ActivityResponse>;
+    user?: Partial<UserResponse>;
+  } = {},
+): ActivityPinResponse => {
+  return {
+    created_at: new Date(),
+    updated_at: new Date(),
+    feed: getHumanId(),
+    ...overrides,
+    activity: generateActivityResponse(overrides.activity),
+    user: generateUserResponse(overrides.user),
+  };
+};
+
+export const generateBookmarkFolderResponse = (
+  overrides: Partial<BookmarkFolderResponse> = {},
+): BookmarkFolderResponse => ({
+  id: `bookmark-folder-${getHumanId()}`,
+  name: humanId(),
+  created_at: new Date(),
+  updated_at: new Date(),
+  ...overrides,
+});
+
+export const generateBookmarkResponse = (
+  overrides: Omit<Partial<BookmarkResponse>, 'activity' | 'user'> & {
+    activity?: Partial<ActivityResponse>;
+    user?: Partial<UserResponse>;
+  } = {},
+): BookmarkResponse => ({
+  created_at: new Date(),
+  updated_at: new Date(),
+  ...overrides,
+  activity: generateActivityResponse(overrides.activity),
+  user: generateUserResponse(overrides.user),
+});
+
+// event generators
+export function generateActivityReactionAddedEvent(
+  overrides: Omit<
+    Partial<EventPayload<'feeds.activity.reaction.added'>>,
+    'activity' | 'type' | 'reaction' | 'user'
+  > & {
+    activity?: Parameters<typeof generateActivityResponse>[0];
+    reaction?: Parameters<typeof generateFeedReactionResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+  } = {},
+): EventPayload<'feeds.activity.reaction.added'> {
+  const activity = generateActivityResponse(overrides.activity);
+  const reaction = generateFeedReactionResponse(overrides.reaction);
+  const user = generateUserResponse(overrides.user);
+
+  return {
+    type: 'feeds.activity.reaction.added',
+    created_at: new Date(),
+    fid: '',
+    custom: {},
+    ...overrides,
+    user,
+    reaction,
+    activity,
+  };
+}
+
+export function generateActivityReactionDeletedEvent(
+  overrides: Omit<
+    Partial<EventPayload<'feeds.activity.reaction.deleted'>>,
+    'user' | 'activity' | 'reaction'
+  > & {
+    activity?: Parameters<typeof generateActivityResponse>[0];
+    reaction?: Parameters<typeof generateFeedReactionResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+  } = {},
+): EventPayload<'feeds.activity.reaction.deleted'> {
+  const activity = generateActivityResponse(overrides.activity);
+  const reaction = generateFeedReactionResponse(overrides.reaction);
+  const user = generateUserResponse(overrides.user);
+  return {
+    type: 'feeds.activity.reaction.deleted',
+    created_at: new Date(),
+    fid: '',
+    custom: {},
+    ...overrides,
+    user,
+    reaction,
+    activity,
+  };
+}
+
+export function generateActivityUpdatedEvent(
+  overrides: Omit<
+    Partial<EventPayload<'feeds.activity.updated'>>,
+    'activity' | 'type'
+  > & {
+    activity?: Parameters<typeof generateActivityResponse>[0];
+  } = {},
+): EventPayload<'feeds.activity.updated'> {
+  const activity = generateActivityResponse(overrides.activity);
+  return {
+    type: 'feeds.activity.updated',
+    created_at: new Date(),
+    fid: '',
+    custom: {},
+    ...overrides,
+    activity,
+  };
+}
+
+export function generateBookmarkAddedEvent(
+  overrides: Omit<
+    Partial<EventPayload<'feeds.bookmark.added'>>,
+    'bookmark' | 'user'
+  > & {
+    bookmark?: Parameters<typeof generateBookmarkResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+  } = {},
+): EventPayload<'feeds.bookmark.added'> {
+  const bookmark = generateBookmarkResponse(overrides.bookmark);
+  const user = generateUserResponse(overrides.user);
+  return {
+    type: 'feeds.bookmark.added',
+    created_at: new Date(),
+    custom: {},
+    ...overrides,
+    bookmark,
+    user,
+  };
+}
+
+export function generateBookmarkDeletedEvent(
+  overrides: Omit<
+    Partial<EventPayload<'feeds.bookmark.deleted'>>,
+    'bookmark' | 'user'
+  > & {
+    bookmark?: Parameters<typeof generateBookmarkResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+  } = {},
+): EventPayload<'feeds.bookmark.deleted'> {
+  const bookmark = generateBookmarkResponse(overrides.bookmark);
+  const user = generateUserResponse(overrides.user);
+  return {
+    type: 'feeds.bookmark.deleted',
+    created_at: new Date(),
+    custom: {},
+    ...overrides,
+    bookmark,
+    user,
+  };
+}
+
+export function generateBookmarkUpdatedEvent(
+  overrides: Omit<
+    Partial<EventPayload<'feeds.bookmark.updated'>>,
+    'bookmark' | 'user'
+  > & {
+    bookmark?: Parameters<typeof generateBookmarkResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+  } = {},
+): EventPayload<'feeds.bookmark.updated'> {
+  const bookmark = generateBookmarkResponse(overrides.bookmark);
+  const user = generateUserResponse(overrides.user);
+  return {
+    type: 'feeds.bookmark.updated',
+    created_at: new Date(),
+    custom: {},
+    ...overrides,
+    bookmark,
+    user,
+  };
+}
+
+export function generateActivityPinnedEvent(
+  overrides: Omit<
+    Partial<EventPayload<'feeds.activity.pinned'>>,
+    'pinned_activity' | 'user'
+  > & {
+    pinned_activity?: Parameters<typeof generateActivityPinResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+  } = {},
+): EventPayload<'feeds.activity.pinned'> {
+  const pinnedActivity = generateActivityPinResponse(overrides.pinned_activity);
+  const user = generateUserResponse(overrides.user);
+
+  // FIXME(TEMPORARY): re-map ActivityPinResponse to PinActivityResponse
+  const typeAdjustedPinnedActivity: PinActivityResponse = {
+    ...pinnedActivity,
+    user_id: pinnedActivity.user.id,
+    duration: '0',
+  };
+
+  return {
+    type: 'feeds.activity.pinned',
+    created_at: pinnedActivity.created_at,
+    fid: pinnedActivity.feed,
+    custom: {},
+    ...overrides,
+    pinned_activity: typeAdjustedPinnedActivity,
+    user,
+  };
+}

package/src/utils/index.ts

@@ -3,3 +3,4 @@ export * from './unique-array-merge';
 export * from './constants';
 export * from './type-assertions';
 export * from './state-update-queue';
+export * from './update-entity-in-array';