nuxt-auth-utils 0.5.0 → 0.5.2

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "auth-utils",
   "configKey": "auth",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "2.0.0"

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { readFile, writeFile } from 'node:fs/promises';
-import { defineNuxtModule, createResolver, addComponentsDir, addImportsDir, addPlugin, addServerPlugin, addServerImportsDir, logger, addServerHandler } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addComponentsDir, addImports, addPlugin, addServerPlugin, addServerImportsDir, logger, addServerHandler } from '@nuxt/kit';
 import { join } from 'pathe';
 import { defu } from 'defu';
 import { randomUUID } from 'uncrypto';
@@ -21,8 +21,14 @@ const module = defineNuxtModule({
     nuxt.options.alias["#auth-utils"] = resolver.resolve(
       "./runtime/types/index"
     );
+    const composables = [
+      { name: "useUserSession", from: resolver.resolve("./runtime/app/composables/session") }
+    ];
+    if (options.webAuthn) {
+      composables.push({ name: "useWebAuthn", from: resolver.resolve("./runtime/app/composables/webauthn") });
+    }
     addComponentsDir({ path: resolver.resolve("./runtime/app/components") });
-    addImportsDir(resolver.resolve("./runtime/app/composables"));
+    addImports(composables);
     addPlugin(resolver.resolve("./runtime/app/plugins/session.server"));
     addPlugin(resolver.resolve("./runtime/app/plugins/session.client"));
     addServerPlugin(resolver.resolve("./runtime/server/plugins/oauth"));
@@ -219,6 +225,12 @@ const module = defineNuxtModule({
       clientSecret: "",
       redirectURL: ""
     });
+    runtimeConfig.oauth.zitadel = defu(runtimeConfig.oauth.zitadel, {
+      clientId: "",
+      clientSecret: "",
+      domain: "",
+      redirectURL: ""
+    });
   }
 });
 

package/dist/runtime/server/lib/oauth/zitadel.d.ts

@@ -0,0 +1,37 @@
+import type { OAuthConfig } from '#auth-utils';
+export interface OAuthZitadelConfig {
+    /**
+     * ZITADEL OAuth Client ID
+     * @default process.env.NUXT_OAUTH_ZITADEL_CLIENT_ID
+     */
+    clientId?: string;
+    /**
+     * ZITADEL OAuth Client Secret
+     * @default process.env.NUXT_OAUTH_ZITADEL_CLIENT_SECRET
+     */
+    clientSecret?: string;
+    /**
+     * ZITADEL OAuth Domain
+     * @example <your-zitadel-instance>.zitadel.cloud
+     * @default process.env.NUXT_OAUTH_ZITADEL_DOMAIN
+     */
+    domain?: string;
+    /**
+     * ZITADEL OAuth Scope
+     * @default ['openid']
+     * @see https://zitadel.com/docs/apis/openidoauth/scopes
+     * @example ['openid', 'profile', 'email']
+     */
+    scope?: string[];
+    /**
+     * Extra authorization parameters to provide to the authorization URL
+     * @example { ui_locales: 'de-CH de en' }
+     */
+    authorizationParams?: Record<string, string>;
+    /**
+     * Redirect URL to allow overriding for situations like prod failing to determine public hostname
+     * @default process.env.NUXT_OAUTH_ZITADEL_REDIRECT_URL or current URL
+     */
+    redirectURL?: string;
+}
+export declare function defineOAuthZitadelEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthZitadelConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

package/dist/runtime/server/lib/oauth/zitadel.js

