@stream-io/feeds-client 0.1.4 → 0.1.6

package/src/common/ActivitySearchSource.ts

@@ -20,7 +20,7 @@ export class ActivitySearchSource extends BaseSearchSource<ActivityResponse> {
   }
 
   protected async query(searchQuery: string) {
-    const { connectedUser } = this.client.state.getLatestValue();
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
     if (!connectedUser) return { items: [] };
 
     const { activities: items, next } = await this.client.queryActivities({
@@ -39,8 +39,8 @@ export class ActivitySearchSource extends BaseSearchSource<ActivityResponse> {
 }
 
 
-  // filter: { 
-  //   'feed.name': { $autocomplete: searchQuery } 
-  //   'feed.description': { $autocomplete: searchQuery } 
-  //   'created_by.name': { $autocomplete: searchQuery } 
+  // filter: {
+  //   'feed.name': { $autocomplete: searchQuery }
+  //   'feed.description': { $autocomplete: searchQuery }
+  //   'created_by.name': { $autocomplete: searchQuery }
   // },

package/src/common/ApiClient.ts

@@ -21,7 +21,7 @@ export class ApiClient {
     private readonly connectionIdManager: ConnectionIdManager,
     options?: FeedsClientOptions,
   ) {
-    this.baseUrl = options?.base_url ?? 'https://video.stream-io-api.com';
+    this.baseUrl = options?.base_url ?? 'https://feeds.stream-io-api.com';
     this.timeout = options?.timeout ?? 3000;
     this.axiosInstance = axios.create({
       baseURL: this.baseUrl,

package/src/common/FeedSearchSource.ts

@@ -20,7 +20,7 @@ export class FeedSearchSource extends BaseSearchSource<Feed> {
   }
 
   protected async query(searchQuery: string) {
-    const { connectedUser } = this.client.state.getLatestValue();
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
     if (!connectedUser) return { items: [] };
 
     // const channelFilters: ChannelFilters = {

package/src/common/Poll.ts

@@ -36,7 +36,10 @@ const isPollVoteRemovedEvent = (
 
 export const isVoteAnswer = (vote: PollVote) => !!vote?.answer_text;
 
-export type PollAnswersQueryParams = QueryPollVotesRequest & { poll_id: string; user_id?: string };
+export type PollAnswersQueryParams = QueryPollVotesRequest & {
+  poll_id: string;
+  user_id?: string;
+};
 
 type OptionId = string;
 
@@ -66,7 +69,9 @@ export class StreamPoll {
     );
   }
 
-  private readonly getInitialStateFromPollResponse = (poll: PollInitOptions['poll']) => {
+  private readonly getInitialStateFromPollResponse = (
+    poll: PollInitOptions['poll'],
+  ) => {
     const { own_votes, id, ...pollResponseForState } = poll;
     const { ownAnswer, ownVotes } = own_votes?.reduce<{
       ownVotes: PollVote[];
@@ -126,7 +131,9 @@ export class StreamPoll {
     if (event.poll?.id && event.poll.id !== this.id) return;
     if (!isPollVoteCastedEvent(event as WSEvent)) return;
     const currentState = this.data;
-    const isOwnVote = event.poll_vote.user_id === this.client.state.getLatestValue().connectedUser?.id;
+    const isOwnVote =
+      event.poll_vote.user_id ===
+      this.client.state.getLatestValue().connected_user?.id;
     let latestAnswers = [...currentState.latest_answers];
     let ownAnswer = currentState.own_answer;
     const ownVotesByOptionId = currentState.own_votes_by_option_id;
@@ -153,7 +160,12 @@ export class StreamPoll {
       );
     }
 
-    const { answers_count, latest_votes_by_option, vote_count, vote_counts_by_option } = event.poll;
+    const {
+      answers_count,
+      latest_votes_by_option,
+      vote_count,
+      vote_counts_by_option,
+    } = event.poll;
     this.state.partialNext({
       answers_count,
       // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
@@ -173,7 +185,9 @@ export class StreamPoll {
     if (event.poll?.id && event.poll.id !== this.id) return;
     if (!isPollVoteChangedEvent(event as WSEvent)) return;
     const currentState = this.data;
-    const isOwnVote = event.poll_vote.user_id === this.client.state.getLatestValue().connectedUser?.id;
+    const isOwnVote =
+      event.poll_vote.user_id ===
+      this.client.state.getLatestValue().connected_user?.id;
     let latestAnswers = [...currentState.latest_answers];
     let ownAnswer = currentState.own_answer;
     let ownVotesByOptionId = currentState.own_votes_by_option_id;
@@ -227,7 +241,12 @@ export class StreamPoll {
       );
     }
 
-    const { answers_count, latest_votes_by_option, vote_count, vote_counts_by_option } = event.poll;
+    const {
+      answers_count,
+      latest_votes_by_option,
+      vote_count,
+      vote_counts_by_option,
+    } = event.poll;
     this.state.partialNext({
       answers_count,
       // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
@@ -237,7 +256,7 @@ export class StreamPoll {
       latest_answers: latestAnswers,
       last_activity_at: new Date(event.created_at),
       own_answer: ownAnswer,
-      own_votes_by_option_id:ownVotesByOptionId,
+      own_votes_by_option_id: ownVotesByOptionId,
       max_voted_option_ids: maxVotedOptionIds,
     });
   };
@@ -246,7 +265,9 @@ export class StreamPoll {
     if (event.poll?.id && event.poll.id !== this.id) return;
     if (!isPollVoteRemovedEvent(event as WSEvent)) return;
     const currentState = this.data;
-    const isOwnVote = event.poll_vote.user_id === this.client.state.getLatestValue().connectedUser?.id;
+    const isOwnVote =
+      event.poll_vote.user_id ===
+      this.client.state.getLatestValue().connected_user?.id;
     let latestAnswers = [...currentState.latest_answers];
     let ownAnswer = currentState.own_answer;
     const ownVotesByOptionId = { ...currentState.own_votes_by_option_id };
@@ -265,12 +286,16 @@ export class StreamPoll {
         event.poll.vote_counts_by_option,
       );
       if (isOwnVote && event.poll_vote.option_id) {
-
         delete ownVotesByOptionId[event.poll_vote.option_id];
       }
     }
 
-    const { answers_count, latest_votes_by_option, vote_count, vote_counts_by_option } = event.poll;
+    const {
+      answers_count,
+      latest_votes_by_option,
+      vote_count,
+      vote_counts_by_option,
+    } = event.poll;
     this.state.partialNext({
       answers_count,
       // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed

package/src/common/TokenManager.ts

@@ -1,4 +1,4 @@
-import { isFunction, retryInterval, sleep } from './utils';
+import { isFunction, sleep } from './utils';
 
 /**
  * TokenManager
@@ -67,12 +67,11 @@ export class TokenManager {
             this.token = await tokenProvider();
           } catch (e) {
             const numberOfFailures = ++previousFailuresCount;
-            await sleep(retryInterval(numberOfFailures));
+            await sleep(1000);
             if (numberOfFailures === 3) {
               this.loadTokenPromise = null;
               return reject(
                 new Error(
-
                   `Stream error: tried to get token ${numberOfFailures} times, but it failed with ${e}. Check your token provider`,
                   { cause: e },
                 ),

package/src/common/UserSearchSource.ts

@@ -20,7 +20,7 @@ export class UserSearchSource extends BaseSearchSource<UserResponse> {
   }
 
   protected async query(searchQuery: string) {
-    const { connectedUser } = this.client.state.getLatestValue();
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
     if (!connectedUser) return { items: [] };
 
     // const channelFilters: ChannelFilters = {

package/src/common/real-time/StableWSConnection.ts

@@ -487,7 +487,10 @@ export class StableWSConnection {
   onmessage = (wsID: number, event: MessageEvent) => {
     if (this.wsID !== wsID) return;
 
-    this._log('onmessage() - onmessage callback', { event, wsID });
+    this._log('onmessage() - onmessage callback', {
+      event: { ...event, data: JSON.parse(event.data) },
+      wsID,
+    });
     let data = typeof event.data === 'string' ? JSON.parse(event.data) : null;
     this.decoders.forEach((decode) => {
       data = decode(data);

package/src/state-updates/bookmark-utils.test.ts

@@ -37,6 +37,7 @@ const createMockActivity = (id: string): ActivityResponse => ({
   visibility: 'public',
   bookmark_count: 0,
   comment_count: 0,
+  reaction_count: 0,
   share_count: 0,
   attachments: [],
   comments: [],
@@ -181,6 +182,71 @@ describe('bookmark-utils', () => {
       expect(result.own_bookmarks).toHaveLength(1);
       expect(result.own_bookmarks[0]).toEqual(bookmark2);
     });
+
+    it('should correctly identify bookmarks by activity_id + folder_id + user_id', () => {
+      const activity = createMockActivity('activity1');
+      const user = createMockUser('user1');
+
+      // Create two bookmarks with same activity and user but different folders
+      const bookmark1 = {
+        ...createMockBookmark(user, activity),
+        folder: {
+          id: 'folder1',
+          name: 'Folder 1',
+          created_at: new Date(),
+          updated_at: new Date(),
+          custom: {},
+        },
+      };
+      const bookmark2 = {
+        ...createMockBookmark(user, activity),
+        folder: {
+          id: 'folder2',
+          name: 'Folder 2',
+          created_at: new Date(),
+          updated_at: new Date(),
+          custom: {},
+        },
+      };
+
+      activity.own_bookmarks = [bookmark1, bookmark2];
+
+      // Try to remove bookmark1
+      const event = createMockDeletedEvent(bookmark1);
+      const result = removeBookmarkFromActivity(event, activity, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(1);
+      expect(result.own_bookmarks[0]).toEqual(bookmark2);
+    });
+
+    it('should handle bookmarks without folders correctly', () => {
+      const activity = createMockActivity('activity1');
+      const user = createMockUser('user1');
+
+      // Create two bookmarks: one with folder, one without
+      const bookmarkWithFolder = {
+        ...createMockBookmark(user, activity),
+        folder: {
+          id: 'folder1',
+          name: 'Folder 1',
+          created_at: new Date(),
+          updated_at: new Date(),
+          custom: {},
+        },
+      };
+      const bookmarkWithoutFolder = createMockBookmark(user, activity);
+
+      activity.own_bookmarks = [bookmarkWithFolder, bookmarkWithoutFolder];
+
+      // Try to remove bookmark without folder
+      const event = createMockDeletedEvent(bookmarkWithoutFolder);
+      const result = removeBookmarkFromActivity(event, activity, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(1);
+      expect(result.own_bookmarks[0]).toEqual(bookmarkWithFolder);
+    });
   });
 
   describe('updateBookmarkInActivity', () => {
@@ -220,20 +286,80 @@ describe('bookmark-utils', () => {
       expect(result.own_bookmarks[0]).toEqual(bookmark); // unchanged
     });
 
-    it('should not update bookmark if it does not exist', () => {
+    // Test for the bug: updating bookmarks with same activity_id but different folder_id
+    it('should correctly update bookmark by activity_id + folder_id + user_id', () => {
       const activity = createMockActivity('activity1');
       const user = createMockUser('user1');
-      const bookmark = createMockBookmark(user, activity);
-      activity.own_bookmarks = [bookmark];
 
-      const differentUser = createMockUser('user2');
-      const differentBookmark = createMockBookmark(differentUser, activity);
-      const event = createMockUpdatedEvent(differentBookmark);
+      // Create two bookmarks with same activity and user but different folders
+      const bookmark1 = {
+        ...createMockBookmark(user, activity),
+        folder: {
+          id: 'folder1',
+          name: 'Folder 1',
+          created_at: new Date(),
+          updated_at: new Date(),
+          custom: {},
+        },
+      };
+      const bookmark2 = {
+        ...createMockBookmark(user, activity),
+        folder: {
+          id: 'folder2',
+          name: 'Folder 2',
+          created_at: new Date(),
+          updated_at: new Date(),
+          custom: {},
+        },
+      };
+
+      activity.own_bookmarks = [bookmark1, bookmark2];
+
+      // Update bookmark1
+      const updatedBookmark1 = {
+        ...bookmark1,
+        custom: { updated: true },
+      };
+      const event = createMockUpdatedEvent(updatedBookmark1);
       const result = updateBookmarkInActivity(event, activity, true);
 
       expect(result.changed).toBe(true);
-      expect(result.own_bookmarks).toHaveLength(1);
-      expect(result.own_bookmarks[0]).toEqual(bookmark); // unchanged
+      expect(result.own_bookmarks).toHaveLength(2);
+      expect(result.own_bookmarks).toContain(updatedBookmark1);
+      expect(result.own_bookmarks).toContain(bookmark2);
+    });
+
+    it('should handle updating bookmarks without folders correctly', () => {
+      const activity = createMockActivity('activity1');
+      const user = createMockUser('user1');
+
+      // Create two bookmarks: one with folder, one without
+      const bookmarkWithFolder = {
+        ...createMockBookmark(user, activity),
+        folder: {
+          id: 'folder1',
+          name: 'Folder 1',
+          created_at: new Date(),
+          updated_at: new Date(),
+          custom: {},
+        },
+      };
+      const bookmarkWithoutFolder = createMockBookmark(user, activity);
+
+      activity.own_bookmarks = [bookmarkWithFolder, bookmarkWithoutFolder];
+
+      // Update bookmark without folder
+      const updatedBookmarkWithoutFolder = {
+        ...bookmarkWithoutFolder,
+        custom: { updated: true },
+      };
+      const event = createMockUpdatedEvent(updatedBookmarkWithoutFolder);
+      const result = updateBookmarkInActivity(event, activity, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(2);
+      expect(result.own_bookmarks).toContain(bookmarkWithFolder);
+      expect(result.own_bookmarks).toContain(updatedBookmarkWithoutFolder);
     });
   });
 

package/src/state-updates/bookmark-utils.ts

@@ -3,9 +3,23 @@ import {
   BookmarkDeletedEvent,
   BookmarkUpdatedEvent,
   ActivityResponse,
+  BookmarkResponse,
 } from '../gen/models';
 import { UpdateStateResult } from '../types-internal';
 
+// Helper function to check if two bookmarks are the same
+// A bookmark is identified by activity_id + folder_id + user_id
+const isSameBookmark = (
+  bookmark1: BookmarkResponse,
+  bookmark2: BookmarkResponse,
+): boolean => {
+  return (
+    bookmark1.user.id === bookmark2.user.id &&
+    bookmark1.activity.id === bookmark2.activity.id &&
+    bookmark1.folder?.id === bookmark2.folder?.id
+  );
+};
+
 const updateActivityInActivities = (
   updatedActivity: ActivityResponse,
   activities: ActivityResponse[],
@@ -46,9 +60,7 @@ export const removeBookmarkFromActivity = (
   // Update own_bookmarks if the bookmark is from the current user
   const ownBookmarks = isCurrentUser
     ? (activity.own_bookmarks || []).filter(
-        (bookmark) =>
-          bookmark.user.id !== event.bookmark.user.id ||
-          bookmark.activity.id !== event.bookmark.activity.id,
+        (bookmark) => !isSameBookmark(bookmark, event.bookmark),
       )
     : activity.own_bookmarks;
 
@@ -67,10 +79,8 @@ export const updateBookmarkInActivity = (
   // Update own_bookmarks if the bookmark is from the current user
   let ownBookmarks = activity.own_bookmarks || [];
   if (isCurrentUser) {
-    const bookmarkIndex = ownBookmarks.findIndex(
-      (bookmark) =>
-        bookmark.user.id === event.bookmark.user.id &&
-        bookmark.activity.id === event.bookmark.activity.id,
+    const bookmarkIndex = ownBookmarks.findIndex((bookmark) =>
+      isSameBookmark(bookmark, event.bookmark),
     );
     if (bookmarkIndex !== -1) {
       ownBookmarks = [...ownBookmarks];

package/src/types.ts

@@ -1,6 +1,13 @@
 import { ConnectionChangedEvent } from './common/real-time/event-models';
 import { NetworkChangedEvent } from './common/types';
-import { PagerResponse, WSEvent } from './gen/models';
+import {
+  PagerResponse,
+  WSEvent,
+} from './gen/models';
+import type {
+  ActivityResponse,
+  CommentResponse,
+} from './gen/models';
 import { FeedsClient } from './FeedsClient';
 
 export type FeedsEvent = WSEvent | ConnectionChangedEvent | NetworkChangedEvent;
@@ -22,3 +29,7 @@ export type LoadingStates = {
 export type TokenOrProvider = string | TokenProvider;
 
 export type TokenProvider = () => Promise<string>;
+
+export type StreamFile = File | { name: string, uri: string, type: string }
+
+export type CommentParent = ActivityResponse | CommentResponse;

package/src/utils.ts

@@ -1,4 +1,28 @@
-export const isImageFile = (file: File) => {
+import { CommentParent, StreamFile } from './types';
+import type { CommentResponse } from './gen/models';
+
+export const isImageFile = (file: StreamFile) => {
   // photoshop files begin with 'image/'
   return file.type.startsWith('image/') && !file.type.endsWith('.photoshop');
 };
+
+export const isVideoFile = (file: StreamFile) => {
+  return file.type.startsWith('video/');
+};
+
+export const checkHasAnotherPage = <T extends unknown | undefined>(
+  v: T,
+  cursor: string | undefined,
+) =>
+  (typeof v === 'undefined' && typeof cursor === 'undefined') ||
+  typeof cursor === 'string';
+
+export const isCommentResponse = (
+  entity: CommentParent,
+): entity is CommentResponse => {
+  return typeof (entity as CommentResponse)?.object_id === 'string';
+};
+
+export const Constants = {
+  DEFAULT_COMMENT_PAGINATION: 'first',
+} as const;

package/dist/@react-bindings/hooks/clientStateHooks.d.ts

@@ -1,10 +0,0 @@
-/**
- * A React hook that returns the currently connected user on a `FeedsClient` instance and null otherwise.
- */
-export declare const useClientConnectedUser: () => import("../..").OwnUser | undefined;
-/**
- * A React hook that returns the websocket connection state of `FeedsClient`.
- */
-export declare const useWsConnectionState: () => {
-    isHealthy: boolean | undefined;
-};

package/dist/@react-bindings/hooks/useComments.d.ts

@@ -1,12 +0,0 @@
-import type { ActivityResponse, CommentResponse } from '../../src/gen/models';
-import type { Feed } from '../../src/Feed';
-export declare const useComments: (feed: Feed, 
-/**
- * The parent (activity or comment) for which to fetch comments.
- */
-parent: ActivityResponse | CommentResponse) => {
-    comments: CommentResponse[];
-    comment_pagination: (import("../../src/gen/models").PagerResponse & import("../..").LoadingStates & {
-        sort?: string;
-    }) | undefined;
-};

package/dist/@react-bindings/hooks/useOwnCapabilities.d.ts

@@ -1,33 +0,0 @@
-import type { Feed } from '../../src/Feed';
-export declare const useOwnCapabilities: (feed: Feed | undefined) => {
-    canAddActivity: boolean;
-    canAddActivityReaction: boolean;
-    canAddComment: boolean;
-    canAddCommentReaction: boolean;
-    canBookmarkActivity: boolean;
-    canCreateFeed: boolean;
-    canDeleteBookmark: boolean;
-    canDeleteComment: boolean;
-    canDeleteFeed: boolean;
-    canEditBookmark: boolean;
-    canFollow: boolean;
-    canRemoveActivity: boolean;
-    canRemoveActivityReaction: boolean;
-    canRemoveCommentReaction: boolean;
-    canUnfollow: boolean;
-    canUpdateFeed: boolean;
-    canInviteFeed: boolean;
-    canJoinFeed: boolean;
-    canLeaveFeed: boolean;
-    canManageFeedGroup: boolean;
-    canMarkActivity: boolean;
-    canPinActivity: boolean;
-    canQueryFeedMembers: boolean;
-    canQueryFollows: boolean;
-    canReadActivities: boolean;
-    canReadFeed: boolean;
-    canUpdateActivity: boolean;
-    canUpdateComment: boolean;
-    canUpdateFeedFollowers: boolean;
-    canUpdateFeedMembers: boolean;
-};