@douvery/auth 0.2.1 → 0.3.0

package/dist/qwik/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, {
@@ -734,30 +921,38 @@ function createDouveryAuth(config) {
   return new DouveryAuthClient(config);
 }
 var DouveryAuthContext = createContextId("douvery-auth");
-var DouveryAuthProvider = component$(({ config }) => {
-  const client = createDouveryAuth(config);
-  const state = useSignal(client.getState());
-  const isInitialized = useSignal(false);
-  const isLoading = useSignal(false);
-  const error = useSignal(null);
-  useContextProvider(DouveryAuthContext, { state, isInitialized, isLoading, error, client });
-  useVisibleTask$(() => {
-    client.initialize().then(() => {
-      isInitialized.value = true;
-      state.value = client.getState();
-    }).catch((err) => {
-      error.value = err instanceof Error ? err : new Error(String(err));
+var DouveryAuthProvider = component$(
+  ({ config }) => {
+    const client = createDouveryAuth(config);
+    const state = useSignal(client.getState());
+    const isInitialized = useSignal(false);
+    const isLoading = useSignal(false);
+    const error = useSignal(null);
+    useContextProvider(DouveryAuthContext, {
+      state,
+      isInitialized,
+      isLoading,
+      error,
+      client
     });
-    const unsubscribe = client.subscribe((event) => {
-      state.value = client.getState();
-      if (event.type === "LOGIN_ERROR" || event.type === "LOGOUT_ERROR" || event.type === "TOKEN_REFRESH_ERROR") {
-        error.value = event.error;
-      }
+    useVisibleTask$(() => {
+      client.initialize().then(() => {
+        isInitialized.value = true;
+        state.value = client.getState();
+      }).catch((err) => {
+        error.value = err instanceof Error ? err : new Error(String(err));
+      });
+      const unsubscribe = client.subscribe((event) => {
+        state.value = client.getState();
+        if (event.type === "LOGIN_ERROR" || event.type === "LOGOUT_ERROR" || event.type === "TOKEN_REFRESH_ERROR") {
+          error.value = event.error;
+        }
+      });
+      return () => unsubscribe();
     });
-    return () => unsubscribe();
-  });
-  return /* @__PURE__ */ jsx(Slot, {});
-});
+    return /* @__PURE__ */ jsx(Slot, {});
+  }
+);
 function useDouveryAuth() {
   return useContext(DouveryAuthContext);
 }
@@ -805,9 +1000,86 @@ function useAuthActions() {
       isLoading.value = false;
     }
   };
-  return { login, logout, isLoading };
+  const selectAccount = (options) => {
+    client.selectAccount(options);
+  };
+  const addAccount = (options) => {
+    client.addAccount(options);
+  };
+  const register = (options) => {
+    client.register(options);
+  };
+  const recoverAccount = (options) => {
+    client.recoverAccount(options);
+  };
+  const verifyAccount = (options) => {
+    client.verifyAccount(options);
+  };
+  const upgradeAccount = (options) => {
+    client.upgradeAccount(options);
+  };
+  const setupPasskey = (options) => {
+    client.setupPasskey(options);
+  };
+  const setupAddress = (options) => {
+    client.setupAddress(options);
+  };
+  const revokeToken = async (options) => {
+    isLoading.value = true;
+    error.value = null;
+    try {
+      await client.revokeToken(options);
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      throw err;
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  return {
+    login,
+    logout,
+    selectAccount,
+    addAccount,
+    register,
+    recoverAccount,
+    verifyAccount,
+    upgradeAccount,
+    setupPasskey,
+    setupAddress,
+    revokeToken,
+    isLoading
+  };
+}
+function useAuthUrls() {
+  const { client } = useDouveryAuth();
+  return {
+    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)
+  };
+}
+function useSessionStatus() {
+  const { client, state } = useDouveryAuth();
+  const isExpired = useSignal(client.isSessionExpired());
+  const needsVerification = useSignal(client.needsEmailVerification());
+  const isGuest = useSignal(client.isGuestAccount());
+  useTask$(({ track }) => {
+    track(() => state.value);
+    isExpired.value = client.isSessionExpired();
+    needsVerification.value = client.needsEmailVerification();
+    isGuest.value = client.isGuestAccount();
+  });
+  return { isExpired, needsVerification, isGuest };
 }
 
-export { DouveryAuthClient, DouveryAuthContext, DouveryAuthProvider, createDouveryAuth, useAuthActions, useDouveryAuth, useIsAuthenticated, useUser };
+export { DouveryAuthClient, DouveryAuthContext, DouveryAuthProvider, createDouveryAuth, useAuthActions, useAuthUrls, useDouveryAuth, useIsAuthenticated, useSessionStatus, useUser };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map