@@ -0,0 +1,77 @@
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
+import { defu } from "defu";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
+import { useRuntimeConfig, createError } from "#imports";
+export function defineOAuthZitadelEventHandler({ config, onSuccess, onError }) {
+  return eventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig(event).oauth?.zitadel, {
+      authorizationParams: {}
+    });
+    const query = getQuery(event);
+    if (query.error) {
+      const error = createError({
+        statusCode: 401,
+        message: `Zitadel login failed: ${query.error || "Unknown error"}`,
+        data: query
+      });
+      if (!onError) throw error;
+      return onError(event, error);
+    }
+    if (!config.clientId || !config.clientSecret || !config.domain) {
+      return handleMissingConfiguration(event, "zitadel", ["clientId", "clientSecret", "issuerUrl"], onError);
+    }
+    const authorizationURL = `https://${config.domain}/oauth/v2/authorize`;
+    const tokenURL = `https://${config.domain}/oauth/v2/token`;
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
+      config.scope = config.scope || ["openid"];
+      return sendRedirect(
+        event,
+        withQuery(authorizationURL, {
+          response_type: "code",
+          client_id: config.clientId,
+          redirect_uri: redirectURL,
+          scope: config.scope.join(" "),
+          ...config.authorizationParams
+        })
+      );
+    }
+    const tokens = await requestAccessToken(tokenURL, {
+      headers: {
+        "Authorization": `Basic ${Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64")}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: {
+        grant_type: "authorization_code",
+        client_id: config.clientId,
+        redirect_uri: redirectURL,
+        code: query.code
+      }
+    });
+    if (tokens.error) {
+      return handleAccessTokenErrorResponse(event, "zitadel", tokens, onError);
+    }
+    const accessToken = tokens.access_token;
+    const user = await $fetch(`https://${config.domain}/oidc/v1/userinfo`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json"
+      }
+    });
+    console.log("Zitadel user:", user);
+    if (!user) {
+      const error = createError({
+        statusCode: 500,
+        message: "Could not get Zitadel user",
+        data: tokens
+      });
+      if (!onError) throw error;
+      return onError(event, error);
+    }
+    return onSuccess(event, {
+      user,
+      tokens
+    });
+  });
+}

package/dist/runtime/server/lib/webauthn/authenticate.js

