@stream-io/feeds-client 0.3.7 → 0.3.9

package/src/bindings/react/hooks/feed-state-hooks/useActivityComments.ts

@@ -0,0 +1,113 @@
+import { useCallback, useMemo } from 'react';
+import {
+  type ActivityResponse,
+  type CommentResponse,
+  type Feed,
+  type FeedState,
+  checkHasAnotherPage,
+  type ActivityWithStateUpdates,
+  type ActivityState,
+  type StateStore,
+} from '@self';
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+
+const canLoadComments = (
+  feedOrActivity: Feed | ActivityResponse | ActivityWithStateUpdates,
+): feedOrActivity is ActivityWithStateUpdates | Feed => {
+  return (
+    'loadNextPageCommentReplies' in feedOrActivity &&
+    'loadNextPageActivityComments' in feedOrActivity
+  );
+};
+
+type UseCommentsReturnType<T extends ActivityResponse | CommentResponse> = {
+  comments: NonNullable<
+    FeedState['comments_by_entity_id'][T['id']]
+  >['comments'];
+  comments_pagination: NonNullable<
+    FeedState['comments_by_entity_id'][T['id']]
+  >['pagination'];
+  has_next_page: boolean;
+  is_loading_next_page: boolean;
+  loadNextPage: (
+    request?: T extends CommentResponse
+      ? Parameters<Feed['loadNextPageCommentReplies']>[1]
+      : Parameters<Feed['loadNextPageActivityComments']>[1],
+  ) => Promise<void>;
+};
+
+export function useActivityComments({
+  feed: feedFromProps,
+  parentComment,
+  activity,
+}: {
+  feed?: Feed;
+  parentComment?: CommentResponse;
+  activity?: ActivityResponse | ActivityWithStateUpdates;
+}) {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+  const feedOrActivity = feed ?? activity;
+
+  if (!feedOrActivity) {
+    throw new Error('Feed or activity is required');
+  }
+
+  if (!canLoadComments(feedOrActivity)) {
+    throw new Error('Feed or activity does not support loading comments');
+  }
+
+  if (!(activity || parentComment)) {
+    throw new Error('Activity or parent comment is required');
+  }
+
+  const entityId = parentComment?.id ?? activity?.id ?? '';
+  const selector = useCallback(
+    (state: FeedState | ActivityState) => ({
+      comments: state.comments_by_entity_id?.[entityId]?.comments,
+      comments_pagination: state.comments_by_entity_id?.[entityId]?.pagination,
+    }),
+    [entityId],
+  );
+
+  const data = useStateStore(
+    feedOrActivity.state as StateStore<FeedState | ActivityState>,
+    selector,
+  );
+
+  const loadNextPage = useCallback<
+    UseCommentsReturnType<ActivityResponse | CommentResponse>['loadNextPage']
+  >(
+    (request) => {
+      if (parentComment) {
+        return feedOrActivity.loadNextPageCommentReplies(
+          parentComment,
+          request,
+        );
+      } else {
+        if (activity && canLoadComments(activity)) {
+          return activity.loadNextPageActivityComments(request);
+        } else if (feed) {
+          return feed.loadNextPageActivityComments(activity?.id ?? '', request);
+        } else {
+          throw new Error('Activity or feed is required');
+        }
+      }
+    },
+    [feedOrActivity, feed, parentComment, activity],
+  );
+
+  return useMemo(() => {
+    return {
+      ...data,
+      has_next_page: checkHasAnotherPage(
+        data.comments,
+        data.comments_pagination?.next,
+      ),
+      is_loading_next_page:
+        data?.comments_pagination?.loading_next_page ?? false,
+      loadNextPage,
+    };
+  }, [data, loadNextPage]);
+}

package/src/bindings/react/hooks/feed-state-hooks/useComments.ts

@@ -27,6 +27,10 @@ type UseCommentsReturnType<T extends ActivityResponse | CommentResponse> = {
   ) => Promise<void>;
 };
 
