@stream-io/feeds-client 0.1.11 → 0.2.1

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: '-' });
 
@@ -13,6 +20,7 @@ export const generateUserResponse = (
   overrides: Partial<UserResponse> = {},
 ): UserResponse => ({
   id: `user-${getHumanId()}`,
+  name: humanId({ separator: ' ' }),
   created_at: new Date(),
   updated_at: new Date(),
   banned: false,
@@ -57,29 +65,27 @@ export const generateFeedResponse = (
 ): FeedResponse => {
   const id = overrides.id || `feed-${getHumanId()}`;
   const groupId = overrides.group_id || 'user';
-  const fid = `${groupId}:${id}`;
-  const createdBy = generateUserResponse(overrides.created_by);
-  const description = humanId({
-    addAdverb: true,
-    adjectiveCount: 4,
-  });
-  const name = humanId();
+  const feed = `${groupId}:${id}`;
 
   return {
     id,
     group_id: groupId,
     created_at: new Date(),
     updated_at: new Date(),
-    description,
-    fid,
+    description: humanId({
+      addAdverb: true,
+      adjectiveCount: 4,
+      separator: ' ',
+    }),
     follower_count: 0,
     following_count: 0,
     member_count: 0,
-    name,
+    name: humanId({ separator: ' ' }),
     pin_count: 0,
     custom: {},
     ...overrides,
-    created_by: createdBy,
+    feed,
+    created_by: generateUserResponse(overrides.created_by),
   };
 };
 
@@ -100,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';

package/src/utils/state-update-queue.ts

@@ -27,7 +27,7 @@ export function getStateUpdateQueueId(
   prefix?: 'deleted' | 'updated' | 'created' | (string & {}),
 ) {
   if (isFollowResponse(data)) {
-    const toJoin = [data.source_feed.fid, data.target_feed.fid];
+    const toJoin = [data.source_feed.feed, data.target_feed.feed];
     if (prefix) {
       toJoin.unshift(prefix);
     }

package/src/utils/update-entity-in-array.ts

@@ -0,0 +1,51 @@
+/**
+ * Utility function through which you can update an entity in an array;
+ *
+ * - if the entity is not found, it returns the original array unchanged
+ * - if the entity is found and updated, it returns a new array with the updated entity
+ * - if the entity is found but not updated (updater returns `matchedEntity`), it returns the original array unchanged
+ *
+ * - `changed: boolean` indicates whether the array has changed or not - this is QOL enhancement, you
+ * can compare returned array to the original one
+ *
+ */
+export function updateEntityInArray<T>(_: {
+  matcher: (entity: T) => boolean;
+  entities: T[];
+  updater: (currentEntity: T) => T;
+}): { changed: boolean; entities: T[] };
+export function updateEntityInArray<T>(_: {
+  matcher: (entity: T) => boolean;
+  entities: T[] | undefined;
+  updater: (currentEntity: T) => T;
+}): { changed: boolean; entities: T[] | undefined };
+export function updateEntityInArray<T>({
+  matcher,
+  updater,
+  entities,
+}: {
+  matcher: (entity: T) => boolean;
+  entities: T[] | undefined;
+  updater: (currentEntity: T) => T;
+}) {
+  if (!entities || !entities.length) {
+    return { changed: false, entities };
+  }
+
+  const index = entities.findIndex(matcher);
+
+  if (index === -1) {
+    return { changed: false, entities };
+  }
+
+  const newEntity = updater(entities[index]);
+
+  if (newEntity === entities[index]) {
+    return { changed: false, entities };
+  }
+
+  const updatedEntities = [...entities];
+  updatedEntities[index] = newEntity;
+
+  return { changed: true, entities: updatedEntities };
+}