@douvery/auth 0.2.1 → 0.3.0

package/dist/react/index.js

@@ -626,6 +626,171 @@ var DouveryAuthClient = class {
     }
     return tokens.accessToken;
   }
+  // ============================================
+  // Navigation Methods
+  // ============================================
+  /** Redirect to select/switch account */
+  selectAccount(options = {}) {
+    const url = this.buildSelectAccountUrl(options);
+    this.navigate(url, options);
+  }
+  /** Build select-account URL without redirecting */
+  buildSelectAccountUrl(options = {}) {
+    const params = new URLSearchParams();
+    if (options.returnTo) params.set("continue", options.returnTo);
+    if (options.clientId) params.set("client_id", options.clientId);
+    if (options.loginHint) params.set("login_hint", options.loginHint);
+    return this.createAuthUrl("/select-account", params);
+  }
+  /** Redirect to add another account (multi-session) */
+  addAccount(options = {}) {
+    const url = this.buildAddAccountUrl(options);
+    this.navigate(url, options);
+  }
+  /** Build add-account URL without redirecting */
+  buildAddAccountUrl(options = {}) {
+    const params = new URLSearchParams({ add_account: "true" });
+    if (options.returnTo) params.set("continue", options.returnTo);
+    if (options.clientId) params.set("client_id", options.clientId);
+    if (options.loginHint) params.set("login_hint", options.loginHint);
+    return this.createAuthUrl("/login", params);
+  }
+  /** Redirect to register a new account */
+  register(options = {}) {
+    const url = this.buildRegisterUrl(options);
+    this.navigate(url, options);
+  }
+  /** Build register URL without redirecting */
+  buildRegisterUrl(options = {}) {
+    const params = new URLSearchParams();
+    if (options.returnTo) params.set("continue", options.returnTo);
+    if (options.clientId) params.set("client_id", options.clientId);
+    if (options.email) params.set("email", options.email);
+    if (options.firstName) params.set("first_name", options.firstName);
+    if (options.lastName) params.set("last_name", options.lastName);
+    if (options.uiLocales) params.set("ui_locales", options.uiLocales);
+    return this.createAuthUrl("/register", params);
+  }
+  /** Redirect to recover account (forgot password) */
+  recoverAccount(options = {}) {
+    const url = this.buildRecoverAccountUrl(options);
+    this.navigate(url, options);
+  }
+  /** Build recover-account URL without redirecting */
+  buildRecoverAccountUrl(options = {}) {
+    const params = new URLSearchParams();
+    if (options.returnTo) params.set("continue", options.returnTo);
+    if (options.clientId) params.set("client_id", options.clientId);
+    if (options.email) params.set("email", options.email);
+    return this.createAuthUrl("/recover-account", params);
+  }
+  /** Redirect to verify account (email verification) */
+  verifyAccount(options = {}) {
+    const url = this.buildVerifyAccountUrl(options);
+    this.navigate(url, options);
+  }
+  /** Build verify-account URL without redirecting */
+  buildVerifyAccountUrl(options = {}) {
+    const params = new URLSearchParams();
+    if (options.returnTo) params.set("continue", options.returnTo);
+    if (options.clientId) params.set("client_id", options.clientId);
+    if (options.email) params.set("email", options.email);
+    return this.createAuthUrl("/verify-account", params);
+  }
+  /** Redirect to upgrade account (guest → full account) */
+  upgradeAccount(options = {}) {
+    const url = this.buildUpgradeAccountUrl(options);
+    this.navigate(url, options);
+  }
+  /** Build upgrade-account URL without redirecting */
+  buildUpgradeAccountUrl(options = {}) {
+    const params = new URLSearchParams();
+    if (options.returnTo) params.set("continue", options.returnTo);
+    if (options.clientId) params.set("client_id", options.clientId);
+    if (options.scopes?.length) params.set("scope", options.scopes.join(" "));
+    return this.createAuthUrl("/upgrade-account", params);
+  }
+  /** Redirect to passkey setup */
+  setupPasskey(options = {}) {
+    const url = this.buildSetupPasskeyUrl(options);
+    this.navigate(url, options);
+  }
+  /** Build setup-passkey URL without redirecting */
+  buildSetupPasskeyUrl(options = {}) {
+    const params = new URLSearchParams();
+    if (options.returnTo) params.set("continue", options.returnTo);
+    if (options.clientId) params.set("client_id", options.clientId);
+    return this.createAuthUrl("/setup-passkey", params);
+  }
+  /** Redirect to address setup */
+  setupAddress(options = {}) {
+    const url = this.buildSetupAddressUrl(options);
+    this.navigate(url, options);
+  }
+  /** Build setup-address URL without redirecting */
+  buildSetupAddressUrl(options = {}) {
+    const params = new URLSearchParams();
+    if (options.returnTo) params.set("continue", options.returnTo);
+    if (options.clientId) params.set("client_id", options.clientId);
+    return this.createAuthUrl("/setup-address", params);
+  }
+  /** Build a login URL without redirecting (useful for links/buttons) */
+  buildLoginUrl(options = {}) {
+    const params = new URLSearchParams();
+    if (options.returnTo) params.set("continue", options.returnTo);
+    if (options.loginHint) params.set("email", options.loginHint);
+    if (options.prompt) params.set("prompt", options.prompt);
+    if (options.uiLocales) params.set("ui_locales", options.uiLocales);
+    return this.createAuthUrl("/login", params);
+  }
+  /** Build a logout URL without redirecting */
+  buildLogoutUrl(options = {}) {
+    const params = new URLSearchParams();
+    if (options.returnTo) params.set("continue", options.returnTo);
+    return this.createAuthUrl("/logout", params);
+  }
+  /** Revoke a token (access or refresh) */
+  async revokeToken(options = {}) {
+    this.log("Revoking token...");
+    const token = options.token ?? (await this.tokenManager.getTokens())?.accessToken;
+    if (!token) {
+      throw new AuthError("invalid_token", "No token to revoke");
+    }
+    const revokeUrl = `${this.config.issuer}/oauth/revoke`;
+    const body = new URLSearchParams({
+      token,
+      client_id: this.config.clientId
+    });
+    if (options.tokenTypeHint) {
+      body.set("token_type_hint", options.tokenTypeHint);
+    }
+    const response = await fetch(revokeUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new AuthError(
+        error.error ?? "server_error",
+        error.error_description ?? "Token revocation failed"
+      );
+    }
+    this.log("Token revoked successfully");
+  }
+  /** Check if the user's session is expired */
+  isSessionExpired() {
+    if (!this.state.tokens) return true;
+    return isTokenExpired(this.state.tokens.accessToken);
+  }
+  /** Check if user needs email verification */
+  needsEmailVerification() {
+    return this.state.user?.emailVerified === false;
+  }
+  /** Check if user is a guest account */
+  isGuestAccount() {
+    return this.state.user?.accountType === "guest";
+  }
   tokenSetToInfo(tokenSet) {
     return {
       accessToken: tokenSet.access_token,
@@ -636,6 +801,28 @@ var DouveryAuthClient = class {
       scope: tokenSet.scope?.split(" ") ?? []
     };
   }
+  /** Build an AuthUrl object for a given path and params */
+  createAuthUrl(path, params) {
+    const query = params.toString();
+    const url = `${this.config.issuer}${path}${query ? `?${query}` : ""}`;
+    return {
+      url,
+      redirect: () => {
+        window.location.href = url;
+      },
+      open: () => {
+        return window.open(url, "_blank");
+      }
+    };
+  }
+  /** Navigate to an auth URL, respecting openInNewTab option */
+  navigate(authUrl, options) {
+    if (options.openInNewTab) {
+      authUrl.open();
+    } else {
+      authUrl.redirect();
+    }
+  }
   async fetchUser(accessToken) {
     const discovery = await this.getDiscovery();
     const response = await fetch(discovery.userinfo_endpoint, {
@@ -783,34 +970,40 @@ function DouveryAuthProvider({
     });
     return unsubscribe;
   }, [client, onAuthenticated, onLogout, onError]);
-  const login = useCallback(async (options) => {
-    setIsLoading(true);
-    setError(null);
-    try {
-      await client.login(options);
-    } catch (err) {
-      const e = err instanceof Error ? err : new Error(String(err));
-      setError(e);
-      onError?.(e);
-      throw e;
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client, onError]);
-  const logout = useCallback(async (options) => {
-    setIsLoading(true);
-    setError(null);
-    try {
-      await client.logout(options);
-    } catch (err) {
-      const e = err instanceof Error ? err : new Error(String(err));
-      setError(e);
-      onError?.(e);
-      throw e;
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client, onError]);
+  const login = useCallback(
+    async (options) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await client.login(options);
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        throw e;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onError]
+  );
+  const logout = useCallback(
+    async (options) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await client.logout(options);
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        throw e;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onError]
+  );
   const getAccessToken = useCallback(() => client.getAccessToken(), [client]);
   const refreshTokens = useCallback(async () => {
     setIsLoading(true);
@@ -825,20 +1018,100 @@ function DouveryAuthProvider({
       setIsLoading(false);
     }
   }, [client, onError]);
-  const value = useMemo(() => ({
-    state,
-    isInitialized,
-    isLoading,
-    user: state.user,
-    isAuthenticated: state.status === "authenticated",
-    accessToken: state.tokens?.accessToken ?? null,
-    error,
-    login,
-    logout,
-    getAccessToken,
-    refreshTokens,
-    client
-  }), [state, isInitialized, isLoading, error, login, logout, getAccessToken, refreshTokens, client]);
+  const selectAccount = useCallback(
+    (options) => client.selectAccount(options),
+    [client]
+  );
+  const addAccount = useCallback(
+    (options) => client.addAccount(options),
+    [client]
+  );
+  const register = useCallback(
+    (options) => client.register(options),
+    [client]
+  );
+  const recoverAccount = useCallback(
+    (options) => client.recoverAccount(options),
+    [client]
+  );
+  const verifyAccount = useCallback(
+    (options) => client.verifyAccount(options),
+    [client]
+  );
+  const upgradeAccount = useCallback(
+    (options) => client.upgradeAccount(options),
+    [client]
+  );
+  const setupPasskey = useCallback(
+    (options) => client.setupPasskey(options),
+    [client]
+  );
+  const setupAddress = useCallback(
+    (options) => client.setupAddress(options),
+    [client]
+  );
+  const revokeToken = useCallback(
+    async (options) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await client.revokeToken(options);
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        throw e;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onError]
+  );
+  const value = useMemo(
+    () => ({
+      state,
+      isInitialized,
+      isLoading,
+      user: state.user,
+      isAuthenticated: state.status === "authenticated",
+      accessToken: state.tokens?.accessToken ?? null,
+      error,
+      login,
+      logout,
+      selectAccount,
+      addAccount,
+      register,
+      recoverAccount,
+      verifyAccount,
+      upgradeAccount,
+      setupPasskey,
+      setupAddress,
+      revokeToken,
+      getAccessToken,
+      refreshTokens,
+      client
+    }),
+    [
+      state,
+      isInitialized,
+      isLoading,
+      error,
+      login,
+      logout,
+      selectAccount,
+      addAccount,
+      register,
+      recoverAccount,
+      verifyAccount,
+      upgradeAccount,
+      setupPasskey,
+      setupAddress,
+      revokeToken,
+      getAccessToken,
+      refreshTokens,
+      client
+    ]
+  );
   return /* @__PURE__ */ jsx(DouveryAuthContext.Provider, { value, children });
 }
 function useDouveryAuth() {
@@ -859,10 +1132,65 @@ function useAccessToken() {
   return { accessToken, getAccessToken };
 }
 function useAuthActions() {
-  const { login, logout, isLoading } = useDouveryAuth();
-  return { login, logout, isLoading };
+  const {
+    login,
+    logout,
+    selectAccount,
+    addAccount,
+    register,
+    recoverAccount,
+    verifyAccount,
+    upgradeAccount,
+    setupPasskey,
+    setupAddress,
+    revokeToken,
+    isLoading
+  } = useDouveryAuth();
+  return {
+    login,
+    logout,
+    selectAccount,
+    addAccount,
+    register,
+    recoverAccount,
+    verifyAccount,
+    upgradeAccount,
+    setupPasskey,
+    setupAddress,
+    revokeToken,
+    isLoading
+  };
+}
+function useAuthUrls() {
+  const { client } = useDouveryAuth();
+  return useMemo(
+    () => ({
+      loginUrl: (options) => client.buildLoginUrl(options),
+      logoutUrl: (options) => client.buildLogoutUrl(options),
+      selectAccountUrl: (options) => client.buildSelectAccountUrl(options),
+      addAccountUrl: (options) => client.buildAddAccountUrl(options),
+      registerUrl: (options) => client.buildRegisterUrl(options),
+      recoverAccountUrl: (options) => client.buildRecoverAccountUrl(options),
+      verifyAccountUrl: (options) => client.buildVerifyAccountUrl(options),
+      upgradeAccountUrl: (options) => client.buildUpgradeAccountUrl(options),
+      setupPasskeyUrl: (options) => client.buildSetupPasskeyUrl(options),
+      setupAddressUrl: (options) => client.buildSetupAddressUrl(options)
+    }),
+    [client]
+  );
+}
+function useSessionStatus() {
+  const { client, state } = useDouveryAuth();
+  return useMemo(
+    () => ({
+      isExpired: client.isSessionExpired(),
+      needsVerification: client.needsEmailVerification(),
+      isGuest: client.isGuestAccount()
+    }),
+    [client, state]
+  );
 }
 
-export { DouveryAuthClient, DouveryAuthProvider, createDouveryAuth, useAccessToken, useAuthActions, useDouveryAuth, useIsAuthenticated, useUser };
+export { DouveryAuthClient, DouveryAuthProvider, createDouveryAuth, useAccessToken, useAuthActions, useAuthUrls, useDouveryAuth, useIsAuthenticated, useSessionStatus, useUser };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map