@oxyhq/services 5.24.0 → 5.26.0

package/src/core/mixins/OxyServices.fedcm.ts

@@ -1,6 +1,9 @@
 import type { OxyServicesBase } from '../OxyServices.base';
 import { OxyAuthenticationError } from '../OxyServices.errors';
 import type { SessionLoginResponse } from '../../models/session';
+import { createDebugLogger } from '../../shared/utils/debugUtils';
+
+const debug = createDebugLogger('FedCM');
 
 export interface FedCMAuthOptions {
   nonce?: string;
@@ -99,9 +102,7 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
       const nonce = options.nonce || this.generateNonce();
       const clientId = this.getClientId();
 
-      if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        console.log('[FedCM] Interactive sign-in: Requesting credential for', clientId);
-      }
+      debug.log('Interactive sign-in: Requesting credential for', clientId);
 
       // Request credential from browser's native identity flow
       const credential = await this.requestIdentityCredential({
@@ -115,9 +116,7 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
         throw new OxyAuthenticationError('No credential received from browser');
       }
 
-      if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        console.log('[FedCM] Interactive sign-in: Got credential, exchanging for session');
-      }
+      debug.log('Interactive sign-in: Got credential, exchanging for session');
 
       // Exchange FedCM ID token for Oxy session
       const session = await this.exchangeIdTokenForSession(credential.token);
@@ -127,15 +126,11 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
         this.httpService.setTokens((session as any).accessToken);
       }
 
-      if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        console.log('[FedCM] Interactive sign-in: Success!', { userId: (session as any)?.user?.id });
-      }
+      debug.log('Interactive sign-in: Success!', { userId: (session as any)?.user?.id });
 
       return session;
     } catch (error) {
-      if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        console.log('[FedCM] Interactive sign-in failed:', error);
-      }
+      debug.log('Interactive sign-in failed:', error);
       if ((error as any).name === 'AbortError') {
         throw new OxyAuthenticationError('Sign-in was cancelled by user');
       }
