@oxyhq/services 5.5.8 → 5.6.0

package/src/__tests__/validate-structure.js

@@ -1,91 +0,0 @@
-/**
- * Simple file structure validation for the new Redux architecture
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const requiredFiles = [
-  'src/ui/store/setupOxyStore.ts',
-  'src/ui/store/slices/authSlice.ts',
-  'src/ui/store/slices/followSlice.ts',
-  'src/ui/store/slices/types.ts',
-  'src/ui/store/slices/index.ts',
-  'src/ui/hooks/useOxyFollow.ts',
-  'docs/redux-integration.md',
-  'docs/migration-guide-redux.md',
-];
-
-const requiredExports = [
-  'setupOxyStore',
-  'authSlice',
-  'followSlice',
-  'authReducer',
-  'followReducer',
-  'useOxyFollow',
-];
-
-console.log('🔍 Validating new Redux architecture...\n');
-
-// Check required files exist
-let filesValid = true;
-for (const file of requiredFiles) {
-  const fullPath = path.join(__dirname, '..', '..', file);
-  if (fs.existsSync(fullPath)) {
-    console.log(`✅ ${file}`);
-  } else {
-    console.log(`❌ ${file} - MISSING`);
-    filesValid = false;
-  }
-}
-
-// Check key exports in files
-const setupOxyStoreFile = path.join(__dirname, '..', 'ui', 'store', 'setupOxyStore.ts');
-if (fs.existsSync(setupOxyStoreFile)) {
-  const content = fs.readFileSync(setupOxyStoreFile, 'utf8');
-  if (content.includes('export function setupOxyStore')) {
-    console.log('✅ setupOxyStore function exported');
-  } else {
-    console.log('❌ setupOxyStore function not found');
-    filesValid = false;
-  }
-}
-
-const indexFile = path.join(__dirname, '..', 'ui', 'index.ts');
-if (fs.existsSync(indexFile)) {
-  const content = fs.readFileSync(indexFile, 'utf8');
-  const exportsFound = requiredExports.filter(exp => content.includes(exp));
-  console.log(`✅ Exports found in ui/index.ts: ${exportsFound.join(', ')}`);
-  
-  if (exportsFound.length < requiredExports.length) {
-    const missing = requiredExports.filter(exp => !exportsFound.includes(exp));
-    console.log(`⚠️  Missing exports: ${missing.join(', ')}`);
-  }
-}
-
-// Check main index file
-const mainIndexFile = path.join(__dirname, '..', 'index.ts');
-if (fs.existsSync(mainIndexFile)) {
-  const content = fs.readFileSync(mainIndexFile, 'utf8');
-  if (content.includes('setupOxyStore')) {
-    console.log('✅ setupOxyStore exported from main index');
-  } else {
-    console.log('❌ setupOxyStore not exported from main index');
-    filesValid = false;
-  }
-}
-
-console.log('\n' + '='.repeat(50));
-if (filesValid) {
-  console.log('🎉 All validations passed! New Redux architecture is properly implemented.');
-  console.log('\nKey features:');
-  console.log('- ✅ Framework-agnostic Redux integration');
-  console.log('- ✅ Tree-shakable with setupOxyStore.pick()');
-  console.log('- ✅ Individual slice exports');
-  console.log('- ✅ External store support');
-  console.log('- ✅ Backward compatibility');
-  console.log('- ✅ Comprehensive documentation');
-} else {
-  console.log('❌ Some validations failed. Please check the missing files/exports.');
-  process.exit(1);
-}

package/src/__tests__/validation.js

@@ -1,42 +0,0 @@
-/**
- * Simple validation test for the new Redux architecture
- * This test can be run to ensure the refactoring works correctly
- */
-
-import { configureStore } from '@reduxjs/toolkit';
-
-// Test that setupOxyStore can be imported and used
-try {
-  const { setupOxyStore } = require('../ui/store/setupOxyStore');
-  
-  console.log('✅ setupOxyStore imported successfully');
-  
-  // Test basic usage
-  const reducers = setupOxyStore();
-  console.log('✅ setupOxyStore() returns reducers:', Object.keys(reducers));
-  
-  // Test tree-shaking
-  const authOnly = setupOxyStore.pick('auth');
-  console.log('✅ Tree-shaking works:', Object.keys(authOnly));
-  
-  // Test with configureStore
-  const store = configureStore({
-    reducer: {
-      ...setupOxyStore(),
-      custom: (state = { test: true }) => state,
-    },
-  });
-  
-  const state = store.getState();
-  console.log('✅ Store integration works:', Object.keys(state));
-  
-  // Test individual exports
-  const { authSlice, followSlice } = require('../ui/store/slices');
-  console.log('✅ Individual slices exported:', authSlice.name, followSlice.name);
-  
-  console.log('\n🎉 All tests passed! The new Redux architecture is working correctly.');
-  
-} catch (error) {
-  console.error('❌ Test failed:', error);
-  process.exit(1);
-}