+/**
+ * @deprecated Use `useActivityComments` instead.
+ * @param
+ */
 export function useComments<T extends CommentParent>(_: {
   feed: Feed;
   parent: T;

package/src/bindings/react/hooks/feed-state-hooks/useOwnCapabilities.ts

@@ -12,16 +12,19 @@ export const useOwnCapabilities = (feedFromProps?: Feed) => {
   const feed = feedFromProps ?? feedFromContext;
   const fid = feed?.feed;
 
-  const selector = useCallback((currentState: FeedsClientState) => {
-    if (!fid) {
-      return { feedOwnCapabilities: stableEmptyArray };
-    }
+  const selector = useCallback(
+    (currentState: FeedsClientState) => {
+      if (!fid) {
+        return { feedOwnCapabilities: stableEmptyArray };
+      }
 
-    return {
-      feedOwnCapabilities:
-        currentState.own_capabilities_by_fid[fid] ?? stableEmptyArray,
-    };
-  }, [fid]);
+      return {
+        feedOwnCapabilities:
+          currentState.own_capabilities_by_fid[fid] ?? stableEmptyArray,
+      };
+    },
+    [fid],
+  );
 
   const { feedOwnCapabilities = stableEmptyArray } =
     useStateStore(client?.state, selector) ?? {};

package/src/bindings/react/hooks/useCreateFeedsClient.ts

@@ -43,7 +43,6 @@ export const useCreateFeedsClient = ({
       .connectUser(cachedUserData, tokenOrProvider)
       .then(() => {
         setError(null);
-        console.log('Successfully connected user: ', cachedUserData.id);
       })
       .catch((err) => {
         setError(err);
@@ -60,11 +59,6 @@ export const useCreateFeedsClient = ({
         })
         .catch((err) => {
           setError(err);
-        })
-        .then(() => {
-          console.log(
-            `Connection for user "${cachedUserData.id}" has been closed`,
-          );
         });
     };
   }, [apiKey, cachedUserData, cachedOptions, tokenOrProvider]);

package/src/common/real-time/event-models.ts

@@ -43,7 +43,11 @@ export enum UnhandledErrorType {
   FetchingOwnCapabilitiesOnNewActivity = 'fetching-own-capabilities-on-new-activity',
 }
 
-export type SyncFailure = { feed: string; reason: unknown };
+export type SyncFailure = {
+  feed: string;
+  reason: unknown;
+  activity_id?: string;
+};
 
 export type UnhandledErrorEvent = {
   type: 'errors.unhandled';

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

@@ -82,6 +82,17 @@ export function handleActivityUpdated(
     pinned_activities: currentPinnedActivities,
   } = this.currentState;
 
+  const currentActivity = currentActivities?.find(
+    (a) => a.id === payload.activity.id,
+  );
+  if (
+    !payload.activity.current_feed &&
+    payload.activity.feeds.length === 1 &&
+    currentActivity?.current_feed
+  ) {
+    payload.activity.current_feed = currentActivity.current_feed;
+  }
+
   const [result1, result2] = [
     this.hasActivity(payload.activity.id)
       ? updateActivityInState(payload, currentActivities)

package/src/feed/feed.ts

@@ -59,7 +59,12 @@ import type {
   LoadingStates,
   PagerResponseWithLoadingStates,
 } from '../types';
-import { checkHasAnotherPage, Constants, uniqueArrayMerge } from '../utils';
+import {
+  checkHasAnotherPage,
+  Constants,
+  feedsLoggerSystem,
+  uniqueArrayMerge,
+} from '../utils';
 import { handleActivityFeedback } from './event-handlers/activity/handle-activity-feedback';
 import { deepEqual } from '../utils/deep-equal';
 
@@ -595,13 +600,15 @@ export class Feed extends FeedApi {
   }
 
   public async loadNextPageActivityComments(
-    activity: ActivityResponse,
+    activity: ActivityResponse | string,
     request?: Partial<
       Omit<GetCommentsRequest, 'object_id' | 'object_type' | 'next'>
     >,
   ) {
     const currentEntityState =
-      this.currentState.comments_by_entity_id[activity.id];
+      this.currentState.comments_by_entity_id[
+        typeof activity === 'string' ? activity : activity.id
+      ];
     const currentPagination = currentEntityState?.pagination;
     const currentNextCursor = currentPagination?.next;
     const currentSort = currentPagination?.sort;
@@ -617,13 +624,14 @@ export class Feed extends FeedApi {
       return;
     }
 
+    const entityId = typeof activity === 'string' ? activity : activity.id;
     await this.loadNextPageComments({
-      entityId: activity.id,
+      entityId: entityId,
       base: () =>
         this.client.getComments({
           ...request,
           sort,
-          object_id: activity.id,
+          object_id: entityId,
           object_type: 'activity',
           next: currentNextCursor,
         }),
@@ -929,7 +937,9 @@ export class Feed extends FeedApi {
     }
 
     if (typeof eventHandler === 'undefined') {
-      console.warn(`Received unknown event type: ${event.type}`, event);
+      feedsLoggerSystem
+        .getLogger('event-dispatcher')
+        .warn(`Received unknown feed event, type: ${event.type}`, event);
     }
 
     this.eventDispatcher.dispatch(event);

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

@@ -0,0 +1,42 @@
+import { Feed } from '../feed';
+import type { FeedsClient } from './feeds-client';
+
+export function connectActivityToFeed(
+  this: FeedsClient,
+  {
+    fid,
+  }: {
+    fid: string;
+  },
+) {
+  const [group, id] = fid.split(':');
+  const activeFeed = this.activeFeeds[fid];
+
+  const feed = new Feed(
+    this,
+    group,
+    id,
+    undefined,
+    activeFeed?.currentState.watch,
+  );
+
+  return feed;
+}
+
+export function isAnyFeedWatched(this: FeedsClient, fids: string[]) {
+  for (const fid of fids) {
+    const feed = this.activeFeeds[fid];
+    if (feed && feed.currentState.last_get_or_create_request_config?.watch) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function disconnectActivityFromFeed(this: FeedsClient, id: string) {
+  const activeFeed = this.activeActivities[id];
+  if (activeFeed) {
+    delete this.activeActivities[id];
+  }
+}