@truworth/twc-auth 3.0.3 → 3.0.4

package/build/src/screens/SSOLogin/AuthWebView/index.native.js

@@ -3,25 +3,40 @@ import { WebView } from '@truworth/twc-rn-common';
 import { Layout } from '@ui-kitten/components';
 import { Text } from 'react-native';
 import parse from 'url-parse';
-import { useState } from 'react';
+import { useState, useCallback } from 'react';
+const SAML_CALLBACK_PATHS = ['/saml', 'thewellnesscorner.com/saml'];
 const SSOAuthWebView = ({ navigation, route }) => {
-    const { clientId, authenticationUrl, redirectUri } = route.params;
+    const { clientId, authenticationUrl, redirectUri, authMethod } = route.params;
     const [error, setError] = useState(null);
+    const handleNavigationStateChange = useCallback((navState) => {
+        setError(null);
+        const parsedUrl = parse(navState.url, true);
+        const currentUrl = parsedUrl.href;
+        const authUrl = parse(authenticationUrl, true).href;
+        if (currentUrl === authUrl)
+            return;
+        if (authMethod === 'saml') {
+            const isSamlCallback = SAML_CALLBACK_PATHS.some(path => navState.url.includes(path));
+            if (isSamlCallback) {
+                const { code } = parsedUrl.query;
+                if (code) {
+                    navigation.replace('SSOCallback', { clientId, code: code, authMethod: 'saml' });
+                }
+            }
+        }
+        else {
+            if (redirectUri && navState.url.includes(redirectUri)) {
+                const { code } = parsedUrl.query;
+                navigation.replace('SSOCallback', { clientId, code: code, authMethod: 'oidc' });
+            }
+        }
+    }, [authenticationUrl, authMethod, clientId, navigation, redirectUri]);
     return (_jsxs(Layout, { style: { flex: 1 }, children: [error && (_jsx(Layout, { style: { padding: 16, backgroundColor: '#fee' }, children: _jsx(Text, { style: { color: 'red' }, children: error }) })), _jsx(WebView, { source: { uri: authenticationUrl }, style: { flex: 1 }, onError: (syntheticEvent) => {
                     const { nativeEvent } = syntheticEvent;
                     setError(`Failed to load authentication page: ${nativeEvent.description}`);
                 }, onHttpError: (syntheticEvent) => {
                     const { nativeEvent } = syntheticEvent;
                     setError(`Authentication provider error: ${nativeEvent.statusCode}`);
-                }, onNavigationStateChange: (navState) => {
-                    setError(null);
-                    const currentUrl = parse(navState.url, true).href;
-                    const authUrl = parse(authenticationUrl, true).href;
-                    if (currentUrl != authUrl && navState.url.includes(redirectUri)) {
-                        const query = parse(navState.url, true).query;
-                        const { code } = query;
-                        navigation.replace('SSOCallback', { clientId, code });
-                    }
-                } })] }));
+                }, onNavigationStateChange: handleNavigationStateChange })] }));
 };
 export default SSOAuthWebView;

package/build/src/screens/SSOLogin/AuthenticationMethods/hooks/internal/useSSOAuthenticationMethods.js

