@stream-io/feeds-client 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/feeds-client",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "packageManager": "yarn@3.2.4",
   "main": "./dist/index.node.js",
   "exports": {
@@ -62,17 +62,13 @@
     "@rollup/plugin-replace": "^6.0.1",
     "@rollup/plugin-typescript": "^12.1.0",
     "@types/react": "^19.1.8",
-    "@vitest/browser": "^2.1.3",
-    "@vitest/coverage-v8": "^2.1.2",
     "dotenv": "^16.4.5",
-    "playwright": "^1.48.1",
     "react": "19.0.0",
     "rimraf": "^6.0.1",
     "rollup": "^4.24.0",
     "typescript": "^5.8.3",
     "vite": "^5.4.8",
-    "vitest": "^2.1.2",
-    "vitest-mock-extended": "^2.0.2"
+    "vitest": "^3.2.1"
   },
   "peerDependencies": {
     "react": "^18 || ^19"

package/src/Feed.ts

@@ -207,6 +207,8 @@ export class Feed extends FeedApi {
     'feeds.bookmark.added': this.handleBookmarkAdded.bind(this),
     'feeds.bookmark.deleted': this.handleBookmarkDeleted.bind(this),
     'feeds.bookmark.updated': this.handleBookmarkUpdated.bind(this),
+    'feeds.bookmark_folder.deleted': Feed.noop,
+    'feeds.bookmark_folder.updated': Feed.noop,
     'feeds.comment.added': (event) => {
       const { comment } = event;
       const forId = comment.parent_id ?? comment.object_id;
@@ -310,16 +312,21 @@ export class Feed extends FeedApi {
 
       // this feed followed someone
       if (event.follow.source_feed.fid === this.fid) {
-        if (this.currentState.following_pagination?.next === END_OF_LIST) {
-          this.state.next((currentState) => ({
+        this.state.next((currentState) => {
+          const newState = {
             ...currentState,
             ...event.follow.source_feed,
+          };
+
+          if (currentState.following_pagination?.next === END_OF_LIST) {
             // TODO: respect sort
-            following: currentState.following
+            newState.following = currentState.following
               ? currentState.following.concat(event.follow)
-              : [event.follow],
-          }));
-        }
+              : [event.follow];
+          }
+
+          return newState;
+        });
       } else if (
         // someone followed this feed
         event.follow.target_feed.fid === this.fid
@@ -331,15 +338,15 @@ export class Feed extends FeedApi {
           const newState = { ...currentState, ...event.follow.target_feed };
 
           if (source.created_by.id === connectedUser?.id) {
-            newState.own_follows = newState.own_follows
-              ? newState.own_follows.concat(event.follow)
+            newState.own_follows = currentState.own_follows
+              ? currentState.own_follows.concat(event.follow)
               : [event.follow];
           }
 
           if (currentState.followers_pagination?.next === END_OF_LIST) {
             // TODO: respect sort
-            newState.followers = newState.followers
-              ? newState.followers.concat(event.follow)
+            newState.followers = currentState.followers
+              ? currentState.followers.concat(event.follow)
               : [event.follow];
           }
 
@@ -371,13 +378,13 @@ export class Feed extends FeedApi {
           const newState = { ...currentState, ...event.follow.target_feed };
 
           if (source.created_by.id === connectedUser?.id) {
-            newState.own_follows = newState.own_follows?.filter(
+            newState.own_follows = currentState.own_follows?.filter(
               (follow) =>
                 follow.source_feed.fid !== event.follow.source_feed.fid,
             );
           }
 
-          newState.followers = newState.followers?.filter(
+          newState.followers = currentState.followers?.filter(
             (follow) => follow.source_feed.fid !== event.follow.source_feed.fid,
           );
 

package/src/FeedsClient.ts

@@ -12,7 +12,7 @@ import {
   UserRequest,
   WSEvent,
 } from './gen/models';
-import { FeedsEvent } from './types';
+import { FeedsEvent, TokenOrProvider } from './types';
 import { StateStore } from './common/StateStore';
 import { TokenManager } from './common/TokenManager';
 import { ConnectionIdManager } from './common/ConnectionIdManager';
@@ -35,6 +35,7 @@ import { StreamPoll } from './common/Poll';
 
 export type FeedsClientState = {
   connectedUser: OwnUser | undefined;
+  isWsConnectionHealthy: boolean;
 };
 
 type FID = string;
@@ -67,6 +68,7 @@ export class FeedsClient extends FeedsApi {
     super(apiClient);
     this.state = new StateStore<FeedsClientState>({
       connectedUser: undefined,
+      isWsConnectionHealthy: false,
     });
     this.moderation = new ModerationClient(apiClient);
     this.tokenManager = tokenManager;
@@ -79,6 +81,11 @@ export class FeedsClient extends FeedsApi {
         typeof fid === 'string' ? this.activeFeeds[fid] : undefined;
 
       switch (event.type) {
+        case 'connection.changed': {
+          const { online } = event;
+          this.state.partialNext({ isWsConnectionHealthy: online });
+          break;
+        }
         case 'feeds.feed.created': {
           if (feed) break;
 
@@ -188,10 +195,7 @@ export class FeedsClient extends FeedsApi {
     }
   }
 
-  connectUser = async (
-    user: UserRequest,
-    tokenProvider: string | (() => Promise<string>),
-  ) => {
+  connectUser = async (user: UserRequest, tokenProvider: TokenOrProvider) => {
     if (
       this.state.getLatestValue().connectedUser !== undefined ||
       this.wsConnection
@@ -216,7 +220,10 @@ export class FeedsClient extends FeedsApi {
         this.eventDispatcher.dispatch(event),
       );
       const connectedEvent = await this.wsConnection.connect();
-      this.state.partialNext({ connectedUser: connectedEvent?.me });
+      this.state.partialNext({
+        connectedUser: connectedEvent?.me,
+        isWsConnectionHealthy: this.wsConnection.isHealthy,
+      });
     } catch (err) {
       await this.disconnectUser();
       throw err;
@@ -291,7 +298,7 @@ export class FeedsClient extends FeedsApi {
 
     this.connectionIdManager.reset();
     this.tokenManager.reset();
-    this.state.partialNext({ connectedUser: undefined });
+    this.state.partialNext({ connectedUser: undefined, isWsConnectionHealthy: false });
   };
 
   on = this.eventDispatcher.on;
@@ -317,6 +324,16 @@ export class FeedsClient extends FeedsApi {
     };
   }
 
+  updateNetworkConnectionStatus = (
+    event: { type: 'online' | 'offline' } | Event,
+  ) => {
+    const networkEvent: NetworkChangedEvent = {
+      type: 'network.changed',
+      online: event.type === 'online',
+    };
+    this.eventDispatcher.dispatch(networkEvent);
+  };
+
   private readonly getOrCreateActiveFeed = (
     group: string,
     id: string,
@@ -332,16 +349,6 @@ export class FeedsClient extends FeedsApi {
     }
   };
 
-  private readonly updateNetworkConnectionStatus = (
-    event: { type: 'online' | 'offline' } | Event,
-  ) => {
-    const networkEvent: NetworkChangedEvent = {
-      type: 'network.changed',
-      online: event.type === 'online',
-    };
-    this.eventDispatcher.dispatch(networkEvent);
-  };
-
   private findActiveFeedByActivityId(activityId: string) {
     return Object.values(this.activeFeeds).filter((feed) =>
       feed.currentState.activities?.some(

package/src/common/StateStore.ts

@@ -9,7 +9,6 @@ export type Preprocessor<T> = Handler<T>;
 export const isPatch = <T>(value: ValueOrPatch<T>): value is Patch<T> =>
   typeof value === 'function';
 
- 
 const noop = () => {};
 
 export class StateStore<T extends Record<string, unknown>> {
@@ -23,7 +22,6 @@ export class StateStore<T extends Record<string, unknown>> {
    * @experimental
    * This method is experimental and may change in future versions.
    */
-   
   public merge<Q extends StateStore<any>>(
     stateStore: Q extends StateStore<infer L>
       ? Extract<keyof T, keyof L> extends never
@@ -44,7 +42,7 @@ export class StateStore<T extends Record<string, unknown>> {
       : newValueOrPatch;
 
     // do not notify subscribers if the value hasn't changed
-    if (newValue === this.value) return;
+    if (Object.is(newValue, this.value)) return;
 
     this.preprocessors.forEach((preprocessor) =>
       preprocessor(newValue, this.value),
@@ -71,6 +69,29 @@ export class StateStore<T extends Record<string, unknown>> {
     };
   }
 
+  public static doSelectionsEqual<
+    O extends Readonly<Record<string, unknown>> | readonly unknown[],
+  >(previouslySelectedValues: O | undefined, newlySelectedValues: O): boolean {
+    let selectionsAreEqual: boolean;
+
+    if (
+      (selectionsAreEqual = typeof previouslySelectedValues !== 'undefined')
+    ) {
+      for (const key in newlySelectedValues) {
+        if (
+          Object.is(previouslySelectedValues[key], newlySelectedValues[key])
+        ) {
+          continue;
+        }
+
+        selectionsAreEqual = false;
+        break;
+      }
+    }
+
+    return selectionsAreEqual;
+  }
+
   public subscribeWithSelector = <
     O extends Readonly<Record<string, unknown>> | readonly unknown[],
   >(
@@ -83,16 +104,13 @@ export class StateStore<T extends Record<string, unknown>> {
     const wrappedHandler: Handler<T> = (nextValue) => {
       const newlySelectedValues = selector(nextValue);
 
-      let hasUpdatedValues = typeof previouslySelectedValues === 'undefined';
-
-      for (const key in previouslySelectedValues) {
-        if (previouslySelectedValues[key] === newlySelectedValues[key])
-          continue;
-        hasUpdatedValues = true;
-        break;
-      }
+      // shallow comparison of previouslySelectedValues and newlySelectedValues
+      const selectionsAreEqual = StateStore.doSelectionsEqual(
+        previouslySelectedValues,
+        newlySelectedValues,
+      );
 
-      if (!hasUpdatedValues) return;
+      if (selectionsAreEqual) return;
 
       // save a copy of previouslySelectedValues before running
       // handler - if previouslySelectedValues are set to

package/src/common/utils.ts

@@ -72,7 +72,7 @@ function getRandomValuesWithMathRandom(bytes: Uint8Array): void {
 declare const msCrypto: Crypto;
 
 const getRandomValues = (() => {
-  if (typeof crypto?.getRandomValues !== 'undefined') {
+  if (typeof crypto !== 'undefined' && typeof crypto?.getRandomValues !== 'undefined') {
     return crypto.getRandomValues.bind(crypto);
   } else if (typeof msCrypto !== 'undefined') {
     return msCrypto.getRandomValues.bind(msCrypto);

package/src/gen/feeds/FeedsApi.ts

@@ -32,6 +32,7 @@ import {
   DeleteActivitiesResponse,
   DeleteActivityReactionResponse,
   DeleteActivityResponse,
+  DeleteBookmarkFolderResponse,
   DeleteBookmarkResponse,
   DeleteCommentReactionResponse,
   DeleteCommentResponse,
@@ -103,6 +104,8 @@ import {
   UpdateActivityResponse,
   UpdateBlockListRequest,
   UpdateBlockListResponse,
+  UpdateBookmarkFolderRequest,
+  UpdateBookmarkFolderResponse,
   UpdateBookmarkRequest,
   UpdateBookmarkResponse,
   UpdateCommentRequest,
@@ -743,6 +746,54 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async deleteBookmarkFolder(request: {
+    folder_id: string;
+  }): Promise<StreamResponse<DeleteBookmarkFolderResponse>> {
+    const pathParams = {
+      folder_id: request?.folder_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteBookmarkFolderResponse>
+    >(
+      'DELETE',
+      '/api/v2/feeds/bookmark_folders/{folder_id}',
+      pathParams,
+      undefined,
+    );
+
+    decoders.DeleteBookmarkFolderResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateBookmarkFolder(
+    request: UpdateBookmarkFolderRequest & { folder_id: string },
+  ): Promise<StreamResponse<UpdateBookmarkFolderResponse>> {
+    const pathParams = {
+      folder_id: request?.folder_id,
+    };
+    const body = {
+      name: request?.name,
+      custom: request?.custom,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateBookmarkFolderResponse>
+    >(
+      'PATCH',
+      '/api/v2/feeds/bookmark_folders/{folder_id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateBookmarkFolderResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async queryBookmarks(
     request?: QueryBookmarksRequest,
   ): Promise<StreamResponse<QueryBookmarksResponse>> {

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

@@ -353,6 +353,17 @@ decoders.BookmarkDeletedEvent = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.BookmarkFolderDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.BookmarkFolderResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -362,6 +373,17 @@ decoders.BookmarkFolderResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.BookmarkFolderUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.BookmarkResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1699,6 +1721,13 @@ decoders.UpdateBlockListResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UpdateBookmarkFolderResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UpdateBookmarkResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     bookmark: { type: 'BookmarkResponse', isSingle: true },

package/src/gen/model-decoders/event-decoder-mapping.ts

@@ -46,6 +46,12 @@ const eventDecoderMapping: Record<
   'feeds.bookmark.updated': (data: Record<string, any>) =>
     decoders.BookmarkUpdatedEvent(data),
 
+  'feeds.bookmark_folder.deleted': (data: Record<string, any>) =>
+    decoders.BookmarkFolderDeletedEvent(data),
+
+  'feeds.bookmark_folder.updated': (data: Record<string, any>) =>
+    decoders.BookmarkFolderUpdatedEvent(data),
+
   'feeds.comment.added': (data: Record<string, any>) =>
     decoders.CommentAddedEvent(data),
 

package/src/gen/models/index.ts

@@ -373,6 +373,8 @@ export interface ActivityResponse {
 
   popularity: number;
 
+  reaction_count: number;
+
   score: number;
 
   share_count: number;
@@ -949,6 +951,20 @@ export interface BookmarkDeletedEvent {
   user?: UserResponseCommonFields;
 }
 
+export interface BookmarkFolderDeletedEvent {
+  created_at: Date;
+
+  bookmark_folder: BookmarkFolderResponse;
+
+  custom: Record<string, any>;
+
+  type: string;
+
+  received_at?: Date;
+
+  user?: UserResponseCommonFields;
+}
+
 export interface BookmarkFolderResponse {
   created_at: Date;
 
@@ -961,6 +977,20 @@ export interface BookmarkFolderResponse {
   custom?: Record<string, any>;
 }
 
+export interface BookmarkFolderUpdatedEvent {
+  created_at: Date;
+
+  bookmark_folder: BookmarkFolderResponse;
+
+  custom: Record<string, any>;
+
+  type: string;
+
+  received_at?: Date;
+
+  user?: UserResponseCommonFields;
+}
+
 export interface BookmarkResponse {
   created_at: Date;
 
@@ -2051,6 +2081,10 @@ export interface DeleteActivityResponse {
   duration: string;
 }
 
+export interface DeleteBookmarkFolderResponse {
+  duration: string;
+}
+
 export interface DeleteBookmarkResponse {
   duration: string;
 
@@ -2490,6 +2524,8 @@ export interface FeedInput {
 
   visibility?: 'public' | 'visible' | 'followers' | 'members' | 'private';
 
+  filter_tags?: string[];
+
   members?: FeedMemberRequest[];
 
   custom?: Record<string, any>;
@@ -2620,6 +2656,8 @@ export interface FeedRequest {
 
   visibility?: 'public' | 'visible' | 'followers' | 'members' | 'private';
 
+  filter_tags?: string[];
+
   members?: FeedMemberRequest[];
 
   custom?: Record<string, any>;
@@ -2654,6 +2692,8 @@ export interface FeedResponse {
 
   visibility?: string;
 
+  filter_tags?: string[];
+
   custom?: Record<string, any>;
 }
 
@@ -3678,6 +3718,8 @@ export interface OwnUser {
 
   custom: Record<string, any>;
 
+  total_unread_count_by_team: Record<string, number>;
+
   deactivated_at?: Date;
 
   deleted_at?: Date;
@@ -3757,6 +3799,8 @@ export interface OwnUserResponse {
   push_preferences?: PushPreferences;
 
   teams_role?: Record<string, string>;
+
+  total_unread_count_by_team?: Record<string, number>;
 }
 
 export interface PagerRequest {
@@ -5232,6 +5276,18 @@ export interface UpdateBlockListResponse {
   blocklist?: BlockListResponse;
 }
 
+export interface UpdateBookmarkFolderRequest {
+  name?: string;
+
+  custom?: Record<string, any>;
+}
+
+export interface UpdateBookmarkFolderResponse {
+  duration: string;
+
+  bookmark_folder: BookmarkFolderResponse;
+}
+
 export interface UpdateBookmarkRequest {
   folder_id?: string;
 
@@ -5805,6 +5861,8 @@ export type WSClientEvent =
   | ({ type: 'feeds.bookmark.added' } & BookmarkAddedEvent)
   | ({ type: 'feeds.bookmark.deleted' } & BookmarkDeletedEvent)
   | ({ type: 'feeds.bookmark.updated' } & BookmarkUpdatedEvent)
+  | ({ type: 'feeds.bookmark_folder.deleted' } & BookmarkFolderDeletedEvent)
+  | ({ type: 'feeds.bookmark_folder.updated' } & BookmarkFolderUpdatedEvent)
   | ({ type: 'feeds.comment.added' } & CommentAddedEvent)
   | ({ type: 'feeds.comment.deleted' } & CommentDeletedEvent)
   | ({ type: 'feeds.comment.reaction.added' } & CommentReactionAddedEvent)
@@ -5848,6 +5906,8 @@ export type WSEvent =
   | ({ type: 'feeds.bookmark.added' } & BookmarkAddedEvent)
   | ({ type: 'feeds.bookmark.deleted' } & BookmarkDeletedEvent)
   | ({ type: 'feeds.bookmark.updated' } & BookmarkUpdatedEvent)
+  | ({ type: 'feeds.bookmark_folder.deleted' } & BookmarkFolderDeletedEvent)
+  | ({ type: 'feeds.bookmark_folder.updated' } & BookmarkFolderUpdatedEvent)
   | ({ type: 'feeds.comment.added' } & CommentAddedEvent)
   | ({ type: 'feeds.comment.deleted' } & CommentDeletedEvent)
   | ({ type: 'feeds.comment.reaction.added' } & CommentReactionAddedEvent)

package/src/types.ts

@@ -18,3 +18,7 @@ export type LoadingStates = {
   loading_next_page?: boolean;
   loading_prev_page?: boolean;
 };
+
+export type TokenOrProvider = string | TokenProvider;
+
+export type TokenProvider = () => Promise<string>;