@oxyhq/services 10.3.3 → 10.5.0

package/src/ui/context/OxyContext.tsx

@@ -161,6 +161,16 @@ export interface OxyContextProviderProps {
    * for the cross-app device sign-in flow. See {@link OxyContextState.clientId}.
    */
   clientId?: string;
+  /**
+   * When `true`, skips ONLY the terminal `sso-bounce` cold-boot step — the
+   * force-redirect to `auth.<apex>/sso?prompt=none` that fires for a visitor
+   * with no recoverable local session. Every other cold-boot step still runs
+   * (callback consume, FedCM silent, `/auth/silent` iframe, stored-session,
+   * cookie-restore), so a returning signed-in user is still silently
+   * restored; only the bounce for a truly anonymous visitor is suppressed.
+   * Default `false`.
+   */
+  disableAutoSso?: boolean;
   onAuthStateChange?: (user: User | null) => void;
   onError?: (error: ApiError) => void;
 }
@@ -254,6 +264,39 @@ const COOKIE_RESTORE_TIMEOUT = 3000;
  */
 const COLD_BOOT_OVERALL_DEADLINE = 20000;
 
+/**
+ * Per-session timeout (ms) for the parallel stored-session validation in
+ * `restoreStoredSession`. Each `validateSession` call races against this timer
+ * so a single slow/offline session never blocks the whole startup validation
+ * sweep — sessions that don't answer in time resolve to `null` (treated as
+ * unvalidated) and the remaining sessions still settle.
+ */
+const VALIDATION_TIMEOUT = 8000;
+
+/**
+ * Fallback client-session validity window (ms) — 7 days — applied when a
+ * restored account/session does not carry an explicit `expiresAt`. This is only
+ * a local display/bookkeeping hint for the multi-session store; the server
+ * remains the source of truth for actual session expiry. Used in the refresh
+ * cookie restore, stored-session restore, and web-SSO session paths.
+ */
+const DEFAULT_SESSION_VALIDITY_MS = 7 * 24 * 60 * 60 * 1000;
+
+/**
+ * Minimum interval (ms) between visibility-driven IdP `/auth/session-check`
+ * probes. Debounces the hidden-iframe session check so rapid tab focus/blur
+ * cycles can't spawn a check-iframe storm; at most one probe runs per window.
+ */
+const IDP_SESSION_CHECK_COOLDOWN = 30000;
+
+/**
+ * Hard timeout (ms) for a single visibility-driven IdP `/auth/session-check`
+ * iframe. If the IdP never posts a `oxy-session-check` message back, the iframe
+ * and its listener are torn down after this budget so a non-responsive check
+ * can never leak an iframe or a `message` listener.
+ */
+const IDP_SESSION_CHECK_TIMEOUT = 5000;
+
 function getHttpStatus(error: unknown): number | undefined {
   if (!error || typeof error !== 'object') {
     return undefined;
@@ -367,6 +410,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   authRedirectUri,
   storageKeyPrefix = 'oxy_session',
   clientId: clientIdProp,
+  disableAutoSso = false,
   onAuthStateChange,
   onError,
 }) => {
@@ -849,7 +893,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     const clientSessions: ClientSession[] = snapshot.accounts.map((account) => ({
       sessionId: account.sessionId,
       deviceId: '',
-      expiresAt: account.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+      expiresAt: account.expiresAt || new Date(now.getTime() + DEFAULT_SESSION_VALIDITY_MS).toISOString(),
       lastActive: now.toISOString(),
       userId: account.user?.id,
       isCurrent: account.sessionId === activeAccount.sessionId,
@@ -906,9 +950,8 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     let validSessions: ClientSession[] = [];
 
     if (storedSessionIds.length > 0) {
-      // Validate all sessions in parallel (with 8s timeout per session) to avoid
+      // Validate all sessions in parallel (with a per-session timeout) to avoid
       // sequential blocking that freezes the app on startup
-      const VALIDATION_TIMEOUT = 8000;
       const results = await Promise.allSettled(
         storedSessionIds.map(async (sessionId) => {
           const timeoutPromise = new Promise<null>((resolve) =>
@@ -931,7 +974,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
               const clientSession: ClientSession = {
                 sessionId,
                 deviceId: '',
-                expiresAt: new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+                expiresAt: new Date(now.getTime() + DEFAULT_SESSION_VALIDITY_MS).toISOString(),
                 lastActive: now.toISOString(),
                 userId: validation.user.id?.toString() ?? '',
                 isCurrent: sessionId === storedActiveSessionId,
@@ -1241,6 +1284,13 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
             // still active (loop + self-heal protection).
             id: 'sso-bounce',
             enabled: () => {
+              // Opt-out: when the consumer disabled auto-SSO, never bounce a
+              // truly-anonymous visitor to the central IdP. All other restore
+              // steps already ran above, so a signed-in user is still
+              // recovered; only this terminal force-bounce is suppressed.
+              if (disableAutoSso) {
+                return false;
+              }
               if (!isWebBrowser() || window.top !== window.self) {
                 return false;
               }
@@ -1335,6 +1385,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     restoreStoredSession,
     runSsoReturn,
     markAuthResolved,
+    disableAutoSso,
   ]);
 
   useEffect(() => {
@@ -1456,7 +1507,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     const clientSession = {
       sessionId: session.sessionId,
       deviceId: session.deviceId || '',
-      expiresAt: session.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+      expiresAt: session.expiresAt || new Date(Date.now() + DEFAULT_SESSION_VALIDITY_MS).toISOString(),
       lastActive: new Date().toISOString(),
       userId: session.user.id?.toString() ?? '',
       isCurrent: true,
@@ -1550,9 +1601,9 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     const idpOrigin = resolvedAuthWebUrl || 'https://auth.oxy.so';
 
     const checkIdPSession = () => {
-      // Debounce: check at most once per 30 seconds
+      // Debounce: check at most once per cooldown window
       const now = Date.now();
-      if (now - lastIdPCheckRef.current < 30000) return;
+      if (now - lastIdPCheckRef.current < IDP_SESSION_CHECK_COOLDOWN) return;
       lastIdPCheckRef.current = now;
 
       // Clean up any in-flight check before starting a new one
@@ -1591,7 +1642,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
       window.addEventListener('message', handleMessage);
       document.body.appendChild(iframe);
-      setTimeout(cleanup, 5000); // Timeout after 5s
+      setTimeout(cleanup, IDP_SESSION_CHECK_TIMEOUT);
       pendingIdPCleanupRef.current = cleanup;
     };
 

package/src/ui/hooks/queries/queryKeys.ts

@@ -80,6 +80,12 @@ export const queryKeys = {
     list: () => [...queryKeys.connectedApps.all, 'list'] as const,
   },
 
+  // Follow / social graph queries
+  follow: {
+    all: ['follow'] as const,
+    counts: (userId: string) => [...queryKeys.follow.all, 'counts', userId] as const,
+  },
+
   // Payment / wallet / subscription queries
   payments: {
     all: ['payments'] as const,

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, type BulkUnfollowResult } 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) => {