antaeus.keycloak.react 2.2.3 → 2.4.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { createContext, useState, useRef, useCallback, useEffect, useMemo, useContext } from 'react';
-import { useAuth as useAuth$1, AuthProvider } from 'react-oidc-context';
+import { createContext, useContext, useState, useRef, useCallback, useEffect, useMemo } from 'react';
+import { useAuth as useAuth$1, AuthContext, AuthProvider } from 'react-oidc-context';
 import { WebStorageStateStore, User } from 'oidc-client-ts';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { useLocation } from 'react-router-dom';
@@ -27,7 +27,8 @@ var defaultConfig = {
     maxRefreshTokenLifetime: 2592e3,
     // 30 days in seconds
     showLoadingIndicator: false,
-    loadingMessage: "Refreshing session..."
+    loadingMessage: "Refreshing session...",
+    useRefreshToken: true
   },
   advanced: {
     responseType: "code",
@@ -53,6 +54,7 @@ var KeycloakConfigBuilder = class {
     const config = this.mergeWithDefaults(userConfig);
     const storageType = config.advanced.storageType || "session";
     const storage = storageType === "local" ? window.localStorage : window.sessionStorage;
+    const { useRefreshToken } = config.silentRenew;
     const oidcSettings = {
       authority: config.authority,
       client_id: config.clientId,
@@ -70,6 +72,9 @@ var KeycloakConfigBuilder = class {
         response_mode: "query"
       }
     };
+    if (useRefreshToken !== void 0) {
+      oidcSettings.useRefreshToken = useRefreshToken;
+    }
     return oidcSettings;
   }
   /**
@@ -157,6 +162,7 @@ function useTokenLifecycle(options) {
   const [isRefreshing, setIsRefreshing] = useState(false);
   const [isRefreshTokenExpired, setIsRefreshTokenExpired] = useState(false);
   const hasCheckedOnStartup = useRef(false);
+  const supportsRefreshTokens = config.silentRenew?.useRefreshToken !== false;
   const log = useCallback(
     (message, ...args) => {
       if (debug) {
@@ -293,24 +299,49 @@ function useTokenLifecycle(options) {
   useEffect(() => {
     const strategy = config.silentRenew?.refreshStrategy || "both";
     const shouldCheckOnStartup = strategy === "startup" || strategy === "both";
+    const hasRefreshToken = Boolean(auth.user?.refresh_token);
     if (!shouldCheckOnStartup || hasCheckedOnStartup.current) {
       return;
     }
-    if (!auth.isAuthenticated || auth.isLoading) {
+    if (auth.isLoading) {
       return;
     }
+    if (!auth.isAuthenticated) {
+      if (!supportsRefreshTokens) {
+        return;
+      }
+      if (!auth.user || !hasRefreshToken) {
+        return;
+      }
+    }
     hasCheckedOnStartup.current = true;
-    log("Running startup token check with strategy:", strategy);
+    log(
+      "Running startup token check with strategy:",
+      strategy,
+      "using refresh token:",
+      !auth.isAuthenticated && supportsRefreshTokens
+    );
     checkAndRefreshTokens().catch((error) => {
       log("Startup token check failed:", error);
     });
   }, [
     auth.isAuthenticated,
     auth.isLoading,
+    auth.user,
     config.silentRenew?.refreshStrategy,
+    supportsRefreshTokens,
     checkAndRefreshTokens,
     log
   ]);
+  useEffect(() => {
+    if (hasCheckedOnStartup.current) {
+      const hasUser = Boolean(auth.user);
+      const hasRefreshToken = Boolean(auth.user?.refresh_token);
+      if (auth.isLoading || !auth.isAuthenticated && (!supportsRefreshTokens || !hasUser || !hasRefreshToken)) {
+        hasCheckedOnStartup.current = false;
+      }
+    }
+  }, [auth.isAuthenticated, auth.isLoading, auth.user, supportsRefreshTokens]);
   useEffect(() => {
     if (auth.user && !auth.isLoading) {
       storeFirstLoginTime();
@@ -625,6 +656,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();
+  useEffect(() => {
+    const token = auth.user?.access_token ?? null;
+    bridge.setToken(token);
+  }, [auth.user, bridge]);
+  useEffect(() => {
+    if (!auth.isAuthenticated) {
+      bridge.setToken(null);
+    }
+  }, [auth.isAuthenticated, bridge]);
+  return null;
+};
+
 // src/config/presets.ts
 var CONFIG_PRESETS = {
   /**
@@ -843,11 +939,97 @@ var StorageConfigProvider = ({ storageType, children }) => {
   return /* @__PURE__ */ jsx(StorageConfigContext.Provider, { value: { storageType, storage }, children });
 };
 var useStorageConfig = () => useContext(StorageConfigContext);