package/src/types/react-redux.d.ts

@@ -1,5 +0,0 @@
-declare module 'react-redux' {
-  export const Provider: any;
-  export function useDispatch(): any;
-  export function useSelector(fn: any): any;
-}

package/src/ui/components/bottomSheet/index.tsx

@@ -1,14 +0,0 @@
-// Re-export bottom sheet components from @gorhom/bottom-sheet
-export {
-  BottomSheetModal,
-  BottomSheetBackdrop,
-  BottomSheetModalProvider,
-  BottomSheetView,
-  BottomSheetScrollView,
-} from '@gorhom/bottom-sheet';
-
-export type {
-  BottomSheetModalProps,
-  BottomSheetBackdropProps,
-} from '@gorhom/bottom-sheet';
-export type { BottomSheetModalMethods as BottomSheetModalRef } from '@gorhom/bottom-sheet/lib/typescript/types';

package/src/ui/hooks/useAuthFetch.ts

@@ -1,238 +0,0 @@
-/**
- * Zero Config Authenticated Fetch Hook
- * 
- * Simple hook that provides fetch-like API with automatic authentication
- * Leverages the existing useOxy hook and OxyProvider infrastructure
- * 
- * Usage:
- *   const authFetch = useAuthFetch();
- *   const response = await authFetch('/api/protected');
- *   const data = await authFetch.get('/api/users');
- */
-
-import { useCallback } from 'react';
-import { useOxy } from '../context/OxyContext';
-
-export interface AuthFetchOptions extends Omit<RequestInit, 'body'> {
-  body?: any; // Allow any type for body, we'll JSON.stringify if needed
-}
-
-export interface AuthFetchAPI {
-  // Main fetch function (drop-in replacement)
-  (input: RequestInfo | URL, init?: AuthFetchOptions): Promise<Response>;
-  
-  // Convenience methods for JSON APIs
-  get: (endpoint: string, options?: AuthFetchOptions) => Promise<any>;
-  post: (endpoint: string, data?: any, options?: AuthFetchOptions) => Promise<any>;
-  put: (endpoint: string, data?: any, options?: AuthFetchOptions) => Promise<any>;
-  delete: (endpoint: string, options?: AuthFetchOptions) => Promise<any>;
-  
-  // Access to auth state and methods
-  isAuthenticated: boolean;
-  user: any;
-  login: (username: string, password: string) => Promise<any>;
-  logout: () => Promise<void>;
-  signUp: (username: string, email: string, password: string) => Promise<any>;
-  
-  // API configuration
-  setApiUrl: (url: string) => void;
-}
-
-/**
- * Hook that provides authenticated fetch functionality
- * Uses the existing OxyServices instance from useOxy context
- */
-export function useAuthFetch(): AuthFetchAPI {
-  const { oxyServices, isAuthenticated, user, login, logout, signUp, activeSessionId, setApiUrl } = useOxy();
-
-  // Validate that we have the required dependencies
-  if (!oxyServices) {
-    throw new Error('useAuthFetch requires OxyServices to be initialized. Make sure your app is wrapped with OxyProvider.');
-  }
-
-  // Main fetch function with automatic auth headers
-  const authFetch = useCallback(async (input: RequestInfo | URL, init?: AuthFetchOptions): Promise<Response> => {
-    if (!oxyServices) {
-      throw new Error('OxyServices not initialized. Make sure to wrap your app in OxyProvider.');
-    }
-
-    const url = resolveURL(input, oxyServices.getBaseURL());
-    const options = await addAuthHeaders(init, oxyServices, activeSessionId || undefined, isAuthenticated);
-
-    try {
-      let response = await fetch(url, options);
-
-      // Handle token expiry and automatic refresh
-      if (response.status === 401 && isAuthenticated) {
-        // Try to refresh token if we have refresh capability
-        if (oxyServices.refreshTokens) {
-          try {
-            await oxyServices.refreshTokens();
-            const retryOptions = await addAuthHeaders(init, oxyServices, activeSessionId || undefined, isAuthenticated);
-            response = await fetch(url, retryOptions);
-          } catch (refreshError) {
-            // Refresh failed, throw authentication error
-            const error = new Error('Authentication expired. Please login again.') as any;
-            error.status = 401;
-            error.code = 'AUTH_EXPIRED';
-            throw error;
-          }
-        }
-      }
-
-      return response;
-    } catch (error) {
-      // Re-throw with additional context if needed
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw new Error('Request failed');
-    }
-  }, [oxyServices, activeSessionId, isAuthenticated]);
-
-  // JSON convenience methods
-  const get = useCallback(async (endpoint: string, options?: AuthFetchOptions) => {
-    const response = await authFetch(endpoint, { ...options, method: 'GET' });
-    return handleJsonResponse(response);
-  }, [authFetch]);
-
-  const post = useCallback(async (endpoint: string, data?: any, options?: AuthFetchOptions) => {
-    const response = await authFetch(endpoint, {
-      ...options,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...options?.headers
-      },
-      body: data ? JSON.stringify(data) : undefined
-    });
-    return handleJsonResponse(response);
-  }, [authFetch]);
-
-  const put = useCallback(async (endpoint: string, data?: any, options?: AuthFetchOptions) => {
-    const response = await authFetch(endpoint, {
-      ...options,
-      method: 'PUT',
-      headers: {
-        'Content-Type': 'application/json',
-        ...options?.headers
-      },
-      body: data ? JSON.stringify(data) : undefined
-    });
-    return handleJsonResponse(response);
-  }, [authFetch]);
-
-  const del = useCallback(async (endpoint: string, options?: AuthFetchOptions) => {
-    const response = await authFetch(endpoint, { ...options, method: 'DELETE' });
-    return handleJsonResponse(response);
-  }, [authFetch]);
-
-  // Attach convenience methods and auth state to the main function
-  const fetchWithMethods = authFetch as AuthFetchAPI;
-  fetchWithMethods.get = get;
-  fetchWithMethods.post = post;
-  fetchWithMethods.put = put;
-  fetchWithMethods.delete = del;
-  fetchWithMethods.isAuthenticated = isAuthenticated;
-  fetchWithMethods.user = user;
-  fetchWithMethods.login = login;
-  fetchWithMethods.logout = logout;
-  fetchWithMethods.signUp = signUp;
-  fetchWithMethods.setApiUrl = setApiUrl;
-
-  return fetchWithMethods;
-}
-
-/**
- * Helper functions
- */
-
-function resolveURL(input: RequestInfo | URL, baseURL: string): string {
-  if (!baseURL) {
-    throw new Error('Base URL not configured. Please provide a baseURL in OxyServices configuration.');
-  }
-
-  const url = input.toString();
-  
-  // If it's already a full URL (http/https), return as is
-  if (url.startsWith('http://') || url.startsWith('https://')) {
-    return url;
-  }
-  
-  // Normalize base URL (remove trailing slash)
-  const normalizedBaseURL = baseURL.replace(/\/$/, '');
-  
-  // If URL starts with /, it's relative to base URL
-  if (url.startsWith('/')) {
-    return `${normalizedBaseURL}${url}`;
-  }
-  
-  // Otherwise, append to base URL with /
-  return `${normalizedBaseURL}/${url}`;
-}
-
-async function addAuthHeaders(init?: AuthFetchOptions, oxyServices?: any, activeSessionId?: string, isAuthenticated?: boolean): Promise<RequestInit> {
-  const headers = new Headers(init?.headers);
-  
-  // Add auth header if user is authenticated
-  if (isAuthenticated && oxyServices && !headers.has('Authorization')) {
-    try {
-      // First try to get regular JWT access token
-      let accessToken = oxyServices.getAccessToken?.();
-      
-      // If no JWT token but we have a secure session, try to get token from session
-      if (!accessToken && activeSessionId) {
-        try {
-          const tokenData = await oxyServices.getTokenBySession(activeSessionId);
-          accessToken = tokenData.accessToken;
-        } catch (error) {
-          // Silent fail - will attempt request without token
-        }
-      }
-      
-      if (accessToken) {
-        headers.set('Authorization', `Bearer ${accessToken}`);
-      }
-    } catch (error) {
-      // Silent fail - will attempt request without token
-    }
-  }
-
-  const body = init?.body;
-  const processedBody = body && typeof body === 'object' && !(body instanceof FormData) && !(body instanceof URLSearchParams)
-    ? JSON.stringify(body)
-    : body;
-
-  return {
-    ...init,
-    headers,
-    body: processedBody
-  };
-}
-
-async function handleJsonResponse(response: Response): Promise<any> {
-  if (!response.ok) {
-    let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-    
-    try {
-      const errorData = await response.json();
-      errorMessage = errorData.message || errorData.error || errorMessage;
-    } catch {
-      // Ignore JSON parsing errors
-    }
-    
-    const error = new Error(errorMessage) as any;
-    error.status = response.status;
-    error.response = response;
-    throw error;
-  }
-
-  try {
-    return await response.json();
-  } catch {
-    // If response isn't JSON, return the response itself
-    return response;
-  }
-}
-
-export default useAuthFetch; 

