@stream-io/feeds-client 0.3.37 → 0.3.39

package/src/bindings/react/index.ts

@@ -11,6 +11,7 @@ export * from './hooks/search-state-hooks';
 
 export * from './contexts/StreamFeedsContext';
 export * from './contexts/StreamFeedContext';
+export * from './contexts/StreamActivityWithStateUpdatesContext';
 export * from './contexts/StreamSearchContext';
 export * from './contexts/StreamSearchResultsContext';
 
@@ -18,5 +19,6 @@ export * from './contexts/StreamSearchResultsContext';
 
 export * from './wrappers/StreamFeeds';
 export * from './wrappers/StreamFeed';
+export * from './wrappers/StreamActivityWithStateUpdates';
 export * from './wrappers/StreamSearch';
 export * from './wrappers/StreamSearchResults';

package/src/bindings/react/wrappers/StreamActivityWithStateUpdates.tsx

@@ -0,0 +1,24 @@
+import type { PropsWithChildren } from 'react';
+
+import { StreamActivityWithStateUpdatesContext } from '../contexts/StreamActivityWithStateUpdatesContext';
+import type { ActivityWithStateUpdates } from '../../../activity-with-state-updates/activity-with-state-updates';
+
+/**
+ * The props for the StreamActivityWithStateUpdates component. It accepts an `ActivityWithStateUpdates` instance.
+ */
+export type StreamActivityWithStateUpdatesProps = {
+  activityWithStateUpdates: ActivityWithStateUpdates;
+};
+
+export const StreamActivityWithStateUpdates = ({
+  activityWithStateUpdates,
+  children,
+}: PropsWithChildren<StreamActivityWithStateUpdatesProps>) => {
+  return (
+    <StreamActivityWithStateUpdatesContext.Provider value={activityWithStateUpdates}>
+      {children}
+    </StreamActivityWithStateUpdatesContext.Provider>
+  );
+};
+
+StreamActivityWithStateUpdates.displayName = 'StreamActivityWithStateUpdates';

package/src/feed/feed.ts

@@ -219,6 +219,7 @@ export class Feed extends FeedApi {
     'user.reactivated': Feed.noop,
     'user.updated': Feed.noop,
     'feeds.activity.feedback': handleActivityFeedback.bind(this),
+    'feeds.activity.restored': Feed.noop,
   };
 
   protected eventDispatcher: EventDispatcher<WSEvent['type'], WSEvent> =
@@ -872,12 +873,19 @@ export class Feed extends FeedApi {
     return response;
   }
 
