@jmruthers/pace-core 0.2.4

package/src/index.ts

@@ -0,0 +1,200 @@
+/**
+ * @file Complete Component Library Export
+ * @package @jmruthers/pace-core
+ * @module Core
+ * @since 0.1.0
+ * 
+ * This file exports the primary components, hooks, and utilities from the PACE Core library.
+ * It is the main entry point for developers using the library.
+ * 
+ * @example
+ * // Import common components
+ * import { Button, Card, useUnifiedAuth } from '@jmruthers/pace-core';
+ * 
+ * // For specialized components, use the complete library import:
+ * import { Dialog, NavigationMenu } from '@jmruthers/pace-core/components';
+ */
+
+// AUTHENTICATION & AUTHORIZATION
+export { UnifiedAuthProvider, useUnifiedAuth } from './providers/UnifiedAuthProvider';
+export type { UnifiedAuthProviderProps, UnifiedAuthContextType, UserEventAccess } from './providers/UnifiedAuthProvider';
+export { EventProvider, useEvents } from './providers/EventProvider';
+export type { EventProviderProps, EventContextType } from './providers/EventProvider';
+export { OrganisationProvider, useOrganisations } from './providers/OrganisationProvider';
+export type { 
+  Organisation, 
+  OrganisationMembership, 
+  OrganisationContextType, 
+  OrganisationProviderProps,
+  OrganisationSecurityError 
+} from './types/organisation';
+
+// INACTIVITY TRACKING
+export { InactivityWarningModal } from './components/InactivityWarningModal/InactivityWarningModal';
+export type { InactivityWarningModalProps } from './components/InactivityWarningModal/InactivityWarningModal';
+export { useInactivityTracker } from './hooks/useInactivityTracker';
+export type { UseInactivityTrackerOptions, UseInactivityTrackerReturn } from './hooks/useInactivityTracker';
+
+// RBAC SYSTEM - Use the new RBAC module
+// Note: For RBAC functionality, use @jmruthers/pace-core/rbac instead
+// This provides a complete, type-safe RBAC system with organisation context enforcement
+
+// BASIC UI COMPONENTS
+export { Button } from './components/Button/Button';
+export type { ButtonProps } from './components/Button/Button';
+
+export { 
+  Card, 
+  CardHeader, 
+  CardFooter, 
+  CardTitle, 
+  CardDescription, 
+  CardContent,
+  CardActions
+} from './components/Card/Card';
+export type { CardProps } from './components/Card/Card';
+
+export { Input } from './components/Input/Input';
+export type { InputProps } from './components/Input/Input';
+export { Label } from './components/Label/Label';
+export type { LabelProps } from './components/Label/Label';
+
+export { Alert, AlertTitle, AlertDescription } from './components/Alert/Alert';
+export { Avatar, AvatarImage, AvatarFallback } from './components/Avatar/Avatar';
+
+export { Checkbox } from './components/Checkbox/Checkbox';
+export { Progress } from './components/Progress/Progress';
+
+// ADVANCED UI COMPONENTS
+export {
+  Dialog,
+  DialogPortal,
+  DialogOverlay,
+  DialogTrigger,
+  DialogClose,
+  DialogContent,
+  DialogHeader,
+  DialogBody,
+  DialogFooter,
+  DialogTitle,
+  DialogDescription,
+} from './components/Dialog/Dialog';
+
+// Dropdown Menu exports
+// DropdownMenu components have been merged into Select components
+
+// Select exports
+export {
+  Select,
+  SelectGroup,
+  SelectValue,
+  SelectTrigger,
+  SelectContent,
+  SelectLabel,
+  SelectItem,
+  SelectSeparator,
+} from './components/Select';
+
+// Modal functionality is provided by Dialog components
+
+export {
+  Toast,
+  Toaster,
+  ToastAction,
+  ToastProvider,
+  ToastViewport,
+  ToastTitle,
+  ToastDescription,
+  ToastClose,
+  useToast,
+} from './components/Toast/Toast';
+export type { ToastActionElement, ToastProps } from './components/Toast/Toast';
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider, TooltipRoot } from './components/Tooltip/Tooltip';
+
+// DATA DISPLAY COMPONENTS
+export {
+  DataTable,
+  type DataTableProps,
+  type DataTableColumn,
+  type DataTableAction,
+  type DataTableToolbarButton,
+  type AggregateConfig,
+  type EmptyStateConfig,
+  type GetRowId
+} from './components/DataTable';
+
+// Re-export types from DataTable types
+export type { DataRecord } from './components/DataTable/types';
+
+// FORM COMPONENTS
+export { Form } from './components/Form/Form';
+export { LoginForm } from './components/LoginForm/LoginForm';
+export type { LoginFormProps } from './components/LoginForm/LoginForm';
+
+// LAYOUT COMPONENTS
+export { Header } from './components/Header/Header';
+export { Footer } from './components/Footer/Footer';
+export type { FooterProps } from './components/Footer/Footer';
+
+// NAVIGATION COMPONENTS
+export { NavigationMenu } from './components/NavigationMenu/NavigationMenu';
+export type { NavigationMenuProps, NavigationItem } from './components/NavigationMenu/types';
+export { UserMenu } from './components/UserMenu/UserMenu';
+export type { UserMenuProps } from './components/UserMenu/UserMenu';
+
+// Reusable Page/Layout Components
+export { PaceAppLayout } from './components/PaceAppLayout/PaceAppLayout';
+export type { PaceAppLayoutProps } from './components/PaceAppLayout/PaceAppLayout';
+export { PaceLoginPage } from './components/PaceLoginPage/PaceLoginPage';
+export type { PaceLoginPageProps } from './components/PaceLoginPage/PaceLoginPage';
+
+// UTILITY COMPONENTS
+export { ErrorBoundary } from './components/ErrorBoundary/ErrorBoundary';
+export { LoadingSpinner } from './components/LoadingSpinner/LoadingSpinner';
+
+// EVENT MANAGEMENT
+export { EventSelector } from './components/EventSelector/EventSelector';
+
+// ORGANISATION MANAGEMENT
+export { OrganisationSelector } from './components/OrganisationSelector/OrganisationSelector';
+export { useOrganisationPermissions } from './hooks/useOrganisationPermissions';
+export { useOrganisationSecurity } from './hooks/useOrganisationSecurity';
+export { createSecureDataAccess } from './utils/secureDataAccess';
+
+// TYPES
+export type { UserProfile } from './types/organisation';
+
+// AUTHENTICATION FORMS
+export { PasswordResetForm } from './components/PasswordReset/PasswordResetForm';
+export { PasswordChangeForm } from './components/PasswordReset/PasswordChangeForm';
+
+// UTILS & HOOKS
+export { useAppConfig } from './hooks/useAppConfig';
+export { cn } from './utils/cn';
+export { setAppConfig, getAppConfig, getCurrentAppName, getCurrentAppId } from './utils/appConfig';
+
+// STORAGE UTILITIES
+export { FileUpload } from './components/FileUpload/FileUpload';
+export type { FileUploadProps } from './components/FileUpload/FileUpload';
+export { useStorage, useFileUpload } from './hooks/useStorage';
+export * from './utils/storage';
+
+// Table components
+export {
+  Table,
+  TableHeader,
+  TableBody,
+  TableCaption,
+  TableCell,
+  TableFooter,
+  TableHead,
+  TableRow,
+} from './components/Table/Table';
+
+// STYLES
+export * from './styles';
+
+// PUBLIC PAGES
+export * from './hooks/public';
+export * from './components/PublicLayout';

