@oxyhq/services 10.3.2 → 10.4.0

package/src/ui/hooks/useFollow.ts

@@ -1,8 +1,10 @@
-import { useCallback, useMemo, useEffect } from 'react';
+import { useCallback, useMemo } from 'react';
+import { useQuery } from '@tanstack/react-query';
 import { useFollowStore } from '../stores/followStore';
 import { useOxy } from '../context/OxyContext';
-import { logger as loggerUtil, type OxyServices, type BulkFollowResult } from '@oxyhq/core';
+import { type OxyServices, type BulkFollowResult, type BulkUnfollowResult } from '@oxyhq/core';
 import { useShallow } from 'zustand/react/shallow';
+import { queryKeys } from './queries/queryKeys';
 
 /**
  * useFollow — Hook for follow state management.
@@ -21,6 +23,9 @@ export const useFollow = (userId?: string | string[]) => {
   const { oxyServices, canUsePrivateApi } = useOxy();
   const userIds = useMemo(() => (Array.isArray(userId) ? userId : userId ? [userId] : []), [userId]);
   const isSingleUser = typeof userId === 'string';
+  // Narrowed single-user id for use in closures (callbacks/queryFn) where TS
+  // can't carry the `isSingleUser` boolean back to a `string` narrowing.
+  const singleUserId: string | undefined = typeof userId === 'string' ? userId : undefined;
 
   // Granular Zustand selectors — only re-render when THIS user's data changes
   const isFollowing = useFollowStore(
@@ -128,16 +133,29 @@ export const useFollow = (userId?: string | string[]) => {
     useFollowStore.getState().setFollowingCount(userId, count);
   }, [isSingleUser, userId]);
 
-  // Auto-fetch counts when hook is used for a single user and counts are missing.
-  useEffect(() => {
-    if (!isSingleUser || !userId) return;
-
-    if ((followerCount === null || followingCount === null) && !isLoadingCounts) {
-      fetchUserCounts().catch((error: unknown) => {
-        loggerUtil.warn('useFollow: fetchUserCounts failed', { component: 'useFollow' }, error);
-      });
-    }
-  }, [isSingleUser, userId, followerCount, followingCount, isLoadingCounts, fetchUserCounts]);
+  // Auto-fetch counts for single-user mode via React Query instead of a manual
+  // useEffect. The Zustand store remains the canonical home for count values
+  // (it is also written by toggleFollowUser / updateCountsFromFollowAction), so
+  // components keep reading `followerCount` / `followingCount` through the
+  // granular selectors above — this query only owns the FETCH lifecycle
+  // (dedup, caching, retry/backoff). It stays disabled until the counts are
+  // actually missing, reproducing the old effect's `(followerCount === null ||
+  // followingCount === null)` gate without a render-phase side effect. The
+  // store action does the network call and writes the counts; the query simply
+  // surfaces the resolved pair as its cached data.
+  useQuery({
+    queryKey: singleUserId ? queryKeys.follow.counts(singleUserId) : queryKeys.follow.all,
+    queryFn: async () => {
+      if (!singleUserId) return null;
+      await useFollowStore.getState().fetchUserCounts(singleUserId, oxyServices);
+      const state = useFollowStore.getState();
+      return {
+        followers: state.followerCounts[singleUserId] ?? null,
+        following: state.followingCounts[singleUserId] ?? null,
+      };
+    },
+    enabled: !!singleUserId && followerCount === null && followingCount === null,
+  });
 
   // Multi-user callbacks
   const toggleFollowForUser = useCallback(async (targetUserId: string) => {
@@ -167,6 +185,12 @@ export const useFollow = (userId?: string | string[]) => {
     return useFollowStore.getState().followManyUsers(userIds, oxyServices);
   }, [canUsePrivateApi, userIds, oxyServices]);
 
+  // Bulk unfollow — unfollows ALL users in ONE network call (idempotent; never follows).
+  const unfollowAllUsers = useCallback(async (): Promise<BulkUnfollowResult> => {
+    if (!canUsePrivateApi) throw new Error('Authentication is required to unfollow users');
+    return useFollowStore.getState().unfollowManyUsers(userIds, oxyServices);
+  }, [canUsePrivateApi, userIds, oxyServices]);
+
   const clearErrorForUser = useCallback((targetUserId: string) => {
     useFollowStore.getState().clearFollowError(targetUserId);
   }, []);
@@ -201,6 +225,7 @@ export const useFollow = (userId?: string | string[]) => {
     fetchStatusForUser,
     fetchAllStatuses,
     followAllUsers,
+    unfollowAllUsers,
     clearErrorForUser,
     isAnyLoading: multiUserLoadingState.isAnyLoading,
     hasAnyError: multiUserLoadingState.hasAnyError,

package/src/ui/stores/followStore.ts

@@ -1,5 +1,5 @@
 import { create } from 'zustand';
-import type { OxyServices, BulkFollowResult } from '@oxyhq/core';
+import type { OxyServices, BulkFollowResult, BulkUnfollowResult } from '@oxyhq/core';
 
 interface FollowState {
   followingUsers: Record<string, boolean>;
@@ -18,6 +18,8 @@ interface FollowState {
   toggleFollowUser: (userId: string, oxyServices: OxyServices, isCurrentlyFollowing: boolean) => Promise<void>;
   // Bulk follow — follows MANY users in one network call; never unfollows.
   followManyUsers: (userIds: string[], oxyServices: OxyServices) => Promise<BulkFollowResult>;
+  // Bulk unfollow — unfollows MANY users in one network call; idempotent, never follows.
+  unfollowManyUsers: (userIds: string[], oxyServices: OxyServices) => Promise<BulkUnfollowResult>;
   // New methods for follower counts
   setFollowerCount: (userId: string, count: number) => void;
   setFollowingCount: (userId: string, count: number) => void;
@@ -172,6 +174,50 @@ export const useFollowStore = create<FollowState>((set: any, get: any) => ({
       throw error;
     }
   },
+  unfollowManyUsers: async (userIds: string[], oxyServices: OxyServices): Promise<BulkUnfollowResult> => {
+    set((state: FollowState) => {
+      const loadingUsers = { ...state.loadingUsers };
+      const errors = { ...state.errors };
+      for (const uid of userIds) {
+        loadingUsers[uid] = true;
+        errors[uid] = null;
+      }
+      return { loadingUsers, errors };
+    });
+    try {
+      const result = await oxyServices.unfollowUsers(userIds);
+      set((state: FollowState) => {
+        const followingUsers = { ...state.followingUsers };
+        const loadingUsers = { ...state.loadingUsers };
+        const errors = { ...state.errors };
+        for (const uid of userIds) {
+          loadingUsers[uid] = false;
+        }
+        for (const entry of result.results) {
+          if (entry.success) {
+            followingUsers[entry.userId] = false;
+            errors[entry.userId] = null;
+          } else {
+            errors[entry.userId] = 'Failed to update follow status';
+          }
+        }
+        return { followingUsers, loadingUsers, errors };
+      });
+      return result;
+    } catch (error: unknown) {
+      const message = (error instanceof Error ? error.message : null) || 'Failed to update follow status';
+      set((state: FollowState) => {
+        const loadingUsers = { ...state.loadingUsers };
+        const errors = { ...state.errors };
+        for (const uid of userIds) {
+          loadingUsers[uid] = false;
+          errors[uid] = message;
+        }
+        return { loadingUsers, errors };
+      });
+      throw error;
+    }
+  },
   setFollowerCount: (userId: string, count: number) => set((state: FollowState) => ({
     followerCounts: { ...state.followerCounts, [userId]: count },
   })),

package/src/ui/types/navigation.ts

@@ -63,4 +63,21 @@ export interface OxyProviderProps {
     authWebUrl?: string;
     authRedirectUri?: string;
     queryClient?: QueryClient;
+    /**
+     * When `true`, skips ONLY the terminal SSO bounce in the web cold-boot
+     * chain — the force-redirect to `auth.<apex>/sso?prompt=none` that fires
+     * for a visitor with no recoverable local session. This lets a truly
+     * anonymous user keep browsing instead of being bounced to the central
+     * IdP (e.g. a marketplace that allows anonymous browsing like eBay /
+     * Shop.app).
+     *
+     * Session restore still runs in full: the callback consume, FedCM silent,
+     * first-party `/auth/silent` iframe, stored-session bearer, and
+     * cookie-restore steps all execute — so a returning signed-in user is
+     * still silently restored. Only the force-bounce for a genuinely
+     * anonymous visitor is suppressed.
+     *
+     * Default `false` (current behavior: the bounce fires).
+     */
+    disableAutoSso?: boolean;
 }