+var defaultStatus = {
+  isEnabled: true,
+  isConfigured: true
+};
+var KeycloakStatusContext = createContext(defaultStatus);
+var KeycloakStatusProvider = KeycloakStatusContext.Provider;
+var useKeycloakStatus = () => 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 = 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;
+  useEffect(() => {
+    if (!effectiveEnabled && props.tokenBridge) {
+      props.tokenBridge.setToken(null);
+    }
+  }, [effectiveEnabled, props.tokenBridge]);
+  if (!effectiveEnabled) {
+    return /* @__PURE__ */ jsx(KeycloakStatusProvider, { value: status, children: /* @__PURE__ */ jsx(AuthContext.Provider, { value: disabledAuthContext, children: /* @__PURE__ */ jsx(StorageConfigProvider, { storageType: "session", children }) }) });
+  }
   const config = isZeroConfig(props) ? buildZeroConfig(props) : props.config;
   const oidcConfig = KeycloakConfigBuilder.build(config);
   const log = useCallback(
@@ -889,7 +1071,7 @@ var KeycloakProvider = (props) => {
   }, [log]);
   const showSessionMonitor = config.features?.sessionMonitor !== false;
   const storageType = config.advanced?.storageType || "session";
-  return /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsx(KeycloakStatusProvider, { value: status, children: /* @__PURE__ */ jsx(
     AuthProvider,
     {
       ...oidcConfig,
@@ -897,11 +1079,12 @@ var KeycloakProvider = (props) => {
       onSignoutCallback,
       onRemoveUser,
       children: /* @__PURE__ */ jsx(StorageConfigProvider, { storageType, children: /* @__PURE__ */ jsxs(TokenLifecycleManager, { config, debug, children: [
+        props.tokenBridge && /* @__PURE__ */ jsx(TokenBridgeSync, { bridge: props.tokenBridge }),
         showSessionMonitor && /* @__PURE__ */ jsx(SessionMonitor, {}),
         children
       ] }) })
     }
-  );
+  ) });
 };
 function buildZeroConfig(props) {
   const { authority, clientId, preset = "default", config: overrides = {} } = props;
@@ -1605,6 +1788,6 @@ function useProtectedFetch(options = {}) {
   };
 }
 
-export { CONFIG_PRESETS, DeviceLogin, KeycloakConfigBuilder, KeycloakProvider, LoginButton, LogoutButton, ProtectedRoute, SessionMonitor, TokenLifecycleManager, UserProfile, defaultConfig, fetchUserInfo, getConfigFromEnv, getConfigPreset, mergeWithPreset, pollForToken, requestDeviceCode, useAuth, useProtectedFetch, useRoles, useScopes, useTokenLifecycle };
+export { CONFIG_PRESETS, DeviceLogin, KeycloakConfigBuilder, KeycloakProvider, KeycloakStatusProvider, LoginButton, LogoutButton, ProtectedRoute, SessionMonitor, TokenBridge, TokenBridgeSync, TokenLifecycleManager, UserProfile, createTokenBridge, defaultConfig, defaultTokenBridge, fetchUserInfo, getConfigFromEnv, getConfigPreset, mergeWithPreset, pollForToken, requestDeviceCode, useAuth, useKeycloakStatus, useProtectedFetch, useRoles, useScopes, useTokenLifecycle };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map