@stream-io/feeds-client 0.3.16 → 0.3.18

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

@@ -38,18 +38,10 @@ const sharedUpdateActivity = ({
     );
   }
 
-  if (
-    !event.bookmark.activity.current_feed &&
-    event.bookmark.activity.feeds.length === 1 &&
-    currentActivity.current_feed
-  ) {
-    event.bookmark.activity.current_feed = currentActivity.current_feed;
-  }
-
   return {
-    ...event.bookmark.activity,
+    ...currentActivity,
+    bookmark_count: event.bookmark.activity.bookmark_count,
     own_bookmarks: newOwnBookmarks,
-    own_reactions: currentActivity.own_reactions,
   };
 };
 

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

@@ -32,9 +32,9 @@ const sharedUpdateActivity = ({
   }
 
   return {
-    ...event.bookmark.activity,
+    ...currentActivity,
+    bookmark_count: event.bookmark.activity.bookmark_count,
     own_bookmarks: newOwnBookmarks,
-    own_reactions: currentActivity.own_reactions,
   };
 };
 

package/src/feed/feed.ts

@@ -932,6 +932,34 @@ export class Feed extends FeedApi {
 
     // no need to run noop function
     if (eventHandler !== Feed.noop) {
+      if ('activity' in event && this.hasActivity(event.activity.id)) {
+        const currentActivity = this.currentState.activities?.find(
+          (a) => a.id === event.activity.id,
+        );
+
+        // Backfill current_feed if activity is posted to multiple feeds
+        if (
+          event.activity.feeds.length > 1 &&
+          !event.activity.current_feed &&
+          currentActivity?.current_feed
+        ) {
+          event.activity.current_feed = currentActivity.current_feed;
+        }
+
+        // Backfill own_ fields if activity is posted to a single feed
+        if (
+          event.activity.feeds.length === 1 &&
+          event.activity.current_feed &&
+          currentActivity?.current_feed
+        ) {
+          event.activity.current_feed.own_capabilities =
+            currentActivity.current_feed.own_capabilities;
+          event.activity.current_feed.own_follows =
+            currentActivity.current_feed.own_follows;
+          event.activity.current_feed.own_membership =
+            currentActivity.current_feed.own_membership;
+        }
+      }
       // @ts-expect-error intersection of handler arguments results to never
       eventHandler?.(event);
     }

package/src/feeds-client/feeds-client.ts

@@ -14,13 +14,15 @@ import type {
   FileUploadRequest,
   FollowBatchRequest,
   FollowRequest,
+  FollowResponse,
   GetOrCreateFeedRequest,
   ImageUploadRequest,
-  OwnCapabilitiesBatchRequest,
+  OwnBatchRequest,
   PollResponse,
   PollVotesResponse,
   QueryFeedsRequest,
   QueryPollVotesRequest,
+  UnfollowBatchRequest,
   UpdateActivityRequest,
   UpdateActivityResponse,
   UpdateCommentRequest,
@@ -93,7 +95,6 @@ import { getFeed } from '../activity-with-state-updates/get-feed';
 
 export type FeedsClientState = {
   connected_user: ConnectedUser | undefined;
-  is_anonymous: boolean;
   is_ws_connection_healthy: boolean;
   own_capabilities_by_fid: Record<string, FeedResponse['own_capabilities']>;
 };
@@ -137,7 +138,6 @@ export class FeedsClient extends FeedsApi {
     super(apiClient);
     this.state = new StateStore<FeedsClientState>({
       connected_user: undefined,
-      is_anonymous: false,
       is_ws_connection_healthy: false,
       own_capabilities_by_fid: {},
     });
@@ -286,7 +286,7 @@ export class FeedsClient extends FeedsApi {
       cancelTimer: cancel,
     } = throttle<GetBatchedOwnCapabilitiesThrottledCallback>(
       (feeds, callback) => {
-        this.ownCapabilitiesBatch({
+        this.ownBatch({
           feeds,
         }).catch((error) => {
           this.eventDispatcher.dispatch({
@@ -393,25 +393,7 @@ export class FeedsClient extends FeedsApi {
     this.state.partialNext({ own_capabilities_by_fid: ownCapabilitiesCache });
   }
 
-  connectAnonymous = () => {
-    this.connectionIdManager.resolveConnectionidPromise();
-    this.tokenManager.setTokenOrProvider(undefined);
-    this.setGetBatchOwnCapabilitiesThrottlingInterval(
-      this.query_batch_own_capabilties_throttling_interval,
-    );
-    this.state.partialNext({
-      connected_user: undefined,
-      is_anonymous: true,
-      is_ws_connection_healthy: false,
-    });
-
-    return Promise.resolve();
-  };
-
-  connectUser = async (
-    user: UserRequest | { id: '!anon' },
-    tokenProvider?: TokenOrProvider,
-  ) => {
+  connectUser = async (user: UserRequest, tokenProvider?: TokenOrProvider) => {
     if (
       this.state.getLatestValue().connected_user !== undefined ||
       this.wsConnection
@@ -745,12 +727,12 @@ export class FeedsClient extends FeedsApi {
     };
   }
 
-  async ownCapabilitiesBatch(request: OwnCapabilitiesBatchRequest) {
-    const response = await super.ownCapabilitiesBatch(request);
-    const feedResponses = Object.entries(response.capabilities).map(
-      ([feed, own_capabilities]) => ({
+  async ownBatch(request: OwnBatchRequest) {
+    const response = await super.ownBatch(request);
+    const feedResponses = Object.entries(response.data).map(
+      ([feed, ownFields]) => ({
         feed,
-        own_capabilities,
+        own_capabilities: ownFields.own_capabilities,
       }),
     );
     this.hydrateCapabilitiesCache(feedResponses);
@@ -784,36 +766,41 @@ export class FeedsClient extends FeedsApi {
   // For follow API endpoints we update the state after HTTP response to allow queryFeeds with watch: false
   async follow(request: FollowRequest) {
     const response = await super.follow(request);
-
-    [
-      response.follow.source_feed.feed,
-      response.follow.target_feed.feed,
-    ].forEach((fid) => {
-      const feeds = this.findAllActiveFeedsByFid(fid);
-      feeds.forEach((f) => handleFollowCreated.bind(f)(response, false));
-    });
+    this.updateStateFromFollows([response.follow]);
 
     return response;
   }
 
+  /**
+   * @deprecated Use getOrCreateFollows instead
+   * @param request
+   * @returns
+   */
   async followBatch(request: FollowBatchRequest) {
     const response = await super.followBatch(request);
+    this.updateStateFromFollows(response.follows);
 
-    response.follows.forEach((follow) => {
-      const feeds = this.findAllActiveFeedsByFid(follow.source_feed.feed);
-      feeds.forEach((f) => handleFollowCreated.bind(f)({ follow }, false));
-    });
+    return response;
+  }
+
+  async getOrCreateFollows(request: FollowBatchRequest) {
+    const response = await super.getOrCreateFollows(request);
+
+    this.updateStateFromFollows(response.created);
 
     return response;
   }
 
-  async unfollow(request: FollowRequest) {
+  async unfollow(request: { source: string; target: string }) {
     const response = await super.unfollow(request);
+    this.updateStateFromUnfollows([response.follow]);
 
-    [request.source, request.target].forEach((fid) => {
-      const feeds = this.findAllActiveFeedsByFid(fid);
-      feeds.forEach((f) => handleFollowDeleted.bind(f)(response, false));
-    });
+    return response;
+  }
+
+  async getOrCreateUnfollows(request: UnfollowBatchRequest) {
+    const response = await super.getOrCreateUnfollows(request);
+    this.updateStateFromUnfollows(response.follows);
 
     return response;
   }
@@ -942,4 +929,24 @@ export class FeedsClient extends FeedsApi {
         .map((a) => getFeed.call(a)!),
     ];
   }
+
+  private updateStateFromFollows(follows: FollowResponse[]) {
+    follows.forEach((follow) => {
+      const feeds = [
+        ...this.findAllActiveFeedsByFid(follow.source_feed.feed),
+        ...this.findAllActiveFeedsByFid(follow.target_feed.feed),
+      ];
+      feeds.forEach((f) => handleFollowCreated.bind(f)({ follow }, false));
+    });
+  }
+
+  private updateStateFromUnfollows(follows: FollowResponse[]) {
+    follows.forEach((follow) => {
+      const feeds = [
+        ...this.findAllActiveFeedsByFid(follow.source_feed.feed),
+        ...this.findAllActiveFeedsByFid(follow.target_feed.feed),
+      ];
+      feeds.forEach((f) => handleFollowDeleted.bind(f)({ follow }, false));
+    });
+  }
 }

package/src/gen/feeds/FeedsApi.ts

@@ -62,8 +62,8 @@ import type {
   ListBlockListResponse,
   ListDevicesResponse,
   MarkActivityRequest,
-  OwnCapabilitiesBatchRequest,
-  OwnCapabilitiesBatchResponse,
+  OwnBatchRequest,
+  OwnBatchResponse,
   PinActivityRequest,
   PinActivityResponse,
   PollOptionResponse,
@@ -104,6 +104,8 @@ import type {
   SingleFollowResponse,
   UnblockUsersRequest,
   UnblockUsersResponse,
+  UnfollowBatchRequest,
+  UnfollowBatchResponse,
   UnfollowResponse,
   UnpinActivityResponse,
   UpdateActivityPartialRequest,
@@ -979,14 +981,14 @@ export class FeedsApi {
   }
 
   async addComment(
-    request: AddCommentRequest,
+    request?: AddCommentRequest,
   ): Promise<StreamResponse<AddCommentResponse>> {
     const body = {
-      object_id: request?.object_id,
-      object_type: request?.object_type,
       comment: request?.comment,
       create_notification_activity: request?.create_notification_activity,
       id: request?.id,
+      object_id: request?.object_id,
+      object_type: request?.object_type,
       parent_id: request?.parent_id,
       skip_enrich_url: request?.skip_enrich_url,
       skip_push: request?.skip_push,
@@ -1621,28 +1623,29 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
-  async ownCapabilitiesBatch(
-    request: OwnCapabilitiesBatchRequest & { connection_id?: string },
-  ): Promise<StreamResponse<OwnCapabilitiesBatchResponse>> {
+  async ownBatch(
+    request: OwnBatchRequest & { connection_id?: string },
+  ): Promise<StreamResponse<OwnBatchResponse>> {
     const queryParams = {
       connection_id: request?.connection_id,
     };
     const body = {
       feeds: request?.feeds,
+      fields: request?.fields,
     };
 
     const response = await this.apiClient.sendRequest<
-      StreamResponse<OwnCapabilitiesBatchResponse>
+      StreamResponse<OwnBatchResponse>
     >(
       'POST',
-      '/api/v2/feeds/feeds/own_capabilities/batch',
+      '/api/v2/feeds/feeds/own/batch',
       undefined,
       queryParams,
       body,
       'application/json',
     );
 
-    decoders.OwnCapabilitiesBatchResponse?.(response.body);
+    decoders.OwnBatchResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
   }
@@ -1783,6 +1786,29 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async getOrCreateFollows(
+    request: FollowBatchRequest,
+  ): Promise<StreamResponse<FollowBatchResponse>> {
+    const body = {
+      follows: request?.follows,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<FollowBatchResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/follows/batch/upsert',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.FollowBatchResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async queryFollows(
     request?: QueryFollowsRequest,
   ): Promise<StreamResponse<QueryFollowsResponse>> {
@@ -1857,6 +1883,29 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async getOrCreateUnfollows(
+    request: UnfollowBatchRequest,
+  ): Promise<StreamResponse<UnfollowBatchResponse>> {
+    const body = {
+      follows: request?.follows,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UnfollowBatchResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/unfollow/batch/upsert',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UnfollowBatchResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async createGuest(
     request: CreateGuestRequest,
   ): Promise<StreamResponse<CreateGuestResponse>> {