@@ -178,19 +173,19 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
    */
   async silentSignInWithFedCM(): Promise<SessionLoginResponse | null> {
     if (!this.isFedCMSupported()) {
-      console.log('[FedCM] Silent SSO: FedCM not supported in this browser');
+      debug.log('Silent SSO: FedCM not supported in this browser');
       return null;
     }
 
     const clientId = this.getClientId();
-    console.log('[FedCM] Silent SSO: Starting for', clientId);
+    debug.log('Silent SSO: Starting for', clientId);
 
     // First try silent mediation (no UI) - works if user previously consented
     let credential: { token: string } | null = null;
 
     try {
       const nonce = this.generateNonce();
-      console.log('[FedCM] Silent SSO: Attempting silent mediation...');
+      debug.log('Silent SSO: Attempting silent mediation...');
 
       credential = await this.requestIdentityCredential({
         configURL: (this.constructor as any).DEFAULT_CONFIG_URL,
@@ -199,19 +194,19 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
         mediation: 'silent',
       });
 
-      console.log('[FedCM] Silent SSO: Silent mediation result:', { hasCredential: !!credential, hasToken: !!credential?.token });
+      debug.log('Silent SSO: Silent mediation result:', { hasCredential: !!credential, hasToken: !!credential?.token });
     } catch (silentError) {
       // Silent mediation failed - this is expected if user hasn't consented before or is in quiet period
       const errorName = silentError instanceof Error ? silentError.name : 'Unknown';
       const errorMessage = silentError instanceof Error ? silentError.message : String(silentError);
-      console.log('[FedCM] Silent SSO: Silent mediation error (will try optional):', { name: errorName, message: errorMessage });
+      debug.log('Silent SSO: Silent mediation error (will try optional):', { name: errorName, message: errorMessage });
     }
 
     // If silent failed, try optional mediation which shows browser UI if needed
     if (!credential || !credential.token) {
       try {
         const nonce = this.generateNonce();
-        console.log('[FedCM] Silent SSO: Trying optional mediation (may show browser UI)...');
+        debug.log('Silent SSO: Trying optional mediation (may show browser UI)...');
 
         credential = await this.requestIdentityCredential({
           configURL: (this.constructor as any).DEFAULT_CONFIG_URL,
@@ -220,55 +215,55 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
           mediation: 'optional',
         });
 
-        console.log('[FedCM] Silent SSO: Optional mediation result:', { hasCredential: !!credential, hasToken: !!credential?.token });
+        debug.log('Silent SSO: Optional mediation result:', { hasCredential: !!credential, hasToken: !!credential?.token });
       } catch (optionalError) {
         const errorName = optionalError instanceof Error ? optionalError.name : 'Unknown';
         const errorMessage = optionalError instanceof Error ? optionalError.message : String(optionalError);
-        console.log('[FedCM] Silent SSO: Optional mediation also failed:', { name: errorName, message: errorMessage });
+        debug.log('Silent SSO: Optional mediation also failed:', { name: errorName, message: errorMessage });
         return null;
       }
     }
 
     if (!credential || !credential.token) {
-      console.log('[FedCM] Silent SSO: No credential returned (user may have dismissed prompt or is not logged in at IdP)');
+      debug.log('Silent SSO: No credential returned (user may have dismissed prompt or is not logged in at IdP)');
       return null;
     }
 
-    console.log('[FedCM] Silent SSO: Got credential, exchanging for session...');
+    debug.log('Silent SSO: Got credential, exchanging for session...');
 
     let session: SessionLoginResponse;
     try {
       session = await this.exchangeIdTokenForSession(credential.token);
     } catch (exchangeError) {
-      console.error('[FedCM] Silent SSO: Token exchange failed:', exchangeError);
+      debug.error('Silent SSO: Token exchange failed:', exchangeError);
       return null;
     }
 
     // Validate session response has required fields
     if (!session) {
-      console.error('[FedCM] Silent SSO: Exchange returned null session');
+      debug.error('Silent SSO: Exchange returned null session');
       return null;
     }
 
     if (!session.sessionId) {
-      console.error('[FedCM] Silent SSO: Exchange returned session without sessionId:', session);
+      debug.error('Silent SSO: Exchange returned session without sessionId:', session);
       return null;
     }
 
     if (!session.user) {
-      console.error('[FedCM] Silent SSO: Exchange returned session without user:', session);
+      debug.error('Silent SSO: Exchange returned session without user:', session);
       return null;
     }
 
     // Set the access token
     if ((session as any).accessToken) {
       this.httpService.setTokens((session as any).accessToken);
-      console.log('[FedCM] Silent SSO: Access token set');
+      debug.log('Silent SSO: Access token set');
     } else {
-      console.warn('[FedCM] Silent SSO: No accessToken in session response');
+      debug.warn('Silent SSO: No accessToken in session response');
     }
 
-    console.log('[FedCM] Silent SSO: Success!', {
+    debug.log('Silent SSO: Success!', {
       sessionId: session.sessionId?.substring(0, 8) + '...',
       userId: session.user?.id
     });
@@ -296,7 +291,7 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
     const requestedMediation = options.mediation || 'optional';
     const isInteractive = requestedMediation !== 'silent';
 
-    console.log('[FedCM] requestIdentityCredential called:', {
+    debug.log('requestIdentityCredential called:', {
       mediation: requestedMediation,
       clientId: options.clientId,
       inProgress: fedCMRequestInProgress,
@@ -304,7 +299,7 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
 
     // If a request is already in progress...
     if (fedCMRequestInProgress && fedCMRequestPromise) {
-      console.log('[FedCM] Request already in progress, waiting...');
+      debug.log('Request already in progress, waiting...');
       // If current request is silent and new request is interactive,
       // wait for silent to finish, then make the interactive request
       if (currentMediationMode === 'silent' && isInteractive) {
@@ -332,13 +327,13 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
       ? (this.constructor as any).FEDCM_SILENT_TIMEOUT
       : (this.constructor as any).FEDCM_TIMEOUT;
     const timeout = setTimeout(() => {
-      console.log('[FedCM] Request timed out after', timeoutMs, 'ms (mediation:', requestedMediation + ')');
+      debug.log('Request timed out after', timeoutMs, 'ms (mediation:', requestedMediation + ')');
       controller.abort();
     }, timeoutMs);
 
     fedCMRequestPromise = (async () => {
       try {
-        console.log('[FedCM] Calling navigator.credentials.get with mediation:', requestedMediation);
+        debug.log('Calling navigator.credentials.get with mediation:', requestedMediation);
         // Type assertion needed as FedCM types may not be in all TypeScript versions
         const credential = (await (navigator.credentials as any).get({
           identity: {
@@ -359,23 +354,23 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
           signal: controller.signal,
         })) as any;
 
-        console.log('[FedCM] navigator.credentials.get returned:', {
+        debug.log('navigator.credentials.get returned:', {
           hasCredential: !!credential,
           type: credential?.type,
           hasToken: !!credential?.token,
         });
 
         if (!credential || credential.type !== 'identity') {
-          console.log('[FedCM] No valid identity credential returned');
+          debug.log('No valid identity credential returned');
           return null;
         }
 
-        console.log('[FedCM] Got valid identity credential with token');
+        debug.log('Got valid identity credential with token');
         return { token: credential.token };
       } catch (error) {
         const errorName = error instanceof Error ? error.name : 'Unknown';
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.log('[FedCM] navigator.credentials.get error:', { name: errorName, message: errorMessage });
+        debug.log('navigator.credentials.get error:', { name: errorName, message: errorMessage });
         throw error;
       } finally {
         clearTimeout(timeout);
@@ -397,9 +392,9 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
    * @private
    */
   public async exchangeIdTokenForSession(idToken: string): Promise<SessionLoginResponse> {
-    console.log('[FedCM] exchangeIdTokenForSession: Starting exchange...');
-    console.log('[FedCM] exchangeIdTokenForSession: Token length:', idToken?.length);
-    console.log('[FedCM] exchangeIdTokenForSession: Token preview:', idToken?.substring(0, 50) + '...');
+    debug.log('exchangeIdTokenForSession: Starting exchange...');
+    debug.log('exchangeIdTokenForSession: Token length:', idToken?.length);
+    debug.log('exchangeIdTokenForSession: Token preview:', idToken?.substring(0, 50) + '...');
 
     try {
       const response = await this.makeRequest<SessionLoginResponse>(
@@ -409,7 +404,7 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
         { cache: false }
       );
 
-      console.log('[FedCM] exchangeIdTokenForSession: Response received:', {
+      debug.log('exchangeIdTokenForSession: Response received:', {
         hasResponse: !!response,
         hasSessionId: !!(response as any)?.sessionId,
         hasUser: !!(response as any)?.user,
@@ -421,7 +416,7 @@ export function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T)
 
       return response;
     } catch (error) {
-      console.error('[FedCM] exchangeIdTokenForSession: Error:', {
+      debug.error('exchangeIdTokenForSession: Error:', {
         name: error instanceof Error ? error.name : 'Unknown',
         message: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : undefined,

package/src/core/mixins/OxyServices.popup.ts

@@ -1,6 +1,9 @@
 import type { OxyServicesBase } from '../OxyServices.base';
 import { OxyAuthenticationError } from '../OxyServices.errors';
 import type { SessionLoginResponse } from '../../models/session';
+import { createDebugLogger } from '../../shared/utils/debugUtils';
+
+const debug = createDebugLogger('PopupAuth');
 
 export interface PopupAuthOptions {
   width?: number;
@@ -125,7 +128,7 @@ export function OxyServicesPopupAuthMixin<T extends typeof OxyServicesBase>(Base
             (session as any).user = userData;
           }
         } catch (userError) {
-          console.warn('[PopupAuth] Failed to fetch user data:', userError);
+          debug.warn('Failed to fetch user data:', userError);
           // Continue without user data - caller can fetch separately
         }
       }
@@ -261,7 +264,7 @@ export function OxyServicesPopupAuthMixin<T extends typeof OxyServicesBase>(Base
 
         // Log all messages for debugging
         if (event.data && typeof event.data === 'object' && event.data.type) {
-          console.log('[PopupAuth] Message received:', {
+          debug.log('Message received:', {
             origin: event.origin,
             expectedOrigin: authUrl,
             type: event.data.type,
@@ -281,12 +284,12 @@ export function OxyServicesPopupAuthMixin<T extends typeof OxyServicesBase>(Base
           return;
         }
 
-        console.log('[PopupAuth] Valid auth response:', { state, expectedState, hasSession: !!session, error });
+        debug.log('Valid auth response:', { state, expectedState, hasSession: !!session, error });
 
         // Verify state parameter to prevent CSRF attacks
         if (state !== expectedState) {
           cleanup();
-          console.error('[PopupAuth] State mismatch');
+          debug.error('State mismatch');
           reject(new OxyAuthenticationError('Invalid state parameter. Possible CSRF attack.'));
           return;
         }
@@ -294,13 +297,13 @@ export function OxyServicesPopupAuthMixin<T extends typeof OxyServicesBase>(Base
         cleanup();
 
         if (error) {
-          console.error('[PopupAuth] Auth error:', error);
+          debug.error('Auth error:', error);
           reject(new OxyAuthenticationError(error));
         } else if (session) {
-          console.log('[PopupAuth] Session received successfully');
+          debug.log('Session received successfully');
           resolve(session);
         } else {
-          console.error('[PopupAuth] No session in response');
+          debug.error('No session in response');
           reject(new OxyAuthenticationError('No session received from authentication server'));
         }
       };

package/src/index.ts

@@ -39,6 +39,9 @@ export type { AuthState, AuthActions, UseAuthReturn } from './ui/hooks/useAuth';
 // Streamlined provider with built-in bottom sheet
 export { default as OxyProvider } from './ui/components/OxyProvider';
 
+// Font loading utility
+export { FontLoader } from './ui/components/FontLoader';
+
 // Web-only provider (no React Native dependencies)
 export { default as WebOxyProvider } from './ui/components/WebOxyProvider';
 
@@ -114,7 +117,7 @@ export type {
   SecurityEventType,
   SecurityEventSeverity,
   SecurityActivity,
-  SecurityActivityResponse
+  SecurityActivityResponse,
 } from './models/interfaces';
 
 // Export security constants
@@ -145,6 +148,7 @@ export {
 export { useSessionSocket } from './ui/hooks/useSessionSocket';
 export { useAssets, setOxyAssetInstance } from './ui/hooks/useAssets';
 export { useFileDownloadUrl, setOxyFileUrlInstance } from './ui/hooks/useFileDownloadUrl';
+export { useFollow, useFollowerCounts } from './ui/hooks/useFollow';
 
 // UI hooks - Query hooks (TanStack Query)
 export {
@@ -204,6 +208,10 @@ export {
 } from './ui/utils/authHelpers';
 export type { HandleApiErrorOptions } from './ui/utils/authHelpers';
 
+// Error handlers
+export { handleAuthError, isInvalidSessionError, isTimeoutOrNetworkError, extractErrorMessage } from './ui/utils/errorHandlers';
+export type { HandleAuthErrorOptions } from './ui/utils/errorHandlers';
+
 // File filtering hook
 export { useFileFiltering } from './ui/hooks/useFileFiltering';
 export type { ViewMode, SortBy, SortOrder } from './ui/hooks/useFileFiltering';
@@ -212,19 +220,69 @@ export type { ViewMode, SortBy, SortOrder } from './ui/hooks/useFileFiltering';
 export { OxySignInButton } from './ui/components/OxySignInButton';
 export { OxyLogo, FollowButton } from './ui';
 
-// New consolidated utilities
+// Shared utilities (platform-agnostic)
+export {
+  // Color utilities
+  darkenColor,
+  lightenColor,
+  hexToRgb,
+  rgbToHex,
+  withOpacity,
+  isLightColor,
+  getContrastTextColor,
+} from './shared/utils/colorUtils';
+
+export {
+  // Theme utilities
+  normalizeTheme,
+  normalizeColorScheme,
+  getOppositeTheme,
+  systemPrefersDarkMode,
+  getSystemColorScheme,
+} from './shared/utils/themeUtils';
+export type { ThemeValue } from './shared/utils/themeUtils';
+
+export {
+  // Error utilities
+  HttpStatus,
+  getErrorStatus,
+  getErrorMessage,
+  isAlreadyRegisteredError,
+  isUnauthorizedError,
+  isForbiddenError,
+  isNotFoundError,
+  isRateLimitError,
+  isServerError,
+  isNetworkError,
+  isRetryableError,
+} from './shared/utils/errorUtils';
+
+export {
+  // Network utilities
+  DEFAULT_CIRCUIT_BREAKER_CONFIG,
+  createCircuitBreakerState,
+  calculateBackoffInterval,
+  recordFailure,
+  recordSuccess,
+  shouldAllowRequest,
+  delay,
+  withRetry,
+} from './shared/utils/networkUtils';
+export type { CircuitBreakerState, CircuitBreakerConfig } from './shared/utils/networkUtils';
+
+// Other utilities
 export * from './utils/apiUtils';
-export { 
-  ErrorCodes, 
-  createApiError, 
-  handleHttpError, 
+export {
+  ErrorCodes,
+  createApiError,
+  handleHttpError,
   validateRequiredFields,
-  retryWithBackoff 
 } from './utils/errorUtils';
+export { retryAsync } from './utils/asyncUtils';
 export * from './utils/validationUtils';
-export { 
-  logger, 
-  LogLevel, 
+export {
+  logger,
+  LogLevel,
   LogContext,
   logAuth,
   logApi,
@@ -235,4 +293,11 @@ export {
   logPerformance
 } from './utils/loggerUtils';
 export * from './utils/asyncUtils';
-export * from './utils/hookUtils';
+export * from './utils/hookUtils';
+
+// Bottom sheet navigation
+export { showBottomSheet, closeBottomSheet } from './ui/navigation/bottomSheetManager';
+export type { RouteName } from './ui/navigation/routes';
+
+// Sign-in modal
+export { showSignInModal, hideSignInModal } from './ui/components/SignInModal';

package/src/models/session.ts

@@ -23,4 +23,8 @@ export interface SessionLoginResponse {
   deviceId: string;
   expiresAt: string;
   user: MinimalUserData;
+  /** JWT access token for API authentication */
+  accessToken?: string;
+  /** Refresh token for obtaining new access tokens */
+  refreshToken?: string;
 } 

package/src/shared/index.ts

@@ -0,0 +1,82 @@
+/**
+ * OxyServices Shared Module
+ *
+ * Platform-agnostic utilities and helpers that work everywhere:
+ * - Browser (Web, Expo Web)
+ * - React Native (iOS, Android)
+ * - Node.js (Backend)
+ *
+ * This module contains NO React Native or browser-specific dependencies.
+ *
+ * @module shared
+ *
+ * @example
+ * ```ts
+ * import { darkenColor, normalizeTheme, withRetry } from '@oxyhq/services/shared';
+ *
+ * const darkBlue = darkenColor('#0066FF', 0.3);
+ * const theme = normalizeTheme(userPreference);
+ * const data = await withRetry(() => fetchData(), { maxRetries: 3 });
+ * ```
+ */
+
+// Color utilities
+export {
+  darkenColor,
+  lightenColor,
+  hexToRgb,
+  rgbToHex,
+  withOpacity,
+  isLightColor,
+  getContrastTextColor,
+} from './utils/colorUtils';
+
+// Theme utilities
+export {
+  normalizeTheme,
+  normalizeColorScheme,
+  getOppositeTheme,
+  systemPrefersDarkMode,
+  getSystemColorScheme,
+} from './utils/themeUtils';
+export type { ThemeValue } from './utils/themeUtils';
+
+// Error utilities
+export {
+  HttpStatus,
+  getErrorStatus,
+  getErrorMessage,
+  isAlreadyRegisteredError,
+  isUnauthorizedError,
+  isForbiddenError,
+  isNotFoundError,
+  isRateLimitError,
+  isServerError,
+  isNetworkError,
+  isRetryableError,
+} from './utils/errorUtils';
+
+// Network utilities
+export {
+  DEFAULT_CIRCUIT_BREAKER_CONFIG,
+  createCircuitBreakerState,
+  calculateBackoffInterval,
+  recordFailure,
+  recordSuccess,
+  shouldAllowRequest,
+  delay,
+  withRetry,
+} from './utils/networkUtils';
+export type {
+  CircuitBreakerState,
+  CircuitBreakerConfig,
+} from './utils/networkUtils';
+
+// Debug utilities
+export {
+  isDev,
+  debugLog,
+  debugWarn,
+  debugError,
+  createDebugLogger,
+} from './utils/debugUtils';