package/src/ui/hooks/useOxyFollow.ts

@@ -1,188 +0,0 @@
-import { useDispatch, useSelector } from 'react-redux';
-import { useCallback, useMemo } from 'react';
-import { 
-  toggleFollowUser, 
-  setFollowingStatus, 
-  clearFollowError, 
-  fetchFollowStatus,
-  followSelectors
-} from '../store/slices/followSlice';
-import type { FollowState } from '../store/slices/types';
-import { useOxy } from '../context/OxyContext';
-
-// Generic type for state that includes follow slice
-interface StateWithFollow {
-  follow: FollowState;
-}
-
-// Memoized selector to prevent unnecessary re-renders
-const createFollowSelector = (userId: string) => (state: StateWithFollow) => ({
-  isFollowing: followSelectors.selectIsUserFollowed(state, userId),
-  isLoading: followSelectors.selectIsUserLoading(state, userId),
-  error: followSelectors.selectUserError(state, userId),
-});
-
-// Memoized selector for multiple users
-const createMultipleFollowSelector = (userIds: string[]) => (state: StateWithFollow) => {
-  const followData: Record<string, { isFollowing: boolean; isLoading: boolean; error: string | null }> = {};
-  
-  for (const userId of userIds) {
-    followData[userId] = {
-      isFollowing: followSelectors.selectIsUserFollowed(state, userId),
-      isLoading: followSelectors.selectIsUserLoading(state, userId),
-      error: followSelectors.selectUserError(state, userId),
-    };
-  }
-  
-  const followState = state.follow;
-  return {
-    followData,
-    isAnyLoading: userIds.some(uid => followState.loadingUsers[uid]),
-    hasAnyError: userIds.some(uid => followState.errors[uid]),
-    allFollowing: userIds.every(uid => followState.followingUsers[uid]),
-    allNotFollowing: userIds.every(uid => !followState.followingUsers[uid]),
-  };
-};
-
-/**
- * Custom hook for managing follow/unfollow functionality
- * Works with any Redux store that includes the Oxy follow reducer
- * Optimized to prevent unnecessary re-renders
- * Can handle both single user and multiple users
- */
-export const useOxyFollow = (userId?: string | string[]) => {
-  const dispatch = useDispatch();
-  const { oxyServices } = useOxy();
-  
-  // Memoize user IDs to prevent recreation on every render
-  const userIds = useMemo(() => {
-    return Array.isArray(userId) ? userId : userId ? [userId] : [];
-  }, [userId]);
-  
-  const isSingleUser = typeof userId === 'string';
-  
-  // Memoize selectors to prevent recreation
-  const singleUserSelector = useMemo(() => {
-    return isSingleUser && userId ? createFollowSelector(userId) : null;
-  }, [isSingleUser, userId]);
-  
-  const multipleUserSelector = useMemo(() => {
-    return !isSingleUser ? createMultipleFollowSelector(userIds) : null;
-  }, [isSingleUser, userIds]);
-  
-  // Use appropriate selector based on mode
-  const singleUserData = useSelector(singleUserSelector || (() => ({ isFollowing: false, isLoading: false, error: null })));
-  const multipleUserData = useSelector(multipleUserSelector || (() => ({ 
-    followData: {}, 
-    isAnyLoading: false, 
-    hasAnyError: false, 
-    allFollowing: false, 
-    allNotFollowing: true 
-  })));
-
-  // Memoized callbacks to prevent recreation on every render
-  const toggleFollow = useCallback(async () => {
-    if (!isSingleUser || !userId) throw new Error('toggleFollow is only available for single user mode');
-    
-    try {
-      const result = await dispatch(toggleFollowUser({
-        userId,
-        oxyServices,
-        isCurrentlyFollowing: singleUserData.isFollowing
-      })).unwrap();
-      return result;
-    } catch (error) {
-      throw error;
-    }
-  }, [dispatch, userId, oxyServices, singleUserData.isFollowing, isSingleUser]);
-
-  const setFollowStatus = useCallback((following: boolean) => {
-    if (!isSingleUser || !userId) throw new Error('setFollowStatus is only available for single user mode');
-    dispatch(setFollowingStatus({ userId, isFollowing: following }));
-  }, [dispatch, userId, isSingleUser]);
-
-  const fetchStatus = useCallback(async () => {
-    if (!isSingleUser || !userId) throw new Error('fetchStatus is only available for single user mode');
-    
-    try {
-      await dispatch(fetchFollowStatus({ userId, oxyServices })).unwrap();
-    } catch (error) {
-      console.warn(`Failed to fetch follow status for user ${userId}:`, error);
-    }
-  }, [dispatch, userId, oxyServices, isSingleUser]);
-
-  const clearError = useCallback(() => {
-    if (!isSingleUser || !userId) throw new Error('clearError is only available for single user mode');
-    dispatch(clearFollowError(userId));
-  }, [dispatch, userId, isSingleUser]);
-
-  // Multiple user callbacks
-  const toggleFollowForUser = useCallback(async (targetUserId: string) => {
-    const currentState = multipleUserData.followData[targetUserId]?.isFollowing ?? false;
-    try {
-      const result = await dispatch(toggleFollowUser({
-        userId: targetUserId,
-        oxyServices,
-        isCurrentlyFollowing: currentState
-      })).unwrap();
-      return result;
-    } catch (error) {
-      throw error;
-    }
-  }, [dispatch, oxyServices, multipleUserData.followData]);
-
-  const setFollowStatusForUser = useCallback((targetUserId: string, following: boolean) => {
-    dispatch(setFollowingStatus({ userId: targetUserId, isFollowing: following }));
-  }, [dispatch]);
-
-  const fetchStatusForUser = useCallback(async (targetUserId: string) => {
-    try {
-      await dispatch(fetchFollowStatus({ userId: targetUserId, oxyServices })).unwrap();
-    } catch (error) {
-      console.warn(`Failed to fetch follow status for user ${targetUserId}:`, error);
-    }
-  }, [dispatch, oxyServices]);
-
-  const fetchAllStatuses = useCallback(async () => {
-    const promises = userIds.map(uid => 
-      dispatch(fetchFollowStatus({ userId: uid, oxyServices })).unwrap().catch((error: any) => {
-        console.warn(`Failed to fetch follow status for user ${uid}:`, error);
-      })
-    );
-    await Promise.all(promises);
-  }, [dispatch, userIds, oxyServices]);
-
-  const clearErrorForUser = useCallback((targetUserId: string) => {
-    dispatch(clearFollowError(targetUserId));
-  }, [dispatch]);
-
-  // Return appropriate interface based on mode
-  if (isSingleUser && userId) {
-    return {
-      isFollowing: singleUserData.isFollowing,
-      isLoading: singleUserData.isLoading,
-      error: singleUserData.error,
-      toggleFollow,
-      setFollowStatus,
-      fetchStatus,
-      clearError,
-    };
-  }
-  
-  return {
-    followData: multipleUserData.followData,
-    toggleFollowForUser,
-    setFollowStatusForUser,
-    fetchStatusForUser,
-    fetchAllStatuses,
-    clearErrorForUser,
-    // Helper methods
-    isAnyLoading: multipleUserData.isAnyLoading,
-    hasAnyError: multipleUserData.hasAnyError,
-    allFollowing: multipleUserData.allFollowing,
-    allNotFollowing: multipleUserData.allNotFollowing,
-  };
-};
-
-// Backward compatibility alias
-export const useFollow = useOxyFollow;