@asgardeo/react 0.6.9 → 0.6.11

package/dist/cjs/index.js

@@ -1642,14 +1642,24 @@ var AsgardeoProvider = ({
       const currentUrl = new URL(window.location.href);
       const hasAuthParamsResult = hasAuthParams(currentUrl, afterSignInUrl);
       const isV2Platform = config.platform === import_browser12.Platform.AsgardeoV2;
-      if (hasAuthParamsResult && !isV2Platform) {
+      if (hasAuthParamsResult) {
         try {
-          await signIn(
-            { callOnlyOnRedirect: true }
-            // authParams?.authorizationCode,
-            // authParams?.sessionState,
-            // authParams?.state,
-          );
+          if (isV2Platform) {
+            const urlParams = currentUrl.searchParams;
+            const code = urlParams.get("code");
+            const flowIdFromUrl = urlParams.get("flowId");
+            const storedFlowId = sessionStorage.getItem("asgardeo_flow_id");
+            if (code && !flowIdFromUrl && !storedFlowId) {
+              await signIn();
+            }
+          } else {
+            await signIn(
+              { callOnlyOnRedirect: true }
+              // authParams?.authorizationCode,
+              // authParams?.sessionState,
+              // authParams?.state,
+            );
+          }
         } catch (error) {
           if (error && Object.prototype.hasOwnProperty.call(error, "code")) {
           }
@@ -7643,18 +7653,87 @@ var SignIn = ({ className, size = "medium", onSuccess, onError, variant, childre
   const [isSubmitting, setIsSubmitting] = (0, import_react59.useState)(false);
   const initializationAttemptedRef = (0, import_react59.useRef)(false);
   const oauthCodeProcessedRef = (0, import_react59.useRef)(false);
+  const setFlowId = (flowId) => {
+    setCurrentFlowId(flowId);
+    if (flowId) {
+      sessionStorage.setItem("asgardeo_flow_id", flowId);
+    } else {
+      sessionStorage.removeItem("asgardeo_flow_id");
+    }
+  };
+  const clearFlowState = () => {
+    setFlowId(null);
+    setIsFlowInitialized(false);
+    sessionStorage.removeItem("asgardeo_session_data_key");
+    oauthCodeProcessedRef.current = false;
+  };
+  const getUrlParams = () => {
+    const urlParams = new URL(window?.location?.href ?? "").searchParams;
+    return {
+      code: urlParams.get("code"),
+      error: urlParams.get("error"),
+      errorDescription: urlParams.get("error_description"),
+      state: urlParams.get("state"),
+      nonce: urlParams.get("nonce"),
+      flowId: urlParams.get("flowId"),
+      applicationId: urlParams.get("applicationId"),
+      sessionDataKey: urlParams.get("sessionDataKey")
+    };
+  };
+  const handleSessionDataKey = (sessionDataKey) => {
+    if (sessionDataKey) {
+      sessionStorage.setItem("asgardeo_session_data_key", sessionDataKey);
+    }
+  };
+  const resolveFlowId = (currentFlowId2, state, flowIdFromUrl, storedFlowId) => {
+    return currentFlowId2 || state || flowIdFromUrl || storedFlowId || null;
+  };
+  const cleanupOAuthUrlParams = (includeNonce = false) => {
+    if (!window?.location?.href) return;
+    const url = new URL(window.location.href);
+    url.searchParams.delete("error");
+    url.searchParams.delete("error_description");
+    url.searchParams.delete("code");
+    url.searchParams.delete("state");
+    if (includeNonce) {
+      url.searchParams.delete("nonce");
+    }
+    window?.history?.replaceState({}, "", url.toString());
+  };
+  const cleanupFlowUrlParams = () => {
+    if (!window?.location?.href) return;
+    const url = new URL(window.location.href);
+    url.searchParams.delete("flowId");
+    url.searchParams.delete("sessionDataKey");
+    url.searchParams.delete("applicationId");
+    window?.history?.replaceState({}, "", url.toString());
+  };
+  const handleOAuthError = (error, errorDescription) => {
+    console.warn("[SignIn] OAuth error detected:", error);
+    clearFlowState();
+    const errorMessage = errorDescription || `OAuth error: ${error}`;
+    const err = new import_browser51.AsgardeoRuntimeError(
+      errorMessage,
+      "SIGN_IN_ERROR",
+      "react"
+    );
+    setError(err);
+    cleanupOAuthUrlParams(true);
+  };
+  const setError = (error) => {
+    setFlowError(error);
+    setIsFlowInitialized(true);
+    onError?.(error);
+  };
   const handleRedirection = (response) => {
     if (response.type === import_browser51.EmbeddedSignInFlowTypeV2.Redirection) {
       const redirectURL = response.data?.redirectURL || response?.redirectURL;
-      if (redirectURL) {
+      if (redirectURL && window?.location) {
         if (response.flowId) {
-          sessionStorage.setItem("asgardeo_flow_id", response.flowId);
-        }
-        const urlParams = new URL(window.location.href).searchParams;
-        const sessionDataKeyFromUrl = urlParams.get("sessionDataKey");
-        if (sessionDataKeyFromUrl) {
-          sessionStorage.setItem("asgardeo_session_data_key", sessionDataKeyFromUrl);
+          setFlowId(response.flowId);
         }
+        const urlParams = getUrlParams();
+        handleSessionDataKey(urlParams.sessionDataKey);
         window.location.href = redirectURL;
         return true;
       }
@@ -7663,58 +7742,41 @@ var SignIn = ({ className, size = "medium", onSuccess, onError, variant, childre
   };
   (0, import_react59.useEffect)(() => {
     const storedFlowId = sessionStorage.getItem("asgardeo_flow_id");
-    const urlParams = new URL(window.location.href).searchParams;
-    const code = urlParams.get("code");
-    const state = urlParams.get("state");
-    const sessionDataKeyFromUrl = urlParams.get("sessionDataKey");
-    if (sessionDataKeyFromUrl) {
-      sessionStorage.setItem("asgardeo_session_data_key", sessionDataKeyFromUrl);
-    }
-    if (code) {
-      const flowIdFromUrl = urlParams.get("flowId");
-      const flowIdFromState = state || flowIdFromUrl || storedFlowId;
-      if (flowIdFromState) {
-        setCurrentFlowId(flowIdFromState);
-        setIsFlowInitialized(true);
-        sessionStorage.setItem("asgardeo_flow_id", flowIdFromState);
-        initializationAttemptedRef.current = true;
-      }
+    const urlParams = getUrlParams();
+    if (urlParams.error) {
+      handleOAuthError(urlParams.error, urlParams.errorDescription);
+      return;
+    }
+    handleSessionDataKey(urlParams.sessionDataKey);
+    if (urlParams.code || urlParams.state) {
       return;
     }
-    if (isInitialized && !isLoading && !isFlowInitialized && !initializationAttemptedRef.current && !currentFlowId) {
+    const currentUrlParams = getUrlParams();
+    if (isInitialized && !isLoading && !isFlowInitialized && !initializationAttemptedRef.current && !currentFlowId && !currentUrlParams.code && !currentUrlParams.state && !isSubmitting && !oauthCodeProcessedRef.current) {
       initializationAttemptedRef.current = true;
       initializeFlow();
     }
   }, [isInitialized, isLoading, isFlowInitialized, currentFlowId]);
   const initializeFlow = async () => {
-    const urlParams = new URL(window.location.href).searchParams;
-    const code = urlParams.get("code");
-    if (code) {
-      return;
-    }
-    const flowIdFromUrl = urlParams.get("flowId");
-    const applicationIdFromUrl = urlParams.get("applicationId");
-    const sessionDataKeyFromUrl = urlParams.get("sessionDataKey");
-    if (sessionDataKeyFromUrl) {
-      sessionStorage.setItem("asgardeo_session_data_key", sessionDataKeyFromUrl);
-    }
-    const effectiveApplicationId = applicationId || applicationIdFromUrl;
-    if (!flowIdFromUrl && !effectiveApplicationId) {
+    const urlParams = getUrlParams();
+    oauthCodeProcessedRef.current = false;
+    handleSessionDataKey(urlParams.sessionDataKey);
+    const effectiveApplicationId = applicationId || urlParams.applicationId;
+    if (!urlParams.flowId && !effectiveApplicationId) {
       const error = new import_browser51.AsgardeoRuntimeError(
         "Either flowId or applicationId is required for authentication",
-        "SignIn-initializeFlow-RuntimeError-001",
-        "react",
-        "Something went wrong while trying to sign in. Please try again later."
+        "SIGN_IN_ERROR",
+        "react"
       );
-      setFlowError(error);
+      setError(error);
       throw error;
     }
     try {
       setFlowError(null);
       let response;
-      if (flowIdFromUrl) {
+      if (urlParams.flowId) {
         response = await signIn({
-          flowId: flowIdFromUrl
+          flowId: urlParams.flowId
         });
       } else {
         response = await signIn({
@@ -7727,20 +7789,23 @@ var SignIn = ({ className, size = "medium", onSuccess, onError, variant, childre
       }
       const { flowId, components: components2 } = normalizeFlowResponse(response, t);
       if (flowId && components2) {
-        setCurrentFlowId(flowId);
+        setFlowId(flowId);
         setComponents(components2);
         setIsFlowInitialized(true);
+        cleanupFlowUrlParams();
       }
     } catch (error) {
       const err = error;
-      setFlowError(err);
-      onError?.(err);
-      throw new import_browser51.AsgardeoRuntimeError(
-        `Failed to initialize authentication flow: ${error instanceof Error ? error.message : String(error)}`,
-        "SignIn-initializeFlow-RuntimeError-002",
-        "react",
-        "Something went wrong while trying to sign in. Please try again later."
+      clearFlowState();
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      const displayError = new import_browser51.AsgardeoRuntimeError(
+        errorMessage,
+        "SIGN_IN_ERROR",
+        "react"
       );
+      setError(displayError);
+      initializationAttemptedRef.current = false;
+      return;
     }
   };
   const handleSubmit = async (payload) => {
@@ -7763,81 +7828,99 @@ var SignIn = ({ className, size = "medium", onSuccess, onError, variant, childre
         return;
       }
       const { flowId, components: components2 } = normalizeFlowResponse(response, t);
+      if (response.flowStatus === import_browser51.EmbeddedSignInFlowStatusV2.Error) {
+        console.error("[SignIn] Flow returned Error status, clearing flow state");
+        clearFlowState();
+        const failureReason = response?.failureReason;
+        const errorMessage = failureReason || "Authentication flow failed. Please try again.";
+        const err = new import_browser51.AsgardeoRuntimeError(
+          errorMessage,
+          "SIGN_IN_ERROR",
+          "react"
+        );
+        setError(err);
+        cleanupFlowUrlParams();
+        return;
+      }
       if (response.flowStatus === import_browser51.EmbeddedSignInFlowStatusV2.Complete) {
-        const redirectUrl = response.redirectUrl || response.redirect_uri;
-        sessionStorage.removeItem("asgardeo_flow_id");
-        if (redirectUrl) {
-          sessionStorage.removeItem("asgardeo_session_data_key");
-        }
-        const url = new URL(window.location.href);
-        url.searchParams.delete("code");
-        url.searchParams.delete("state");
-        url.searchParams.delete("nonce");
-        window.history.replaceState({}, "", url.toString());
+        const redirectUrl = response?.redirectUrl || response?.redirect_uri;
         const finalRedirectUrl = redirectUrl || afterSignInUrl;
+        setIsSubmitting(false);
+        setFlowId(null);
+        setIsFlowInitialized(false);
+        sessionStorage.removeItem("asgardeo_flow_id");
+        sessionStorage.removeItem("asgardeo_session_data_key");
+        cleanupOAuthUrlParams(true);
         onSuccess && onSuccess({
           redirectUrl: finalRedirectUrl,
-          ...response.data
+          ...response.data || {}
         });
-        if (finalRedirectUrl) {
+        if (finalRedirectUrl && window?.location) {
           window.location.href = finalRedirectUrl;
+        } else {
+          console.warn("[SignIn] Flow completed but no redirect URL available");
         }
         return;
       }
       if (flowId && components2) {
-        setCurrentFlowId(flowId);
+        setFlowId(flowId);
         setComponents(components2);
-      }
-      if (!currentFlowId && effectiveFlowId) {
-        setCurrentFlowId(effectiveFlowId);
+        setIsFlowInitialized(true);
+        cleanupFlowUrlParams();
       }
     } catch (error) {
       const err = error;
-      setFlowError(err);
-      onError?.(err);
-      throw new import_browser51.AsgardeoRuntimeError(
-        `Failed to submit authentication flow: ${error instanceof Error ? error.message : String(error)}`,
-        "SignIn-handleSubmit-RuntimeError-001",
-        "react",
-        "Something went wrong while trying to sign in. Please try again later."
+      clearFlowState();
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      const displayError = new import_browser51.AsgardeoRuntimeError(
+        errorMessage,
+        "SIGN_IN_ERROR",
+        "react"
       );
+      setError(displayError);
+      return;
     } finally {
       setIsSubmitting(false);
     }
   };
   const handleError = (error) => {
     console.error("Authentication error:", error);
-    setFlowError(error);
-    onError?.(error);
+    setError(error);
   };
   (0, import_react59.useEffect)(() => {
-    const urlParams = new URL(window.location.href).searchParams;
-    const code = urlParams.get("code");
-    const nonce = urlParams.get("nonce");
-    const state = urlParams.get("state");
-    const flowIdFromUrl = urlParams.get("flowId");
+    const urlParams = getUrlParams();
     const storedFlowId = sessionStorage.getItem("asgardeo_flow_id");
-    if (!code || oauthCodeProcessedRef.current || isSubmitting) {
+    if (urlParams.error) {
+      handleOAuthError(urlParams.error, urlParams.errorDescription);
+      oauthCodeProcessedRef.current = true;
+      return;
+    }
+    if (!urlParams.code || oauthCodeProcessedRef.current || isSubmitting) {
       return;
     }
-    const flowIdToUse = currentFlowId || state || flowIdFromUrl || storedFlowId;
+    const flowIdToUse = resolveFlowId(
+      currentFlowId,
+      urlParams.state,
+      urlParams.flowId,
+      storedFlowId
+    );
     if (!flowIdToUse || !signIn) {
       return;
     }
     oauthCodeProcessedRef.current = true;
     if (!currentFlowId) {
-      setCurrentFlowId(flowIdToUse);
-      setIsFlowInitialized(true);
+      setFlowId(flowIdToUse);
     }
     const submitPayload = {
       flowId: flowIdToUse,
       inputs: {
-        code,
-        ...nonce && { nonce }
+        code: urlParams.code,
+        ...urlParams.nonce && { nonce: urlParams.nonce }
       }
     };
-    handleSubmit(submitPayload).catch(() => {
-      oauthCodeProcessedRef.current = false;
+    handleSubmit(submitPayload).catch((error) => {
+      console.error("[SignIn] OAuth callback submission failed:", error);
+      cleanupOAuthUrlParams(true);
     });
   }, [isFlowInitialized, currentFlowId, isInitialized, isLoading, isSubmitting, signIn]);
   if (children) {
@@ -8962,7 +9045,21 @@ var BaseSignUpContent = ({
       handleSubmit
     ]
   );
+  const getUrlParams = () => {
+    const urlParams = new URL(window?.location?.href ?? "").searchParams;
+    return {
+      code: urlParams.get("code"),
+      state: urlParams.get("state"),
+      error: urlParams.get("error")
+    };
+  };
   (0, import_react61.useEffect)(() => {
+    if (platform === import_browser61.Platform.AsgardeoV2) {
+      const urlParams = getUrlParams();
+      if (urlParams.code || urlParams.state) {
+        return;
+      }
+    }
     if (isInitialized && !isFlowInitialized && !initializationAttemptedRef.current) {
       initializationAttemptedRef.current = true;
       (async () => {