package/src/providers/AuthProvider.tsx

@@ -0,0 +1,369 @@
+/**
+ * @file Authentication Provider
+ * @package @jmruthers/pace-core
+ * @module Providers/Auth
+ * @since 0.1.0
+ *
+ * Handles user authentication, session management, and auth-related operations.
+ * Separated from UnifiedAuthProvider for better maintainability.
+ */
+
+import React, { createContext, useContext, useState, useEffect, useCallback, useMemo } from 'react';
+import { type SupabaseClient, type User, type Session, AuthError } from '@supabase/supabase-js';
+import { DebugLogger } from '../utils/debugLogger';
+
+// Auth context type
+export interface AuthContextType {
+  // Auth state
+  user: User | null;
+  session: Session | null;
+  isAuthenticated: boolean;
+  authLoading: boolean;
+  authError: AuthError | null;
+  error: AuthError | null; // Alias for authError for backward compatibility
+  supabase: SupabaseClient | null;
+  
+  // Auth methods
+  signIn: (email: string, password?: string) => Promise<{ error: AuthError | null }>;
+  signUp: (email: string, password: string) => Promise<{ error: AuthError | null }>;
+  signOut: () => Promise<{ error: AuthError | null }>;
+  resetPassword: (email: string) => Promise<{ error: AuthError | null }>;
+  updatePassword: (password: string) => Promise<{ error: AuthError | null }>;
+  refreshSession: () => Promise<{ error: AuthError | null }>;
+}
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+export const useAuth = () => {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error('useAuth must be used within an AuthProvider');
+  }
+  return context;
+};
+
+export interface AuthProviderProps {
+  children: React.ReactNode;
+  supabaseClient?: SupabaseClient;
+}
+
+export function AuthProvider({ children, supabaseClient }: AuthProviderProps) {
+  // Auth state
+  const [user, setUser] = useState<User | null>(null);
+  const [session, setSession] = useState<Session | null>(null);
+  const [authLoading, setAuthLoading] = useState(true);
+  const [authError, setAuthError] = useState<AuthError | null>(null);
+
+  // Global error handler to suppress AuthSessionMissingError during logout
+  useEffect(() => {
+    const handleError = (event: ErrorEvent) => {
+      if (event.error?.message?.includes('AuthSessionMissingError') || 
+          event.error?.message?.includes('Auth session missing')) {
+        console.warn('[AuthProvider] Suppressing AuthSessionMissingError during logout');
+        event.preventDefault();
+        return false;
+      }
+    };
+
+    const handleUnhandledRejection = (event: PromiseRejectionEvent) => {
+      if (event.reason?.message?.includes('AuthSessionMissingError') ||
+          event.reason?.message?.includes('Auth session missing')) {
+        console.warn('[AuthProvider] Suppressing unhandled AuthSessionMissingError');
+        event.preventDefault();
+        return false;
+      }
+    };
+
+    window.addEventListener('error', handleError);
+    window.addEventListener('unhandledrejection', handleUnhandledRejection);
+
+    return () => {
+      window.removeEventListener('error', handleError);
+      window.removeEventListener('unhandledrejection', handleUnhandledRejection);
+    };
+  }, []);
+
+  // Load initial user if no session but supabase client exists
+  useEffect(() => {
+    if (!supabaseClient) return;
+
+    const loadInitialUser = async () => {
+      try {
+        const response = await supabaseClient.auth.getUser();
+        const { data: { user: initialUser }, error } = response || { data: { user: null }, error: null };
+        if (error) {
+          console.warn('Failed to get initial user:', error);
+          setAuthLoading(false);
+          return;
+        }
+        
+        if (initialUser) {
+          setUser(initialUser);
+        }
+        setAuthLoading(false);
+      } catch (error) {
+        console.error('Error loading initial user:', error);
+        setAuthLoading(false);
+      }
+    };
+
+    // Only load initial user if we haven't set up the auth state change listener yet
+    // This prevents race conditions between loadInitialUser and auth state change
+    const timeoutId = setTimeout(() => {
+      if (authLoading && !user && !session) {
+        loadInitialUser();
+      }
+    }, 100);
+
+    return () => clearTimeout(timeoutId);
+  }, [supabaseClient, authLoading, user, session]);
+
+  // Auth state change listener
+  useEffect(() => {
+    if (!supabaseClient) {
+      setAuthLoading(false);
+      return;
+    }
+
+    // Shorter timeout to prevent hanging
+    const timeoutId = setTimeout(() => {
+      if (authLoading) {
+        console.warn('AuthProvider: Auth loading timeout reached');
+        setAuthLoading(false);
+      }
+    }, 2000); // Reduced from 5000 to 2000
+
+    try {
+      DebugLogger.log('AuthProvider', 'Setting up auth state change listener...');
+      const authStateChange = supabaseClient.auth.onAuthStateChange(
+        (event, session) => {
+          try {
+            DebugLogger.log('AuthProvider', 'Auth state changed:', event, session?.user?.email);
+            
+            // Clear timeout immediately when we get an auth state change
+            clearTimeout(timeoutId);
+            
+            // Handle different auth events
+            if (event === 'SIGNED_OUT') {
+              DebugLogger.log('AuthProvider', 'User signed out, clearing all state');
+              // Clear all state immediately and aggressively
+              setSession(null);
+              setUser(null);
+              setAuthLoading(false);
+              setAuthError(null);
+            } else {
+              setSession(session);
+              setUser(session?.user ?? null);
+              setAuthLoading(false);
+              
+              // Only clear auth error if we have a valid session
+              if (session) {
+                setAuthError(null);
+              }
+            }
+          } catch (error) {
+            console.warn('[AuthProvider] Error in auth state change handler:', error);
+            // Ensure loading is always set to false
+            setAuthLoading(false);
+          }
+        }
+      );
+
+      const subscription = authStateChange?.data?.subscription || authStateChange;
+      
+      return () => {
+        clearTimeout(timeoutId);
+        if (subscription && typeof subscription.unsubscribe === 'function') {
+          DebugLogger.log('AuthProvider', 'Cleaning up auth state listener');
+          subscription.unsubscribe();
+        }
+      };
+    } catch (error) {
+      console.error('AuthProvider: Error setting up auth state change listener:', error);
+      
+      // Don't set authError for connection issues or auth session missing errors
+      if (error instanceof Error && 
+          !error.message.includes('No API key found') && 
+          !error.message.includes('AuthSessionMissingError') &&
+          !error.message.includes('Auth session missing')) {
+        setAuthError(error as AuthError);
+      }
+      setAuthLoading(false);
+      clearTimeout(timeoutId);
+      return () => {};
+    }
+  }, [supabaseClient]);
+
+  // Auth methods
+  const signIn = useCallback(async (email: string, password?: string) => {
+    if (!supabaseClient) {
+      const error = new Error('No Supabase client provided') as AuthError;
+      setAuthError(error);
+      return { error };
+    }
+
+    setAuthLoading(true);
+    setAuthError(null);
+    
+    try {
+      const { error } = await supabaseClient.auth.signInWithPassword({ email, password: password || '' });
+      if (error) {
+        setAuthError(error);
+      }
+      return { error };
+    } catch (err: any) {
+      const authError = err as AuthError;
+      setAuthError(authError);
+      return { error: authError };
+    } finally {
+      setAuthLoading(false);
+    }
+  }, [supabaseClient]);
+
+  const signUp = useCallback(async (email: string, password: string) => {
+    if (!supabaseClient) {
+      const error = new Error('No Supabase client provided') as AuthError;
+      setAuthError(error);
+      return { error };
+    }
+
+    setAuthError(null);
+    try {
+      const { error } = await supabaseClient.auth.signUp({ email, password });
+      if (error) {
+        setAuthError(error);
+      }
+      return { error };
+    } catch (err: any) {
+      const authError = err as AuthError;
+      setAuthError(authError);
+      return { error: authError };
+    }
+  }, [supabaseClient]);
+
+  const signOut = useCallback(async () => {
+    DebugLogger.log('AuthProvider', 'signOut called');
+    
+    // Immediately set loading to false to prevent timeout warnings
+    setAuthLoading(false);
+    
+    if (!supabaseClient) {
+      DebugLogger.log('AuthProvider', 'No supabase client, clearing state manually');
+      setUser(null);
+      setSession(null);
+      setAuthError(null);
+      return { error: null };
+    }
+    
+    // Clear state immediately before calling Supabase signOut
+    DebugLogger.log('AuthProvider', 'Pre-clearing state before signOut call');
+    setUser(null);
+    setSession(null);
+    setAuthError(null);
+    
+    try {
+      DebugLogger.log('AuthProvider', 'Calling supabase signOut');
+      
+      // Add a timeout to prevent hanging
+      const signOutPromise = supabaseClient.auth.signOut();
+      const timeoutPromise = new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('SignOut timeout')), 3000)
+      );
+      
+      const { error } = await Promise.race([signOutPromise, timeoutPromise]) as any;
+      
+      if (error && !error.message?.includes('SignOut timeout')) {
+        console.error('[AuthProvider] signOut error:', error);
+        // Don't set auth error for logout - we've already cleared state
+      }
+      
+      DebugLogger.log('AuthProvider', 'signOut process completed');
+      return { error: null }; // Always return success for logout
+    } catch (err) {
+      console.warn('[AuthProvider] signOut exception (ignored):', err);
+      // Ignore errors during logout - state is already cleared
+      return { error: null };
+    }
+  }, [supabaseClient]);
+
+  const resetPassword = useCallback(async (email: string) => {
+    if (!supabaseClient) {
+      const error = new Error('No Supabase client provided') as AuthError;
+      setAuthError(error);
+      return { error };
+    }
+
+    setAuthError(null);
+    try {
+      const { error } = await supabaseClient.auth.resetPasswordForEmail(email);
+      if (error) {
+        setAuthError(error);
+      }
+      return { error };
+    } catch (err: any) {
+      const authError = err as AuthError;
+      setAuthError(authError);
+      return { error: authError };
+    }
+  }, [supabaseClient]);
+
+  const updatePassword = useCallback(async (password: string) => {
+    if (!supabaseClient) return { error: new AuthError('Supabase client not available.', 500) };
+    const { error } = await supabaseClient.auth.updateUser({ password });
+    if (error) {
+      setAuthError(error);
+    }
+    return { error };
+  }, [supabaseClient]);
+
+  const refreshSession = useCallback(async () => {
+    if (!supabaseClient) {
+      const error = new Error('No Supabase client provided') as AuthError;
+      setAuthError(error);
+      return { error };
+    }
+
+    setAuthError(null);
+    try {
+      const { error } = await supabaseClient.auth.refreshSession();
+      if (error) {
+        setAuthError(error);
+      }
+      return { error };
+    } catch (err: any) {
+      const authError = err as AuthError;
+      setAuthError(authError);
+      return { error: authError };
+    }
+  }, [supabaseClient]);
+
+  // Memoized derived values
+  const isAuthenticated = !!user;
+
+  // Memoized context value
+  const contextValue = useMemo<AuthContextType>(() => ({
+    user,
+    session,
+    isAuthenticated,
+    authLoading,
+    authError,
+    error: authError, // Alias for backward compatibility
+    supabase: supabaseClient || null,
+
+    signIn,
+    signUp,
+    signOut,
+    resetPassword,
+    updatePassword,
+    refreshSession,
+  }), [
+    user, session, isAuthenticated, authLoading, authError, supabaseClient,
+    signIn, signUp, signOut, resetPassword, updatePassword, refreshSession,
+  ]);
+
+  return (
+    <AuthContext.Provider value={contextValue}>
+      {children}
+    </AuthContext.Provider>
+  );
+}