-  async unfollow(feedOrFid: Feed | string) {
+  async unfollow(
+    feedOrFid: Feed | string,
+    options?: Omit<
+      Parameters<typeof this.client.unfollow>[0],
+      'source' | 'target'
+    >,
+  ) {
     const fid = typeof feedOrFid === 'string' ? feedOrFid : feedOrFid.feed;
 
     const response = await this.client.unfollow({
       source: this.feed,
       target: fid,
+      ...options,
     });
 
     return response;

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

@@ -103,6 +103,7 @@ import {
 
 export type FeedsClientState = {
   connected_user: ConnectedUser | undefined;
+  is_anonymous: boolean;
   is_ws_connection_healthy: boolean;
 };
 
@@ -143,10 +144,7 @@ export class FeedsClient extends FeedsApi {
       options,
     );
     super(apiClient);
-    this.state = new StateStore<FeedsClientState>({
-      connected_user: undefined,
-      is_ws_connection_healthy: false,
-    });
+    this.state = new StateStore<FeedsClientState>(this.initialState);
     this.moderation = new ModerationClient(apiClient);
     this.tokenManager = tokenManager;
     this.connectionIdManager = connectionIdManager;
@@ -365,13 +363,25 @@ export class FeedsClient extends FeedsApi {
     }
   }
 
-  connectUser = async (user: UserRequest, tokenProvider?: TokenOrProvider) => {
-    if (
-      this.state.getLatestValue().connected_user !== undefined ||
-      this.wsConnection
-    ) {
-      throw new Error(`Can't connect a new user, call "disconnectUser" first`);
-    }
+  connectAnonymous = () => {
+    this.checkIfUserIsConnected();
+
+    this.connectionIdManager.resolveConnectionidPromise();
+    this.tokenManager.setTokenOrProvider(undefined);
+    this.setGetBatchOwnFieldsThrottlingInterval(
+      this.query_batch_own_fields_throttling_interval,
+    );
+    this.state.partialNext({
+      connected_user: undefined,
+      is_anonymous: true,
+      is_ws_connection_healthy: false,
+    });
+
+    return Promise.resolve();
+  };
+
+  connectUser = async (user: UserRequest, tokenProvider: TokenOrProvider) => {
+    this.checkIfUserIsConnected();
 
     this.tokenManager.setTokenOrProvider(tokenProvider);
 
@@ -487,11 +497,10 @@ export class FeedsClient extends FeedsApi {
     return response;
   };
 
-  deleteComment = async (request: {
-    id: string;
-    hard_delete?: boolean;
-  }): Promise<StreamResponse<DeleteCommentResponse>> => {
-    const response = await super.deleteComment(request);
+  deleteComment = async (
+    ...args: Parameters<FeedsApi['deleteComment']>
+  ): Promise<StreamResponse<DeleteCommentResponse>> => {
+    const response = await super.deleteComment(...args);
     const { activity, comment } = response;
     for (const feed of this.allActiveFeeds) {
       handleCommentDeleted.bind(feed)({ comment }, false);
@@ -532,11 +541,10 @@ export class FeedsClient extends FeedsApi {
     return this.addActivityReaction(request);
   };
 
-  deleteActivityReaction = async (request: {
-    activity_id: string;
-    type: string;
-  }): Promise<StreamResponse<DeleteActivityReactionResponse>> => {
-    const response = await super.deleteActivityReaction(request);
+  deleteActivityReaction = async (
+    ...args: Parameters<FeedsApi['deleteActivityReaction']>
+  ): Promise<StreamResponse<DeleteActivityReactionResponse>> => {
+    const response = await super.deleteActivityReaction(...args);
     for (const feed of this.allActiveFeeds) {
       handleActivityReactionDeleted.bind(feed)(response, false);
     }
@@ -558,11 +566,10 @@ export class FeedsClient extends FeedsApi {
     return response;
   };
 
-  deleteCommentReaction = async (request: {
-    id: string;
-    type: string;
-  }): Promise<StreamResponse<DeleteCommentReactionResponse>> => {
-    const response = await super.deleteCommentReaction(request);
+  deleteCommentReaction = async (
+    ...args: Parameters<FeedsApi['deleteCommentReaction']>
+  ): Promise<StreamResponse<DeleteCommentReactionResponse>> => {
+    const response = await super.deleteCommentReaction(...args);
     for (const feed of this.allActiveFeeds) {
       handleCommentReactionDeleted.bind(feed)(response, false);
     }
@@ -614,10 +621,7 @@ export class FeedsClient extends FeedsApi {
     this.activeActivities = [];
     this.activeFeeds = {};
 
-    this.state.partialNext({
-      connected_user: undefined,
-      is_ws_connection_healthy: false,
-    });
+    this.state.partialNext(this.initialState);
 
     this.cancelGetBatchOwnFieldsTimer();
     clearQueuedFeeds();
@@ -1010,4 +1014,22 @@ export class FeedsClient extends FeedsApi {
       feeds.forEach((f) => handleFollowDeleted.bind(f)({ follow }, false));
     });
   }
+
+  private get initialState() {
+    return {
+      connected_user: undefined,
+      is_anonymous: false,
+      is_ws_connection_healthy: false,
+    };
+  }
+
+  private checkIfUserIsConnected() {
+    if (
+      this.state.getLatestValue().connected_user !== undefined ||
+      this.wsConnection ||
+      this.state.getLatestValue().is_anonymous
+    ) {
+      throw new Error(`Can't connect a new user, call "disconnectUser" first`);
+    }
+  }
 }

package/src/gen/feeds/FeedsApi.ts

@@ -99,6 +99,8 @@ import type {
   RejectFollowRequest,
   RejectFollowResponse,
   Response,
+  RestoreActivityRequest,
+  RestoreActivityResponse,
   SharedLocationResponse,
   SharedLocationsResponse,
   SingleFollowResponse,
@@ -783,6 +785,30 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async restoreActivity(
+    request: RestoreActivityRequest & { id: string },
+  ): Promise<StreamResponse<RestoreActivityResponse>> {
+    const pathParams = {
+      id: request?.id,
+    };
+    const body = {};
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<RestoreActivityResponse>
+    >(
+      'PUT',
+      '/api/v2/feeds/activities/{id}/restore',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.RestoreActivityResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async queryBookmarkFolders(
     request?: QueryBookmarkFoldersRequest,
   ): Promise<StreamResponse<QueryBookmarkFoldersResponse>> {

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

@@ -212,6 +212,17 @@ decoders.ActivityResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ActivityRestoredEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ActivityUnpinnedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1785,6 +1796,13 @@ decoders.ReminderResponseData = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.RestoreActivityResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ReviewQueueItemResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },

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

@@ -34,6 +34,9 @@ const eventDecoderMapping: Record<
   'feeds.activity.removed_from_feed': (data: Record<string, any>) =>
     decoders.ActivityRemovedFromFeedEvent(data),
 
+  'feeds.activity.restored': (data: Record<string, any>) =>
+    decoders.ActivityRestoredEvent(data),
+
   'feeds.activity.unpinned': (data: Record<string, any>) =>
     decoders.ActivityUnpinnedEvent(data),
 

package/src/gen/models/index.ts

@@ -490,6 +490,24 @@ export interface ActivityResponse {
   poll?: PollResponseData;
 }
 
+export interface ActivityRestoredEvent {
+  created_at: Date;
+
+  fid: string;
+
+  activity: ActivityResponse;
+
+  custom: Record<string, any>;
+
+  type: string;
+
+  feed_visibility?: string;
+
+  received_at?: Date;
+
+  user?: UserResponseCommonFields;
+}
+
 export interface ActivitySelectorConfig {
   cutoff_time: Date;
 
@@ -5138,6 +5156,14 @@ export interface RestoreActionRequest {
   decision_reason?: string;
 }
 
+export interface RestoreActivityRequest {}
+
+export interface RestoreActivityResponse {
+  duration: string;
+
+  activity: ActivityResponse;
+}
+
 export interface ReviewQueueItemResponse {
   ai_text_severity: string;
 
@@ -6472,6 +6498,7 @@ export type WSClientEvent =
   | ({
       type: 'feeds.activity.removed_from_feed';
     } & ActivityRemovedFromFeedEvent)
+  | ({ type: 'feeds.activity.restored' } & ActivityRestoredEvent)
   | ({ type: 'feeds.activity.unpinned' } & ActivityUnpinnedEvent)
   | ({ type: 'feeds.activity.updated' } & ActivityUpdatedEvent)
   | ({ type: 'feeds.bookmark.added' } & BookmarkAddedEvent)
@@ -6522,6 +6549,7 @@ export type WSEvent =
   | ({
       type: 'feeds.activity.removed_from_feed';
     } & ActivityRemovedFromFeedEvent)
+  | ({ type: 'feeds.activity.restored' } & ActivityRestoredEvent)
   | ({ type: 'feeds.activity.unpinned' } & ActivityUnpinnedEvent)
   | ({ type: 'feeds.activity.updated' } & ActivityUpdatedEvent)
   | ({ type: 'feeds.bookmark.added' } & BookmarkAddedEvent)