@@ -16,17 +16,17 @@ export function defineWebAuthnAuthenticateEventHandler({
   return eventHandler(async (event) => {
     const url = getRequestURL(event);
     const body = await readBody(event);
-    const _config = defu(await getOptions?.(event) ?? {}, useRuntimeConfig(event).webauthn.authenticate, {
+    const _config = defu(await getOptions?.(event, body) ?? {}, useRuntimeConfig(event).webauthn.authenticate, {
       rpID: url.hostname
     });
-    if (allowCredentials && body.userName) {
-      _config.allowCredentials = await allowCredentials(event, body.userName);
-    }
     if (!storeChallenge) {
       _config.challenge = "";
     }
     try {
       if (!body.verify) {
+        if (allowCredentials && body.userName) {
+          _config.allowCredentials = await allowCredentials(event, body.userName);
+        }
         const options = await generateAuthenticationOptions(_config);
         const attemptId = bufferToBase64URLString(getRandomValues(new Uint8Array(32)));
         if (storeChallenge) {
@@ -49,6 +49,8 @@ export function defineWebAuthnAuthenticateEventHandler({
         expectedChallenge,
         expectedOrigin: url.origin,
         expectedRPID: url.hostname,
+        requireUserVerification: false,
+        // TODO: make configurable https://simplewebauthn.dev/docs/advanced/passkeys#verifyauthenticationresponse
         credential: {
           id: credential.id,
           publicKey: new Uint8Array(base64URLStringToBuffer(credential.publicKey)),

package/dist/runtime/server/lib/webauthn/register.d.ts

@@ -1,6 +1,6 @@
 import type { ValidateFunction } from 'h3';
 import type { WebAuthnUser, WebAuthnRegisterEventHandlerOptions } from '#auth-utils';
-export declare function defineWebAuthnRegisterEventHandler<T extends WebAuthnUser>({ storeChallenge, getChallenge, getOptions, validateUser, onSuccess, onError, }: WebAuthnRegisterEventHandlerOptions<T>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void | import("@simplewebauthn/server").VerifiedRegistrationResponse | {
+export declare function defineWebAuthnRegisterEventHandler<T extends WebAuthnUser>({ storeChallenge, getChallenge, getOptions, validateUser, excludeCredentials, onSuccess, onError, }: WebAuthnRegisterEventHandlerOptions<T>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void | import("@simplewebauthn/server").VerifiedRegistrationResponse | {
     creationOptions: import("@simplewebauthn/types").PublicKeyCredentialCreationOptionsJSON;
     attemptId: string;
 }>>;

package/dist/runtime/server/lib/webauthn/register.js

@@ -9,6 +9,7 @@ export function defineWebAuthnRegisterEventHandler({
   getChallenge,
   getOptions,
   validateUser,
+  excludeCredentials,
   onSuccess,
   onError
 }) {
@@ -24,7 +25,7 @@ export function defineWebAuthnRegisterEventHandler({
     if (validateUser) {
       user = await validateUserData(body.user, validateUser);
     }
-    const _config = defu(await getOptions?.(event) ?? {}, useRuntimeConfig(event).webauthn.register, {
+    const _config = defu(await getOptions?.(event, body) ?? {}, useRuntimeConfig(event).webauthn.register, {
       rpID: url.hostname,
       rpName: url.hostname,
       userName: user.userName,
@@ -38,6 +39,9 @@ export function defineWebAuthnRegisterEventHandler({
     }
     try {
       if (!body.verify) {
+        if (excludeCredentials) {
+          _config.excludeCredentials = await excludeCredentials(event, user.userName);
+        }
         const options = await generateRegistrationOptions(_config);
         const attemptId = bufferToBase64URLString(getRandomValues(new Uint8Array(32)));
         if (storeChallenge) {

package/dist/runtime/server/plugins/oauth.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("nitropack").NitroAppPlugin;
+declare const _default: import("nitropack/types").NitroAppPlugin;
 export default _default;

package/dist/runtime/types/oauth-config.d.ts

@@ -1,5 +1,5 @@
 import type { H3Event, H3Error } from 'h3';
-export type OAuthProvider = 'auth0' | 'battledotnet' | 'cognito' | 'discord' | 'dropbox' | 'facebook' | 'github' | 'gitlab' | 'google' | 'instagram' | 'keycloak' | 'linear' | 'linkedin' | 'microsoft' | 'paypal' | 'polar' | 'spotify' | 'steam' | 'tiktok' | 'twitch' | 'vk' | 'x' | 'xsuaa' | 'yandex' | (string & {});
+export type OAuthProvider = 'auth0' | 'battledotnet' | 'cognito' | 'discord' | 'dropbox' | 'facebook' | 'github' | 'gitlab' | 'google' | 'instagram' | 'keycloak' | 'linear' | 'linkedin' | 'microsoft' | 'paypal' | 'polar' | 'spotify' | 'steam' | 'tiktok' | 'twitch' | 'vk' | 'x' | 'xsuaa' | 'yandex' | 'zitadel' | (string & {});
 export type OnError = (event: H3Event, error: H3Error) => Promise<void> | void;
 export interface OAuthConfig<TConfig, TUser = any, TTokens = any> {
     config?: TConfig;

package/dist/runtime/types/webauthn.d.ts

@@ -1,4 +1,4 @@
-import type { AuthenticatorTransportFuture } from '@simplewebauthn/types';
+import type { AuthenticationResponseJSON, AuthenticatorTransportFuture, RegistrationResponseJSON } from '@simplewebauthn/types';
 import type { Ref } from 'vue';
 import type { H3Event, H3Error, ValidateFunction } from 'h3';
 import type { GenerateAuthenticationOptionsOpts, GenerateRegistrationOptionsOpts, VerifiedAuthenticationResponse, VerifiedRegistrationResponse } from '@simplewebauthn/server';
@@ -15,7 +15,7 @@ export interface WebAuthnUser {
     displayName?: string;
     [key: string]: unknown;
 }
-type AllowCredentials = NonNullable<GenerateAuthenticationOptionsOpts['allowCredentials']>;
+type CredentialsList = NonNullable<GenerateAuthenticationOptionsOpts['allowCredentials']>;
 type WebAuthnEventHandlerBase<T extends Record<PropertyKey, unknown>> = {
     storeChallenge: (event: H3Event, challenge: string, attemptId: string) => void | Promise<void>;
     getChallenge: (event: H3Event, attemptId: string) => string | Promise<string>;
@@ -27,21 +27,40 @@ type WebAuthnEventHandlerBase<T extends Record<PropertyKey, unknown>> = {
     onSuccess: (event: H3Event, data: T) => void | Promise<void>;
     onError?: (event: H3Event, error: H3Error) => void | Promise<void>;
 };
+export type RegistrationBody<T extends WebAuthnUser> = {
+    user: T;
+    verify: false;
+} | {
+    user: T;
+    verify: true;
+    attemptId: string;
+    response: RegistrationResponseJSON;
+};
 export type WebAuthnRegisterEventHandlerOptions<T extends WebAuthnUser> = WebAuthnEventHandlerBase<{
     user: T;
     credential: WebAuthnCredential;
     registrationInfo: Exclude<VerifiedRegistrationResponse['registrationInfo'], undefined>;
 }> & {
-    getOptions?: (event: H3Event) => GenerateRegistrationOptionsOpts | Promise<GenerateRegistrationOptionsOpts>;
+    getOptions?: (event: H3Event, body: RegistrationBody<T>) => Partial<GenerateRegistrationOptionsOpts> | Promise<Partial<GenerateRegistrationOptionsOpts>>;
     validateUser?: ValidateFunction<T>;
+    excludeCredentials?: (event: H3Event, userName: string) => CredentialsList | Promise<CredentialsList>;
+};
+export type AuthenticationBody = {
+    verify: false;
+    userName?: string;
+} | {
+    verify: true;
+    attemptId: string;
+    userName?: string;
+    response: AuthenticationResponseJSON;
 };
 export type WebAuthnAuthenticateEventHandlerOptions<T extends WebAuthnCredential> = WebAuthnEventHandlerBase<{
     credential: T;
     authenticationInfo: Exclude<VerifiedAuthenticationResponse['authenticationInfo'], undefined>;
 }> & {
-    getOptions?: (event: H3Event) => Partial<GenerateAuthenticationOptionsOpts> | Promise<Partial<GenerateAuthenticationOptionsOpts>>;
+    getOptions?: (event: H3Event, body: AuthenticationBody) => Partial<GenerateAuthenticationOptionsOpts> | Promise<Partial<GenerateAuthenticationOptionsOpts>>;
     getCredential: (event: H3Event, credentialID: string) => T | Promise<T>;
-    allowCredentials?: (event: H3Event, userName: string) => AllowCredentials | Promise<AllowCredentials>;
+    allowCredentials?: (event: H3Event, userName: string) => CredentialsList | Promise<CredentialsList>;
 };
 export interface WebAuthnComposable {
     /**

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "nuxt-auth-utils",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Add Authentication to Nuxt applications with secured & sealed cookies sessions.",
-  "repository": "atinux/nuxt-auth-utils",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/atinux/nuxt-auth-utils.git"
+  },
   "license": "MIT",
   "type": "module",
-  "packageManager": "pnpm@9.12.2",
+  "packageManager": "pnpm@9.12.3",
   "exports": {
     ".": {
       "types": "./dist/types.d.ts",
@@ -33,7 +36,7 @@
   },
   "dependencies": {
     "@adonisjs/hash": "^9.0.5",
-    "@nuxt/kit": "^3.13.2",
+    "@nuxt/kit": "^3.14.0",
     "defu": "^6.1.4",
     "hookable": "^5.5.3",
     "ofetch": "^1.4.1",
@@ -55,20 +58,20 @@
     }
   },
   "devDependencies": {
-    "@iconify-json/simple-icons": "^1.2.9",
+    "@iconify-json/simple-icons": "^1.2.11",
     "@nuxt/devtools": "latest",
-    "@nuxt/eslint-config": "^0.6.0",
+    "@nuxt/eslint-config": "^0.6.1",
     "@nuxt/module-builder": "^0.8.4",
-    "@nuxt/schema": "^3.13.2",
+    "@nuxt/schema": "^3.14.0",
     "@nuxt/test-utils": "^3.14.4",
     "@nuxt/ui": "^2.18.7",
     "@nuxt/ui-pro": "^1.4.4",
     "@simplewebauthn/types": "^11.0.0",
     "changelogen": "^0.5.7",
-    "eslint": "^9.13.0",
-    "nuxt": "^3.13.2",
+    "eslint": "^9.14.0",
+    "nuxt": "^3.14.0",
     "typescript": "^5.6.3",
-    "vitest": "^2.1.3",
-    "vue-tsc": "^2.1.6"
+    "vitest": "^2.1.4",
+    "vue-tsc": "^2.1.10"
   }
 }