@@ -17,8 +17,9 @@ const useSSOAuthenticationMethods = () => {
         }).then((res) => {
             if (!isMountedRef.current)
                 return;
-            const { authenticationUrl, redirectUri } = res.data;
-            onSSOLoginInitiated({ clientId, authenticationUrl, redirectUri });
+            const { authenticationUrl, redirectUri, authMethod } = res.data;
+            const resolvedAuthMethod = authMethod === 'saml' ? 'saml' : 'oidc';
+            onSSOLoginInitiated({ clientId, authenticationUrl, redirectUri, authMethod: resolvedAuthMethod });
         }).catch((error) => {
             if (!isMountedRef.current)
                 return;

package/build/src/screens/SSOLogin/AuthenticationMethods/index.js

@@ -29,6 +29,7 @@ const SSOAuthenticationMethods = ({ client, onPressBack, handleMobileLogin }) =>
     const onSSOLoginInitiated = (result) => {
         try {
             localStorage.setItem('clientId', String(result.clientId));
+            localStorage.setItem('authMethod', result.authMethod);
             const u = new URL(result.authenticationUrl);
             window.location.href = u.toString();
         }

package/build/src/screens/SSOLogin/AuthenticationMethods/index.native.js

@@ -43,7 +43,12 @@ const SSOAuthenticationMethods = ({ route }) => {
         return (_jsx(View, { style: { marginTop: 70, alignSelf: 'center' }, children: _jsx(Logo, {}) }));
     };
     const onSSOLoginInitiated = (result) => {
-        navigation.navigate('SSOAuthWebView', { ...result });
+        navigation.navigate('SSOAuthWebView', {
+            clientId: result.clientId,
+            authenticationUrl: result.authenticationUrl,
+            redirectUri: result.redirectUri,
+            authMethod: result.authMethod,
+        });
     };
     return (_jsx(ScreenLayout, { title: "", containerStyle: { flex: 1, backgroundColor: primary.white }, children: _jsxs(View, { style: { flex: 1, justifyContent: 'center' }, children: [client.image ?
                     _jsx(FastImage, { source: { uri: client.image }, resizeMode: 'contain', style: { width: 180, aspectRatio: aspectRatio, alignSelf: 'center', marginTop: -150 } })

package/build/src/screens/SSOLogin/SSOCallback/components/SSOCallbackComponent/index.js

@@ -1,15 +1,32 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React, { Suspense, lazy, useEffect, useState } from 'react';
+import React, { Suspense, lazy, useEffect, useState, Component } from 'react';
 import { Flex, Typography } from '@truworth/twc-web-design';
 import { useSSOCallback } from '../../hooks/internal/useSSOCallback';
 import { useNavigator } from '../../../../../hooks/useNavigator';
 import redirectAnimation from '../../../../../../assets/animation/redirect-home.json';
 import { RegistrationMethod } from '../../../../../enums';
 const Lottie = lazy(() => import('react-lottie'));
-const SSOCallbackComponents = () => {
+class LottieErrorBoundary extends Component {
+    constructor(props) {
+        super(props);
+        this.state = { hasError: false };
+    }
+    static getDerivedStateFromError() {
+        return { hasError: true };
+    }
+    componentDidCatch() { }
+    render() {
+        if (this.state.hasError)
+            return this.props.fallback;
+        return this.props.children;
+    }
+}
+const SSOCallbackComponents = ({ authMethodOverride } = {}) => {
     const navigator = useNavigator();
     const [clientId, setClientId] = useState('');
     const [code, setCode] = useState('');
+    const [authMethod, setAuthMethod] = useState(authMethodOverride ?? null);
+    const [isReady, setIsReady] = useState(false);
     // Resolve code/token from query (preferred) or localStorage; clientId/authMethod from localStorage only
     useEffect(() => {
         const query = navigator.query;
@@ -17,17 +34,27 @@ const SSOCallbackComponents = () => {
         if (typeof window !== 'undefined') {
             try {
                 const storedClientId = localStorage.getItem('clientId') || '';
+                const storedAuthMethod = localStorage.getItem('authMethod') || 'oidc';
                 setClientId(storedClientId);
+                if (!authMethodOverride) {
+                    setAuthMethod(storedAuthMethod);
+                }
                 setCode(typeof codeFromQuery === 'string' ? codeFromQuery : '');
+                setIsReady(true);
             }
             catch (error) {
                 console.log('Failed to read from localStorage:', error);
                 setCode(typeof codeFromQuery === 'string' ? codeFromQuery : '');
-                // Fallback: proceed without stored values
+                setIsReady(true);
             }
         }
-    }, [navigator.query]);
-    const { result, error } = useSSOCallback({ clientId, code });
+    }, [navigator.query, authMethodOverride]);
+    const { result, error } = useSSOCallback({
+        clientId,
+        code,
+        authMethod: authMethod ?? 'oidc',
+        isReady,
+    });
     useEffect(() => {
         if (result?.registrationToken) {
             navigator.pushAbsolute('/registration', {
@@ -45,14 +72,15 @@ const SSOCallbackComponents = () => {
             }, 1500);
         }
     }, [error, navigator]);
-    return (_jsx(Flex, { justify: 'center', align: 'center', className: 'h-[100vh]', children: _jsxs("div", { children: [_jsx(Suspense, { fallback: _jsx("div", { className: "h-[230px] w-[250px]" }), children: _jsx(Lottie
-                    //@ts-ignore
-                    , { 
+    const loadingFallback = _jsx("div", { className: "h-[230px] w-[250px]" });
+    return (_jsx(Flex, { justify: 'center', align: 'center', className: 'h-[100vh]', children: _jsxs("div", { children: [_jsx(LottieErrorBoundary, { fallback: loadingFallback, children: _jsx(Suspense, { fallback: loadingFallback, children: _jsx(Lottie
                         //@ts-ignore
-                        options: {
-                            animationData: redirectAnimation,
-                            loop: true,
-                            autoplay: true
-                        }, height: 230, width: 250 }) }), _jsx(Typography, { size: 'h6', type: 'heading', color: 'gray-400', children: "Authenticating and Redirecting ..." })] }) }));
+                        , { 
+                            //@ts-ignore
+                            options: {
+                                animationData: redirectAnimation,
+                                loop: true,
+                                autoplay: true
+                            }, height: 230, width: 250 }) }) }), _jsx(Typography, { size: 'h6', type: 'heading', color: 'gray-400', children: "Authenticating and Redirecting ..." })] }) }));
 };
 export { SSOCallbackComponents };

package/build/src/screens/SSOLogin/SSOCallback/hooks/internal/useSSOCallback.js

@@ -7,17 +7,25 @@ import { RegistrationMethod } from "../../../../../enums";
  * @internal
  * Hook for managing SSOCallback screen state and auth context integration.
  * This hook is not exposed to package consumers.
+ *
+ * Supports both OIDC and SAML flows:
+ * - OIDC: Calls /callback endpoint with authorization code
+ * - SAML: Calls /saml-sso-complete endpoint with exchange code
  */
-const useSSOCallback = ({ clientId, code }) => {
+const useSSOCallback = ({ clientId, code, authMethod, isReady = true }) => {
     const [error, setError] = useState(null);
     const [result, setResult] = useState(null);
+    const [hasProcessed, setHasProcessed] = useState(false);
     const { onLogin, onRegistrationMethodChange, onTokenChange } = useAuthPackageContext();
-    const processOAuthCallback = useCallback((code) => {
+    const processSSOCallback = useCallback((codeToProcess) => {
         setError(null);
+        const endpoint = authMethod === 'saml'
+            ? `/auth/login-sso/${clientId}/saml-sso-complete`
+            : `/auth/login-sso/${clientId}/callback`;
         axiosClient({
-            url: `/auth/login-sso/${clientId}/callback`,
+            url: endpoint,
             method: 'POST',
-            data: { code },
+            data: { code: codeToProcess },
         }).then((res) => {
             if (res?.data?.registrationToken) {
                 onRegistrationMethodChange(RegistrationMethod.SSO);
@@ -32,12 +40,13 @@ const useSSOCallback = ({ clientId, code }) => {
             setError(errorMessage);
             return showMessage({ message: errorMessage });
         });
-    }, [clientId, code]);
+    }, [clientId, authMethod, onLogin, onRegistrationMethodChange, onTokenChange]);
     useEffect(() => {
-        if (code && clientId) {
-            processOAuthCallback(code);
+        if (isReady && code && clientId && !hasProcessed) {
+            setHasProcessed(true);
+            processSSOCallback(code);
         }
-    }, [code, clientId]);
+    }, [isReady, code, clientId, hasProcessed, processSSOCallback]);
     return { result, error };
 };
 export { useSSOCallback };

package/build/src/screens/SSOLogin/SSOCallback/index.native.js

@@ -8,8 +8,8 @@ import loadingSpinner from '../../../../assets/loading-spinner.json';
 import Lottie from 'lottie-react-native';
 const { gray } = Colors;
 const SSOCallback = ({ navigation, route }) => {
-    const { clientId, code } = route.params;
-    const { result, error } = useSSOCallback({ clientId, code });
+    const { clientId, code, authMethod } = route.params;
+    const { result, error } = useSSOCallback({ clientId, code, authMethod });
     useEffect(() => {
         if (result?.registrationToken) {
             navigation.replace('SignUp', { ...result });

package/build/types/navigator/index.native.d.ts

@@ -1,5 +1,6 @@
 import { type NativeStackScreenProps } from '@react-navigation/native-stack';
 import type { Client, PersonalDetails } from '../types/types';
+import type { AuthMethod } from '../screens/SSOLogin/AuthenticationMethods/types';
 declare const AuthNavigator: () => import("react/jsx-runtime").JSX.Element;
 export { AuthNavigator };
 export type AuthStackParamList = {
@@ -55,11 +56,13 @@ export type AuthStackParamList = {
     SSOCallback: {
         code?: string;
         clientId: number;
+        authMethod?: AuthMethod;
     };
     SSOAuthWebView: {
         clientId: number;
         authenticationUrl: string;
-        redirectUri: string;
+        redirectUri?: string;
+        authMethod: AuthMethod;
     };
     EnterMobile: undefined;
     LoginWithMobileOTP: {

package/build/types/screens/SSOLogin/AuthenticationMethods/types.d.ts

@@ -1,12 +1,14 @@
 import type { Client } from "../../../types/types";
+type AuthMethod = 'oidc' | 'saml';
 interface SSOInitiationData {
     clientId: number;
     authenticationUrl: string;
-    redirectUri: string;
+    redirectUri?: string;
+    authMethod: AuthMethod;
 }
 interface SSOAuthenticationMethodsProps {
     client: Client;
     onPressBack: () => void;
     handleMobileLogin: () => void;
 }
-export type { SSOAuthenticationMethodsProps, SSOInitiationData };
+export type { SSOAuthenticationMethodsProps, SSOInitiationData, AuthMethod };

package/build/types/screens/SSOLogin/SSOCallback/components/SSOCallbackComponent/index.d.ts

@@ -1,2 +1,6 @@
-declare const SSOCallbackComponents: () => import("react/jsx-runtime").JSX.Element;
+import type { AuthMethod } from '../../../AuthenticationMethods/types';
+interface SSOCallbackComponentsProps {
+    authMethodOverride?: AuthMethod;
+}
+declare const SSOCallbackComponents: ({ authMethodOverride }?: SSOCallbackComponentsProps) => import("react/jsx-runtime").JSX.Element;
 export { SSOCallbackComponents };

package/build/types/screens/SSOLogin/SSOCallback/hooks/internal/useSSOCallback.d.ts

@@ -3,8 +3,12 @@ import type { useSSOCallbackProps, SignUpData } from "../../types";
  * @internal
  * Hook for managing SSOCallback screen state and auth context integration.
  * This hook is not exposed to package consumers.
+ *
+ * Supports both OIDC and SAML flows:
+ * - OIDC: Calls /callback endpoint with authorization code
+ * - SAML: Calls /saml-sso-complete endpoint with exchange code
  */
-declare const useSSOCallback: ({ clientId, code }: useSSOCallbackProps) => {
+declare const useSSOCallback: ({ clientId, code, authMethod, isReady }: useSSOCallbackProps) => {
     result: SignUpData | null;
     error: string | null;
 };

package/build/types/screens/SSOLogin/SSOCallback/types.d.ts

@@ -1,3 +1,4 @@
+import type { AuthMethod } from '../AuthenticationMethods/types';
 interface SignUpData {
     email: string;
     firstName: string;
@@ -7,5 +8,7 @@ interface SignUpData {
 interface useSSOCallbackProps {
     code?: string;
     clientId: number | string;
+    authMethod?: AuthMethod;
+    isReady?: boolean;
 }
 export type { useSSOCallbackProps, SignUpData };

package/package.json

@@ -4,7 +4,7 @@
     "access": "public"
   },
   "description": "Truworth Auth Package for React Native and Web",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "main": "build/src/index.js",
   "types": "build/types/index.d.ts",
   "files": [