antaeus.keycloak.react 2.3.0 → 2.5.0

package/dist/index.js

@@ -152,6 +152,14 @@ var useAuth = reactOidcContext.useAuth;
 
 // src/hooks/useTokenLifecycle.ts
 var STORAGE_KEY_PREFIX = "keycloak_first_login_";
+var isNavigatorOffline = () => typeof navigator !== "undefined" && "onLine" in navigator && navigator.onLine === false;
+var isTransientNetworkError = (error) => {
+  const message = error.message?.toLowerCase?.() ?? "";
+  if (!message) {
+    return false;
+  }
+  return message.includes("network") || message.includes("failed to fetch") || message.includes("fetch") || message.includes("timeout") || message.includes("temporarily unavailable") || message.includes("dns") || message.includes("offline");
+};
 function useTokenLifecycle(options) {
   const {
     config,
@@ -166,6 +174,11 @@ function useTokenLifecycle(options) {
   const [isRefreshTokenExpired, setIsRefreshTokenExpired] = react.useState(false);
   const hasCheckedOnStartup = react.useRef(false);
   const supportsRefreshTokens = config.silentRenew?.useRefreshToken !== false;
+  const [pendingRetry, setPendingRetry] = react.useState(null);
+  const deferredRefreshReasonRef = react.useRef(null);
+  const enqueueRetry = react.useCallback((reason) => {
+    setPendingRetry((current) => current === reason ? current : reason);
+  }, []);
   const log = react.useCallback(
     (message, ...args) => {
       if (debug) {
@@ -216,6 +229,7 @@ function useTokenLifecycle(options) {
       return;
     }
     setIsRefreshing(true);
+    deferredRefreshReasonRef.current = null;
     try {
       if (checkRefreshTokenLifetime()) {
         log("Refresh token exceeded max lifetime, cannot refresh");
@@ -223,6 +237,12 @@ function useTokenLifecycle(options) {
         onRefreshTokenExpired?.();
         return;
       }
+      if (isNavigatorOffline()) {
+        log("Device offline, deferring token refresh until connection is restored");
+        deferredRefreshReasonRef.current = "offline";
+        enqueueRetry("offline");
+        return;
+      }
       onRefreshStart?.();
       log("Starting token refresh");
       await auth.signinSilent();
@@ -230,6 +250,21 @@ function useTokenLifecycle(options) {
       onRefreshSuccess?.();
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
+      if (isTransientNetworkError(err)) {
+        const reason = isNavigatorOffline() ? "offline" : "network";
+        deferredRefreshReasonRef.current = reason;
+        if (reason === "offline") {
+          log("Token refresh deferred because device is offline");
+        } else {
+          log(
+            "Token refresh failed due to transient network issue, will retry automatically:",
+            err.message
+          );
+        }
+        enqueueRetry(reason);
+        onRefreshError?.(err);
+        return;
+      }
       log("Token refresh failed:", err.message);
       onRefreshError?.(err);
       throw err;
@@ -244,6 +279,7 @@ function useTokenLifecycle(options) {
     onRefreshSuccess,
     onRefreshError,
     onRefreshTokenExpired,
+    enqueueRetry,
     log
   ]);
   const checkAndRefreshTokens = react.useCallback(async () => {
@@ -282,6 +318,14 @@ function useTokenLifecycle(options) {
     if (timeUntilExpiry <= threshold) {
       try {
         await refreshToken();
+        if (deferredRefreshReasonRef.current) {
+          log(
+            "Token refresh was deferred due to pending retry:",
+            deferredRefreshReasonRef.current
+          );
+          deferredRefreshReasonRef.current = null;
+          return false;
+        }
         return true;
       } catch (error) {
         log("Failed to refresh tokens:", error);
@@ -299,6 +343,55 @@ function useTokenLifecycle(options) {
     getStorageKey,
     log
   ]);
+  react.useEffect(() => {
+    if (pendingRetry === null) {
+      return;
+    }
+    if (typeof window === "undefined") {
+      return;
+    }
+    let cancelled = false;
+    const executeRetry = () => {
+      if (cancelled) {
+        return;
+      }
+      if (isRefreshing) {
+        log("Skipping scheduled token refresh retry because a refresh is already in progress");
+        return;
+      }
+      refreshToken().catch((err) => {
+        log("Scheduled token refresh retry failed:", err);
+      });
+    };
+    if (pendingRetry === "offline") {
+      log("Waiting for online event to retry token refresh");
+      const handleOnline = () => {
+        if (cancelled) {
+          return;
+        }
+        log("Online event detected, retrying deferred token refresh");
+        setPendingRetry(null);
+        executeRetry();
+      };
+      window.addEventListener("online", handleOnline, { once: true });
+      return () => {
+        cancelled = true;
+        window.removeEventListener("online", handleOnline);
+      };
+    }
+    const timeoutId = window.setTimeout(() => {
+      if (cancelled) {
+        return;
+      }
+      log("Retrying token refresh after transient network failure delay");
+      setPendingRetry(null);
+      executeRetry();
+    }, 5e3);
+    return () => {
+      cancelled = true;
+      window.clearTimeout(timeoutId);
+    };
+  }, [pendingRetry, refreshToken, isRefreshing, log]);
   react.useEffect(() => {
     const strategy = config.silentRenew?.refreshStrategy || "both";
     const shouldCheckOnStartup = strategy === "startup" || strategy === "both";
@@ -659,6 +752,71 @@ var SessionMonitor = ({
   ] });
 };
 
+// src/utils/tokenBridge.ts
+var TokenBridge = class {
+  constructor() {
+    this.currentToken = null;
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Update the tracked token and notify subscribers when it changes.
+   */
+  setToken(token) {
+    if (this.currentToken === token) {
+      return;
+    }
+    this.currentToken = token;
+    for (const listener of this.listeners) {
+      try {
+        listener(token);
+      } catch (error) {
+        console.error("[TokenBridge] Listener threw error:", error);
+      }
+    }
+  }
+  /**
+   * Read the most recent token value.
+   */
+  getToken() {
+    return this.currentToken;
+  }
+  /**
+   * Convenience helper for async callers.
+   */
+  async getTokenAsync() {
+    return this.currentToken;
+  }
+  /**
+   * Subscribe to token changes. Returns an unsubscribe callback.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.currentToken);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+};
+var createTokenBridge = () => new TokenBridge();
+var defaultTokenBridge = createTokenBridge();
+
+// src/components/TokenBridge.tsx
+var TokenBridgeSync = ({
+  bridge = defaultTokenBridge
+}) => {
+  const auth = useAuth();
+  react.useEffect(() => {
+    const token = auth.user?.access_token ?? null;
+    bridge.setToken(token);
+  }, [auth.user, bridge]);
+  react.useEffect(() => {
+    if (!auth.isAuthenticated) {
+      bridge.setToken(null);
+    }
+  }, [auth.isAuthenticated, bridge]);
+  return null;
+};
+
 // src/config/presets.ts
 var CONFIG_PRESETS = {
   /**
@@ -877,11 +1035,97 @@ var StorageConfigProvider = ({ storageType, children }) => {
   return /* @__PURE__ */ jsxRuntime.jsx(StorageConfigContext.Provider, { value: { storageType, storage }, children });
 };
 var useStorageConfig = () => react.useContext(StorageConfigContext);
+var defaultStatus = {
+  isEnabled: true,
+  isConfigured: true
+};
+var KeycloakStatusContext = react.createContext(defaultStatus);
+var KeycloakStatusProvider = KeycloakStatusContext.Provider;
+var useKeycloakStatus = () => react.useContext(KeycloakStatusContext);
+var createDisabledEvents = () => {
+  const noop = () => void 0;
+  const noopSubscription = () => () => void 0;
+  const noopAsync = async () => void 0;
+  const events = {
+    addAccessTokenExpiring: noopSubscription,
+    removeAccessTokenExpiring: noop,
+    addAccessTokenExpired: noopSubscription,
+    removeAccessTokenExpired: noop,
+    addSilentRenewError: noopSubscription,
+    removeSilentRenewError: noop,
+    addUserLoaded: noopSubscription,
+    removeUserLoaded: noop,
+    addUserUnloaded: noopSubscription,
+    removeUserUnloaded: noop,
+    addUserSignedIn: noopSubscription,
+    removeUserSignedIn: noop,
+    addUserSignedOut: noopSubscription,
+    removeUserSignedOut: noop,
+    addUserSessionChanged: noopSubscription,
+    removeUserSessionChanged: noop,
+    load: noopAsync,
+    unload: noopAsync
+  };
+  return events;
+};
+var disabledEvents = createDisabledEvents();
+var disabledSettings = {
+  authority: "",
+  client_id: "",
+  redirect_uri: "http://localhost/disabled",
+  response_type: "code",
+  scope: ""
+};
+var disabledError = () => new Error("Keycloak integration is disabled for this environment.");
+var disabledAsync = async () => {
+  throw disabledError();
+};
+var disabledAuthContext = {
+  settings: disabledSettings,
+  events: disabledEvents,
+  clearStaleState: async () => void 0,
+  removeUser: async () => void 0,
+  signinPopup: (_args) => disabledAsync(),
+  signinSilent: async (_args) => null,
+  signinRedirect: (_args) => disabledAsync(),
+  signinResourceOwnerCredentials: (_args) => disabledAsync(),
+  signoutRedirect: async (_args) => void 0,
+  signoutPopup: async (_args) => void 0,
+  signoutSilent: async (_args) => void 0,
+  querySessionStatus: async (_args) => null,
+  revokeTokens: async (_types) => void 0,
+  startSilentRenew: () => void 0,
+  stopSilentRenew: () => void 0,
+  user: null,
+  isLoading: false,
+  isAuthenticated: false,
+  activeNavigator: void 0,
+  error: void 0
+};
 function isZeroConfig(props) {
   return "authority" in props && "clientId" in props;
 }
 var KeycloakProvider = (props) => {
   const { children, debug = false } = props;
+  const status = react.useMemo(() => {
+    const enabledFlag = props.enabled ?? true;
+    const hasAuthority = isZeroConfig(props) ? Boolean(props.authority) : Boolean(props.config.authority);
+    const hasClientId = isZeroConfig(props) ? Boolean(props.clientId) : Boolean(props.config.clientId);
+    return {
+      isEnabled: enabledFlag,
+      isConfigured: hasAuthority && hasClientId,
+      reason: !enabledFlag ? "disabled" : !hasAuthority || !hasClientId ? "missing-config" : void 0
+    };
+  }, [props]);
+  const effectiveEnabled = status.isEnabled && status.isConfigured;
+  react.useEffect(() => {
+    if (!effectiveEnabled && props.tokenBridge) {
+      props.tokenBridge.setToken(null);
+    }
+  }, [effectiveEnabled, props.tokenBridge]);
+  if (!effectiveEnabled) {
+    return /* @__PURE__ */ jsxRuntime.jsx(KeycloakStatusProvider, { value: status, children: /* @__PURE__ */ jsxRuntime.jsx(reactOidcContext.AuthContext.Provider, { value: disabledAuthContext, children: /* @__PURE__ */ jsxRuntime.jsx(StorageConfigProvider, { storageType: "session", children }) }) });
+  }
   const config = isZeroConfig(props) ? buildZeroConfig(props) : props.config;
   const oidcConfig = KeycloakConfigBuilder.build(config);
   const log = react.useCallback(
@@ -923,7 +1167,7 @@ var KeycloakProvider = (props) => {
   }, [log]);
   const showSessionMonitor = config.features?.sessionMonitor !== false;
   const storageType = config.advanced?.storageType || "session";
-  return /* @__PURE__ */ jsxRuntime.jsx(
+  return /* @__PURE__ */ jsxRuntime.jsx(KeycloakStatusProvider, { value: status, children: /* @__PURE__ */ jsxRuntime.jsx(
     reactOidcContext.AuthProvider,
     {
       ...oidcConfig,
@@ -931,11 +1175,12 @@ var KeycloakProvider = (props) => {
       onSignoutCallback,
       onRemoveUser,
       children: /* @__PURE__ */ jsxRuntime.jsx(StorageConfigProvider, { storageType, children: /* @__PURE__ */ jsxRuntime.jsxs(TokenLifecycleManager, { config, debug, children: [
+        props.tokenBridge && /* @__PURE__ */ jsxRuntime.jsx(TokenBridgeSync, { bridge: props.tokenBridge }),
         showSessionMonitor && /* @__PURE__ */ jsxRuntime.jsx(SessionMonitor, {}),
         children
       ] }) })
     }
-  );
+  ) });
 };
 function buildZeroConfig(props) {
   const { authority, clientId, preset = "default", config: overrides = {} } = props;
@@ -1643,13 +1888,18 @@ exports.CONFIG_PRESETS = CONFIG_PRESETS;
 exports.DeviceLogin = DeviceLogin;
 exports.KeycloakConfigBuilder = KeycloakConfigBuilder;
 exports.KeycloakProvider = KeycloakProvider;
+exports.KeycloakStatusProvider = KeycloakStatusProvider;
 exports.LoginButton = LoginButton;
 exports.LogoutButton = LogoutButton;
 exports.ProtectedRoute = ProtectedRoute;
 exports.SessionMonitor = SessionMonitor;
+exports.TokenBridge = TokenBridge;
+exports.TokenBridgeSync = TokenBridgeSync;
 exports.TokenLifecycleManager = TokenLifecycleManager;
 exports.UserProfile = UserProfile;
+exports.createTokenBridge = createTokenBridge;
 exports.defaultConfig = defaultConfig;
+exports.defaultTokenBridge = defaultTokenBridge;
 exports.fetchUserInfo = fetchUserInfo;
 exports.getConfigFromEnv = getConfigFromEnv;
 exports.getConfigPreset = getConfigPreset;
@@ -1657,6 +1907,7 @@ exports.mergeWithPreset = mergeWithPreset;
 exports.pollForToken = pollForToken;
 exports.requestDeviceCode = requestDeviceCode;
 exports.useAuth = useAuth;
+exports.useKeycloakStatus = useKeycloakStatus;
 exports.useProtectedFetch = useProtectedFetch;
 exports.useRoles = useRoles;
 exports.useScopes = useScopes;