@tidecloak/react 0.13.11 → 0.13.14

package/dist/esm/contexts/TideCloakContextProvider.js

@@ -1,28 +1,133 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from "react";
-import { IAMService } from '@tidecloak/js';
+import { IAMService, AdminAPI } from '@tidecloak/js';
 const TideCloakContext = React.createContext(undefined);
-export function TideCloakContextProvider({ config, children }) {
+export function TideCloakContextProvider({ config: configProp, configUrl = '/adapter.json', authMode, adapter, children, onAuthSuccess, onAuthError, onLogout, onReauthRequired, onActionNotification }) {
+    // Bootstrap state
     const [isInitializing, setIsInitializing] = React.useState(true);
     const [initError, setInitError] = React.useState(null);
+    // Session state
     const [authenticated, setAuthenticated] = React.useState(false);
     const [sessionExpired, setSessionExpired] = React.useState(false);
     const [isRefreshing, setIsRefreshing] = React.useState(false);
+    const [isLoading, setIsLoading] = React.useState(false);
+    // Network state
+    const [isOffline, setIsOffline] = React.useState(typeof navigator !== 'undefined' ? !navigator.onLine : false);
+    const [wasOffline, setWasOffline] = React.useState(false);
+    // Re-auth state
+    const [needsReauth, setNeedsReauth] = React.useState(false);
+    // Token state
     const [token, setToken] = React.useState(null);
     const [idToken, setIdToken] = React.useState(null);
     const [tokenExp, setTokenExp] = React.useState(null);
+    // Config state
     const [baseURL, setBaseURL] = React.useState("");
     const [reloadKey, setReloadKey] = React.useState(0);
+    const [resolvedConfig, setResolvedConfig] = React.useState(null);
+    // Store callbacks in refs to avoid re-subscriptions
+    const onAuthSuccessRef = React.useRef(onAuthSuccess);
+    const onAuthErrorRef = React.useRef(onAuthError);
+    const onLogoutRef = React.useRef(onLogout);
+    const onReauthRequiredRef = React.useRef(onReauthRequired);
+    const onActionNotificationRef = React.useRef(onActionNotification);
     React.useEffect(() => {
+        onAuthSuccessRef.current = onAuthSuccess;
+        onAuthErrorRef.current = onAuthError;
+        onLogoutRef.current = onLogout;
+        onReauthRequiredRef.current = onReauthRequired;
+        onActionNotificationRef.current = onActionNotification;
+    }, [onAuthSuccess, onAuthError, onLogout, onReauthRequired, onActionNotification]);
+    // Network status tracking
+    React.useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const handleOnline = () => setIsOffline(false);
+        const handleOffline = () => {
+            setIsOffline(true);
+            setWasOffline(true);
+        };
+        window.addEventListener('online', handleOnline);
+        window.addEventListener('offline', handleOffline);
+        return () => {
+            window.removeEventListener('online', handleOnline);
+            window.removeEventListener('offline', handleOffline);
+        };
+    }, []);
+    // Resolve config - either use provided config or fetch from URL
+    React.useEffect(() => {
+        let mounted = true;
+        const resolveConfig = async () => {
+            // Validate native mode requirements
+            if (authMode === 'native' && !adapter) {
+                const err = new Error('[TideCloak] authMode="native" requires an adapter prop');
+                if (mounted) {
+                    setInitError(err);
+                    setIsInitializing(false);
+                }
+                return;
+            }
+            // If config is provided directly, use it
+            if (configProp) {
+                const finalConfig = {
+                    ...configProp,
+                    ...(authMode && { authMode }),
+                    ...(adapter && { adapter }),
+                };
+                if (mounted) {
+                    setResolvedConfig(finalConfig);
+                }
+                return;
+            }
+            // Otherwise, fetch from configUrl
+            try {
+                console.debug(`[TideCloak] Fetching config from ${configUrl}`);
+                const response = await fetch(configUrl);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch config from ${configUrl}: ${response.status}`);
+                }
+                const fetchedConfig = await response.json();
+                const finalConfig = {
+                    ...fetchedConfig,
+                    ...(authMode && { authMode }),
+                    ...(adapter && { adapter }),
+                };
+                if (mounted) {
+                    console.debug('[TideCloak] Config loaded:', {
+                        realm: finalConfig.realm,
+                        authMode: finalConfig.authMode || 'frontchannel',
+                        hasAdapter: !!finalConfig.adapter,
+                    });
+                    setResolvedConfig(finalConfig);
+                }
+            }
+            catch (err) {
+                if (mounted) {
+                    console.error('[TideCloak] Failed to load config:', err);
+                    setInitError(err instanceof Error ? err : new Error(String(err)));
+                    setIsInitializing(false);
+                }
+            }
+        };
+        resolveConfig();
+        return () => {
+            mounted = false;
+        };
+    }, [configProp, configUrl, authMode, adapter]);
+    // Main IAMService initialization and event handling
+    React.useEffect(() => {
+        // Wait for config to be resolved
+        if (!resolvedConfig)
+            return;
         let mounted = true;
         const updateAuthState = async (eventName) => {
-            console.debug(`[TideCloak Provider] Updating auth state. Triggered by the ${eventName} event`);
+            console.debug(`[TideCloak] Auth state update from: ${eventName}`);
             if (!mounted)
                 return;
             const logged = IAMService.isLoggedIn();
             setAuthenticated(logged);
             if (logged) {
                 setSessionExpired(false);
+                setNeedsReauth(false);
                 try {
                     const t = await IAMService.getToken();
                     const idt = IAMService.getIDToken();
@@ -31,7 +136,7 @@ export function TideCloakContextProvider({ config, children }) {
                     setTokenExp(IAMService.getTokenExp());
                 }
                 catch (e) {
-                    console.error("[TideCloak Provider] Failed to update auth state", e);
+                    console.error("[TideCloak] Failed to get tokens:", e);
                 }
             }
             else {
@@ -40,106 +145,462 @@ export function TideCloakContextProvider({ config, children }) {
                 setIdToken(null);
             }
         };
-        const onInitError = (err) => {
-            if (mounted) {
-                setInitError(err);
-                setIsInitializing(false);
+        const handleAuthSuccess = async () => {
+            var _a;
+            if (!mounted)
+                return;
+            setIsLoading(false);
+            await updateAuthState('authSuccess');
+            // Send notification
+            (_a = onActionNotificationRef.current) === null || _a === void 0 ? void 0 : _a.call(onActionNotificationRef, {
+                type: 'success',
+                title: 'Logged In',
+                message: 'Successfully authenticated',
+                action: 'login'
+            });
+            // Call user's callback
+            if (onAuthSuccessRef.current) {
+                try {
+                    await onAuthSuccessRef.current();
+                }
+                catch (e) {
+                    console.error("[TideCloak] onAuthSuccess callback error:", e);
+                }
+            }
+        };
+        const handleAuthError = (_event, error) => {
+            var _a;
+            if (!mounted)
+                return;
+            setIsLoading(false);
+            const err = error instanceof Error ? error : new Error(String(error));
+            // Send notification
+            (_a = onActionNotificationRef.current) === null || _a === void 0 ? void 0 : _a.call(onActionNotificationRef, {
+                type: 'error',
+                title: 'Login Failed',
+                message: err.message,
+                action: 'login'
+            });
+            // Call user's callback
+            if (onAuthErrorRef.current) {
+                onAuthErrorRef.current(err);
+            }
+        };
+        const handleLogout = () => {
+            var _a;
+            if (!mounted)
+                return;
+            setIsLoading(false);
+            setAuthenticated(false);
+            setToken(null);
+            setIdToken(null);
+            setNeedsReauth(false);
+            // Send notification
+            (_a = onActionNotificationRef.current) === null || _a === void 0 ? void 0 : _a.call(onActionNotificationRef, {
+                type: 'info',
+                title: 'Logged Out',
+                message: 'You have been logged out',
+                action: 'logout'
+            });
+            // Call user's callback
+            if (onLogoutRef.current) {
+                onLogoutRef.current();
             }
         };
-        const onTokenExpired = async () => {
+        const handleInitError = (err) => {
+            var _a;
+            if (!mounted)
+                return;
+            setInitError(err);
+            setIsInitializing(false);
+            // Send notification
+            (_a = onActionNotificationRef.current) === null || _a === void 0 ? void 0 : _a.call(onActionNotificationRef, {
+                type: 'error',
+                title: 'Initialization Failed',
+                message: err.message,
+                action: 'init'
+            });
+        };
+        const handleTokenExpired = async () => {
+            var _a;
             if (!mounted)
                 return;
-            console.debug("[TideCloak Provider] Token expired, attempting refresh...");
+            console.debug("[TideCloak] Token expired, attempting refresh...");
             setSessionExpired(true);
+            // Send notification
+            (_a = onActionNotificationRef.current) === null || _a === void 0 ? void 0 : _a.call(onActionNotificationRef, {
+                type: 'warning',
+                title: 'Session Expiring',
+                message: 'Refreshing your session...',
+                action: 'token'
+            });
             try {
                 await IAMService.updateIAMToken();
             }
             catch (refreshError) {
-                console.error("[TideCloak Provider] Failed to refresh token:", refreshError);
+                console.error("[TideCloak] Token refresh failed:", refreshError);
             }
         };
+        const handleAuthRefreshSuccess = async () => {
+            var _a;
+            if (!mounted)
+                return;
+            await updateAuthState('authRefreshSuccess');
+            // Send notification
+            (_a = onActionNotificationRef.current) === null || _a === void 0 ? void 0 : _a.call(onActionNotificationRef, {
+                type: 'success',
+                title: 'Session Refreshed',
+                message: 'Your session has been refreshed',
+                action: 'token'
+            });
+        };
+        const handleAuthRefreshError = async () => {
+            var _a;
+            if (!mounted)
+                return;
+            await updateAuthState('authRefreshError');
+            // Send notification
+            (_a = onActionNotificationRef.current) === null || _a === void 0 ? void 0 : _a.call(onActionNotificationRef, {
+                type: 'error',
+                title: 'Session Refresh Failed',
+                message: 'Please log in again',
+                action: 'token'
+            });
+        };
+        // Subscribe to IAMService events
         IAMService
-            .on('authSuccess', updateAuthState)
-            .on('authError', updateAuthState)
-            .on('authRefreshSuccess', updateAuthState)
-            .on('authRefreshError', updateAuthState)
-            .on('logout', updateAuthState)
-            .on('tokenExpired', onTokenExpired)
-            .on('initError', onInitError);
+            .on('authSuccess', handleAuthSuccess)
+            .on('authError', handleAuthError)
+            .on('authRefreshSuccess', handleAuthRefreshSuccess)
+            .on('authRefreshError', handleAuthRefreshError)
+            .on('logout', handleLogout)
+            .on('tokenExpired', handleTokenExpired)
+            .on('initError', handleInitError);
         setIsInitializing(true);
+        // Initialize
         (async () => {
             try {
-                const loaded = await IAMService.loadConfig(config);
-                ;
+                const loaded = await IAMService.loadConfig(resolvedConfig);
                 if (!loaded)
                     throw new Error("Invalid config");
-                setBaseURL(loaded['auth-server-url'].replace(/\/+$/, ''));
-                await IAMService.initIAM(config, updateAuthState);
+                setBaseURL((loaded['auth-server-url'] || '').replace(/\/+$/, ''));
+                await IAMService.initIAM(resolvedConfig, updateAuthState);
                 if (!mounted)
                     return;
                 setIsInitializing(false);
             }
             catch (err) {
-                onInitError(err);
+                handleInitError(err);
             }
         })();
         return () => {
             mounted = false;
-            IAMService.off('ready', updateAuthState)
-                .off('authSuccess', updateAuthState)
-                .off('authError', updateAuthState)
-                .off('authRefreshSuccess', updateAuthState)
-                .off('authRefreshError', updateAuthState)
-                .off('logout', updateAuthState)
-                .off('tokenExpired', onTokenExpired)
-                .off('initError', onInitError);
+            IAMService
+                .off('authSuccess', handleAuthSuccess)
+                .off('authError', handleAuthError)
+                .off('authRefreshSuccess', handleAuthRefreshSuccess)
+                .off('authRefreshError', handleAuthRefreshError)
+                .off('logout', handleLogout)
+                .off('tokenExpired', handleTokenExpired)
+                .off('initError', handleInitError);
         };
-    }, [config, reloadKey]);
-    if (isInitializing)
-        return null;
-    return (_jsx(TideCloakContext.Provider, { value: {
-            isInitializing,
-            initError,
-            authenticated,
-            sessionExpired,
-            isRefreshing,
-            token,
-            idToken,
-            tokenExp,
-            baseURL,
-            getConfig: () => IAMService.getConfig(),
-            reload: () => setReloadKey(k => k + 1),
-            login: () => IAMService.doLogin(),
-            logout: () => IAMService.doLogout(),
-            refreshToken: async () => {
-                setIsRefreshing(true);
-                try {
-                    return await IAMService.updateIAMToken();
-                }
-                finally {
-                    setIsRefreshing(false);
-                }
-            },
-            forceRefreshToken: async () => {
-                setIsRefreshing(true);
-                try {
-                    return await IAMService.forceUpdateToken();
+    }, [resolvedConfig, reloadKey]);
+    // Actions
+    const login = React.useCallback(async () => {
+        setIsLoading(true);
+        try {
+            await IAMService.doLogin();
+        }
+        catch (error) {
+            setIsLoading(false);
+            throw error;
+        }
+    }, []);
+    const logout = React.useCallback(async () => {
+        setIsLoading(true);
+        try {
+            await IAMService.doLogout();
+        }
+        catch (error) {
+            setIsLoading(false);
+            throw error;
+        }
+    }, []);
+    const getToken = React.useCallback(async () => {
+        try {
+            return await IAMService.getToken();
+        }
+        catch (error) {
+            console.error("[TideCloak] getToken error:", error);
+            return null;
+        }
+    }, []);
+    const refreshToken = React.useCallback(async () => {
+        setIsRefreshing(true);
+        try {
+            return await IAMService.updateIAMToken();
+        }
+        finally {
+            setIsRefreshing(false);
+        }
+    }, []);
+    const forceRefreshToken = React.useCallback(async () => {
+        setIsRefreshing(true);
+        try {
+            return await IAMService.forceUpdateToken();
+        }
+        finally {
+            setIsRefreshing(false);
+        }
+    }, []);
+    // Re-auth actions
+    const triggerReauth = React.useCallback(() => {
+        var _a;
+        setNeedsReauth(true);
+        // Send notification
+        (_a = onActionNotificationRef.current) === null || _a === void 0 ? void 0 : _a.call(onActionNotificationRef, {
+            type: 'warning',
+            title: 'Re-authentication Required',
+            message: 'Please log in again to continue',
+            action: 'reauth'
+        });
+        if (onReauthRequiredRef.current) {
+            onReauthRequiredRef.current();
+        }
+    }, []);
+    const clearReauth = React.useCallback(() => {
+        setNeedsReauth(false);
+    }, []);
+    const resetWasOffline = React.useCallback(() => {
+        setWasOffline(false);
+    }, []);
+    // Context value - provide safe defaults during initialization
+    const contextValue = {
+        // Bootstrap
+        isInitializing,
+        initError,
+        // Session
+        authenticated,
+        sessionExpired,
+        isRefreshing,
+        isLoading,
+        // Network
+        isOffline,
+        wasOffline,
+        // Re-auth
+        needsReauth,
+        // Tokens
+        token,
+        idToken,
+        tokenExp,
+        // Config
+        baseURL,
+        // Direct access to service instances
+        IAMService,
+        AdminAPI,
+        getConfig: () => isInitializing ? {} : IAMService.getConfig(),
+        reload: () => setReloadKey((k) => k + 1),
+        // Auth actions
+        login,
+        logout,
+        getToken,
+        refreshToken,
+        forceRefreshToken,
+        // Role checks - return false during initialization
+        hasRealmRole: (role) => isInitializing ? false : IAMService.hasRealmRole(role),
+        hasClientRole: (role, resource) => isInitializing ? false : IAMService.hasClientRole(role, resource),
+        // Token claims - return undefined during initialization or when not authenticated
+        getValueFromToken: (key) => (isInitializing || !authenticated) ? undefined : IAMService.getValueFromToken(key),
+        getValueFromIdToken: (key) => (isInitializing || !authenticated) ? undefined : IAMService.getValueFromIDToken(key),
+        // Re-auth actions
+        triggerReauth,
+        clearReauth,
+        resetWasOffline,
+        // Tide encryption - return null during initialization
+        doEncrypt: async (data) => {
+            var _a, _b;
+            if (isInitializing)
+                return null;
+            try {
+                const result = await IAMService.doEncrypt(data);
+                (_a = onActionNotificationRef.current) === null || _a === void 0 ? void 0 : _a.call(onActionNotificationRef, {
+                    type: 'success',
+                    title: 'Encrypted',
+                    message: `${Array.isArray(data) ? data.length : 1} item(s) encrypted`,
+                    action: 'encrypt'
+                });
+                return result;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                (_b = onActionNotificationRef.current) === null || _b === void 0 ? void 0 : _b.call(onActionNotificationRef, {
+                    type: 'error',
+                    title: 'Encryption Failed',
+                    message: err.message,
+                    action: 'encrypt'
+                });
+                throw error;
+            }
+        },
+        doDecrypt: async (data) => {
+            var _a, _b;
+            if (isInitializing)
+                return null;
+            try {
+                const result = await IAMService.doDecrypt(data);
+                (_a = onActionNotificationRef.current) === null || _a === void 0 ? void 0 : _a.call(onActionNotificationRef, {
+                    type: 'success',
+                    title: 'Decrypted',
+                    message: `${Array.isArray(data) ? data.length : 1} item(s) decrypted`,
+                    action: 'decrypt'
+                });
+                return result;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                (_b = onActionNotificationRef.current) === null || _b === void 0 ? void 0 : _b.call(onActionNotificationRef, {
+                    type: 'error',
+                    title: 'Decryption Failed',
+                    message: err.message,
+                    action: 'decrypt'
+                });
+                throw error;
+            }
+        },
+        // Tide request signing (for policy creation)
+        initializeTideRequest: async (request) => {
+            const tc = IAMService._tc;
+            if (!(tc === null || tc === void 0 ? void 0 : tc.createTideRequest)) {
+                throw new Error("TideCloak createTideRequest not available");
+            }
+            const encodedRequest = request.encode();
+            const initializedBytes = await tc.createTideRequest(encodedRequest);
+            const RequestClass = request.constructor;
+            if (typeof RequestClass.decode === "function") {
+                return RequestClass.decode(initializedBytes);
+            }
+            return request;
+        },
+        // Get vendor ID from config
+        getVendorId: () => {
+            const cfg = IAMService.getConfig();
+            return (cfg === null || cfg === void 0 ? void 0 : cfg.vendorId) || (cfg === null || cfg === void 0 ? void 0 : cfg["vendor-id"]) || "";
+        },
+        // Get resource (client ID) from config
+        getResource: () => {
+            const cfg = IAMService.getConfig();
+            return (cfg === null || cfg === void 0 ? void 0 : cfg.resource) || (cfg === null || cfg === void 0 ? void 0 : cfg.clientId) || "";
+        },
+        // Tide approval enclave (for change set approvals)
+        approveTideRequests: async (requests) => {
+            var _a, _b, _c, _d;
+            const tc = IAMService._tc;
+            if (!(tc === null || tc === void 0 ? void 0 : tc.requestTideOperatorApproval)) {
+                const error = new Error("TideCloak approval enclave not available");
+                (_a = onActionNotificationRef.current) === null || _a === void 0 ? void 0 : _a.call(onActionNotificationRef, {
+                    type: 'error',
+                    title: 'Approval Failed',
+                    message: error.message,
+                    action: 'approval'
+                });
+                throw error;
+            }
+            try {
+                const response = await tc.requestTideOperatorApproval(requests);
+                const results = response.map((res) => {
+                    if (res.status === "approved") {
+                        return { id: res.id, approved: { request: res.request } };
+                    }
+                    else if (res.status === "denied") {
+                        return { id: res.id, denied: true };
+                    }
+                    else {
+                        return { id: res.id, pending: true };
+                    }
+                });
+                // Send notifications for each result
+                const approved = results.filter((r) => r.approved).length;
+                const denied = results.filter((r) => r.denied).length;
+                if (approved > 0) {
+                    (_b = onActionNotificationRef.current) === null || _b === void 0 ? void 0 : _b.call(onActionNotificationRef, {
+                        type: 'success',
+                        title: 'Approved',
+                        message: `${approved} request${approved > 1 ? 's' : ''} approved successfully`,
+                        action: 'approval'
+                    });
                 }
-                finally {
-                    setIsRefreshing(false);
+                if (denied > 0) {
+                    (_c = onActionNotificationRef.current) === null || _c === void 0 ? void 0 : _c.call(onActionNotificationRef, {
+                        type: 'warning',
+                        title: 'Denied',
+                        message: `${denied} request${denied > 1 ? 's' : ''} denied`,
+                        action: 'approval'
+                    });
                 }
-            },
-            hasRealmRole: (role) => IAMService.hasRealmRole(role),
-            hasClientRole: (role, resource) => IAMService.hasClientRole(role, resource),
-            getValueFromToken: (key) => IAMService.getValueFromToken(key),
-            getValueFromIdToken: (key) => IAMService.getValueFromIDToken(key),
-            doEncrypt: async (data) => await IAMService.doEncrypt(data),
-            doDecrypt: async (data) => await IAMService.doDecrypt(data)
-        }, children: children }));
+                // Trigger reload to refresh data after approvals
+                setReloadKey(k => k + 1);
+                return results;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                (_d = onActionNotificationRef.current) === null || _d === void 0 ? void 0 : _d.call(onActionNotificationRef, {
+                    type: 'error',
+                    title: 'Approval Failed',
+                    message: err.message,
+                    action: 'approval'
+                });
+                throw error;
+            }
+        },
+    };
+    return (_jsx(TideCloakContext.Provider, { value: contextValue, children: children }));
 }
+// Default context value for when provider is not available
+// This allows graceful degradation in iframes or other contexts
+const defaultContextValue = {
+    isInitializing: true,
+    initError: null,
+    authenticated: false,
+    sessionExpired: false,
+    isRefreshing: false,
+    isLoading: false,
+    isOffline: false,
+    wasOffline: false,
+    needsReauth: false,
+    token: null,
+    idToken: null,
+    tokenExp: null,
+    baseURL: '',
+    IAMService,
+    AdminAPI,
+    getConfig: () => ({}),
+    reload: () => { },
+    login: async () => { },
+    logout: async () => { },
+    getToken: async () => null,
+    refreshToken: async () => false,
+    forceRefreshToken: async () => false,
+    hasRealmRole: () => false,
+    hasClientRole: () => false,
+    getValueFromToken: () => undefined,
+    getValueFromIdToken: () => undefined,
+    triggerReauth: () => { },
+    clearReauth: () => { },
+    resetWasOffline: () => { },
+    doEncrypt: async () => null,
+    doDecrypt: async () => null,
+    initializeTideRequest: async () => { throw new Error("TideCloakContextProvider not available"); },
+    getVendorId: () => "",
+    getResource: () => "",
+    approveTideRequests: async () => { throw new Error("TideCloakContextProvider not available"); },
+};
 export function useTideCloakContext() {
     const ctx = React.useContext(TideCloakContext);
-    if (!ctx)
-        throw new Error("useTideCloakContext must be used within <TideCloakContextProvider>");
+    // Return default context if not within provider (e.g., in iframes)
+    // This provides graceful degradation instead of throwing
+    if (!ctx) {
+        console.warn("useTideCloakContext called outside TideCloakContextProvider - returning defaults");
+        return defaultContextValue;
+    }
     return ctx;
 }