nuxt-auth-utils 0.5.7 → 0.5.9

package/README.md

@@ -23,6 +23,7 @@ Add Authentication to Nuxt applications with secured & sealed cookies sessions.
 - [Tree-shakable server utils](#server-utils)
 - [`<AuthState>` component](#authstate-component)
 - [Extendable with hooks](#extend-session)
+- [WebSocket support](#websockets-support)
 
 It has few dependencies (only from [UnJS](https://github.com/unjs)), run on multiple JS environments (Node, Deno, Workers) and is fully typed with TypeScript.
 
@@ -204,6 +205,7 @@ It can also be set using environment variables:
 
 #### Supported OAuth Providers
 
+- Atlassian
 - Auth0
 - Authentik
 - AWS Cognito
@@ -217,6 +219,7 @@ It can also be set using environment variables:
 - Hubspot
 - Instagram
 - Keycloak
+- Line
 - Linear
 - LinkedIn
 - Microsoft
@@ -594,6 +597,65 @@ You can use the `placeholder` slot to show a placeholder on server-side and whil
 
 If you are caching your routes with `routeRules`, please make sure to use [Nitro](https://github.com/unjs/nitro) >= `2.9.7` to support the client-side fetching of the user session.
 
+## WebSockets Support
+
+Nuxt Auth Utils is compatible with [Nitro WebSockets](https://nitro.build/guide/websocket).
+
+Make sure to enable the `experimental.websocket` option in your `nuxt.config.ts`:
+
+```ts
+export default defineNuxtConfig({
+  nitro: {
+    experimental: {
+      websocket: true
+    }
+  }
+})
+```
+
+You can use the `requireUserSession` function in the `upgrade` function to check if the user is authenticated before upgrading the WebSocket connection.
+
+```ts
+// server/routes/ws.ts
+export default defineWebSocketHandler({
+  async upgrade(request) {
+    // Make sure the user is authenticated before upgrading the WebSocket connection
+    await requireUserSession(request)
+  },
+  async open(peer) {
+    const { user } = await requireUserSession(peer)
+    const username = Object.values(user).filter(Boolean).join(' ')
+    peer.send(`Hello, ${username}!`)
+  },
+  message(peer, message) {
+    peer.send(`Echo: ${message}`)
+  },
+})
+```
+
+Then, in your application, you can use the [useWebSocket](https://vueuse.org/core/useWebSocket/) composable to connect to the WebSocket:
+
+```vue
+<script setup>
+const { status, data, send, open, close } = useWebSocket('/ws', { immediate: false })
+
+// Only open the websocket after the page is hydrated (client-only)
+onMounted(open)
+</script>
+
+<template>
+  <div>
+    <p>Status: {{ status }}</p>
+    <p>Data: {{ data }}</p>
+    <p>
+      <button @click="open">Open</button>
+      <button @click="close(1000, 'Closing')">Close</button>
+      <button @click="send('hello')">Send hello</button>
+    </p>
+  </div>
+</template>
+```
+
 ## Configuration
 
 We leverage `runtimeConfig.session` to give the defaults option to [h3 `useSession`](https://h3.unjs.io/examples/handle-session).

package/dist/module.json

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

package/dist/module.mjs

@@ -33,6 +33,9 @@ const module = defineNuxtModule({
     addPlugin(resolver.resolve("./runtime/app/plugins/session.client"));
     addServerPlugin(resolver.resolve("./runtime/server/plugins/oauth"));
     addServerImportsDir(resolver.resolve("./runtime/server/lib/oauth"));
+    if (nuxt.options.nitro?.experimental?.websocket) {
+      addServerPlugin(resolver.resolve("./runtime/server/plugins/ws"));
+    }
     if (options.webAuthn) {
       const missingDeps = [];
       const peerDeps = ["@simplewebauthn/server", "@simplewebauthn/browser"];
@@ -102,7 +105,8 @@ const module = defineNuxtModule({
     runtimeConfig.oauth.gitlab = defu(runtimeConfig.oauth.gitlab, {
       clientId: "",
       clientSecret: "",
-      redirectURL: ""
+      redirectURL: "",
+      baseURL: "https://gitlab.com"
     });
     runtimeConfig.oauth.spotify = defu(runtimeConfig.oauth.spotify, {
       clientId: "",
@@ -260,6 +264,16 @@ const module = defineNuxtModule({
       clientSecret: "",
       redirectURL: ""
     });
+    runtimeConfig.oauth.line = defu(runtimeConfig.oauth.line, {
+      clientId: "",
+      clientSecret: "",
+      redirectURL: ""
+    });
+    runtimeConfig.oauth.atlassian = defu(runtimeConfig.oauth.atlassian, {
+      clientId: "",
+      clientSecret: "",
+      redirectURL: ""
+    });
   }
 });
 

package/dist/runtime/app/plugins/session.client.d.ts

@@ -1,2 +1,2 @@
-declare const _default: any;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/app/plugins/session.server.d.ts

@@ -1,2 +1,2 @@
-declare const _default: any;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

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

@@ -0,0 +1,66 @@
+import type { OAuthConfig } from '#auth-utils';
+/**
+ * @see https://developer.atlassian.com/cloud/jira/platform/oauth-2-3lo-apps
+ */
+export interface OAuthAtlassianConfig {
+    /**
+     * Atlassian OAuth Client ID
+     * @default process.env.NUXT_OAUTH_ATLASSIAN_CLIENT_ID
+     * @see https://developer.atlassian.com/console/myapps
+     */
+    clientId?: string;
+    /**
+     * Atlassian OAuth Client Secret
+     * @default process.env.NUXT_OAUTH_ATLASSIAN_CLIENT_SECRET
+     * @see https://developer.atlassian.com/console/myapps
+     */
+    clientSecret?: string;
+    /**
+     * Redirect URL to allow overriding for situations like prod failing to determine public hostname
+     * @default process.env.NUXT_OAUTH_ATLASSIAN_REDIRECT_URL or current URL
+     * @see https://developer.atlassian.com/console/myapps
+     */
+    redirectURL?: string;
+    /**
+     * Atlassian OAuth Scope
+     * @default ['read:me', 'read:account']
+     * @see [Jira scopes](https://developer.atlassian.com/cloud/jira/platform/scopes-for-oauth-2-3LO-and-forge-apps) | [Confluence scopes](https://developer.atlassian.com/cloud/confluence/scopes-for-oauth-2-3LO-and-forge-apps)
+     *
+     * @example
+     * User identity API: ['read:me', 'read:account']
+     * Confluence API: ['read:confluence-user']
+     * BRIE API: ['read:account:brie]
+     * Jira platform REST API: ['read:jira-user']
+     * Personal data reporting API: ['report:personal-data']
+     */
+    scope?: string[];
+    /**
+     * Atlassian OAuth Audience URL
+     * @default 'https://api.atlassian.com'
+     */
+    audienceURL?: string;
+    /**
+     * Atlassian OAuth Authorization URL
+     * @default 'https://auth.atlassian.com/authorize'
+     */
+    authorizationURL?: string;
+    /**
+     * Atlassian OAuth Token URL
+     * @default 'https://auth.atlassian.com/oauth/token'
+     */
+    tokenURL?: string;
+    /**
+     * Require email from user, adds the ['read:me'] scope if not present
+     * @default false
+     */
+    emailHasToBeVerified?: boolean;
+    /**
+     * Extra authorization parameters to provide to the authorization URL
+     * @default {}
+     */
+    authorizationParams?: Record<string, string>;
+}
+/**
+ * Atlassian User identity, Confluence, BRIE, Jira platform, Atlassian Personal data reporting
+ */
+export declare function defineOAuthAtlassianEventHandler({ config, onSuccess, onError, }: OAuthConfig<OAuthAtlassianConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -0,0 +1,99 @@
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
+import { defu } from "defu";
+import { randomUUID } from "uncrypto";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
+import { useRuntimeConfig, createError } from "#imports";
+export function defineOAuthAtlassianEventHandler({
+  config,
+  onSuccess,
+  onError
+}) {
+  return eventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.atlassian, {
+      authorizationURL: "https://auth.atlassian.com/authorize",
+      tokenURL: "https://auth.atlassian.com/oauth/token",
+      audienceURL: "https://api.atlassian.com",
+      scope: ["read:me", "read:account"],
+      authorizationParams: {}
+    });
+    if (!config.clientId || !config.clientSecret) {
+      return handleMissingConfiguration(event, "atlassian", ["clientId", "clientSecret"], onError);
+    }
+    if (config.scope?.length === 0) {
+      config.scope = ["read:me"];
+    }
+    if (config.emailHasToBeVerified && !config.scope?.includes("read:me")) {
+      config.scope?.push("read:me");
+    }
+    const query = getQuery(event);
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
+      return sendRedirect(
+        event,
+        withQuery(config.authorizationURL, {
+          audience: config.audienceURL,
+          client_id: config.clientId,
+          scope: config.scope?.join(" "),
+          redirect_uri: redirectURL,
+          state: randomUUID(),
+          response_type: "code",
+          prompt: "consent",
+          ...config.authorizationParams
+        })
+      );
+    }
+    if (query.error) {
+      const error = createError({
+        statusCode: 401,
+        message: `Atlassian login failed: ${query.error || "Unknown error"}`,
+        data: query
+      });
+      if (!onError) throw error;
+      return onError(event, error);
+    }
+    const tokens = await requestAccessToken(config.tokenURL, {
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: {
+        grant_type: "authorization_code",
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        code: query.code,
+        redirect_uri: redirectURL
+      }
+    });
+    if (tokens.error || !tokens.access_token) {
+      return handleAccessTokenErrorResponse(event, "atlassian", tokens, onError);
+    }
+    const user = await $fetch("https://api.atlassian.com/me", {
+      headers: {
+        "Authorization": `Bearer ${tokens.access_token}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (user.account_status === "inactive") {
+      const error = createError({
+        statusCode: 403,
+        statusMessage: "Atlassian account is inactive",
+        data: { accountStatus: user.account_status }
+      });
+      if (!onError) throw error;
+      return onError(event, error);
+    }
+    if (!user.email_verified) {
+      const error = createError({
+        statusCode: 400,
+        statusMessage: "Email address is not verified",
+        data: { email: user.email }
+      });
+      if (!onError) throw error;
+      return onError(event, error);
+    }
+    return onSuccess(event, {
+      user,
+      tokens
+    });
+  });
+}

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

@@ -15,6 +15,9 @@ export function defineOAuthDiscordEventHandler({ config, onSuccess, onError }) {
     if (!config.clientId || !config.clientSecret) {
       return handleMissingConfiguration(event, "discord", ["clientId", "clientSecret"], onError);
     }
+    if (query.error) {
+      return handleAccessTokenErrorResponse(event, "discord", query, onError);
+    }
     const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
     if (!query.code) {
       config.scope = config.scope || [];

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

@@ -1,8 +1,8 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { eventHandler, getQuery, sendRedirect, createError } from "h3";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
-import { useRuntimeConfig, createError } from "#imports";
+import { useRuntimeConfig } from "#imports";
 export function defineOAuthFacebookEventHandler({
   config,
   onSuccess,
@@ -58,7 +58,13 @@ export function defineOAuthFacebookEventHandler({
       `https://graph.facebook.com/v19.0/me?fields=${fields}&access_token=${accessToken}`
     );
     if (!user) {
-      throw new Error("Facebook login failed: no user found");
+      const error = createError({
+        statusCode: 500,
+        message: "Could not get Facebook user",
+        data: tokens
+      });
+      if (!onError) throw error;
+      return onError(event, error);
     }
     return onSuccess(event, {
       user,

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

@@ -1,8 +1,8 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { eventHandler, getQuery, sendRedirect, createError } from "h3";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
-import { useRuntimeConfig, createError } from "#imports";
+import { useRuntimeConfig } from "#imports";
 export function defineOAuthGitHubEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
     config = defu(config, useRuntimeConfig(event).oauth?.github, {
@@ -67,7 +67,13 @@ export function defineOAuthGitHubEventHandler({ config, onSuccess, onError }) {
       });
       const primaryEmail = emails.find((email) => email.primary);
       if (!primaryEmail) {
-        throw new Error("GitHub login failed: no user email found");
+        const error = createError({
+          statusCode: 500,
+          message: "Could not get GitHub user email",
+          data: tokens
+        });
+        if (!onError) throw error;
+        return onError(event, error);
       }
       user.email = primaryEmail.email;
     }

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

@@ -43,5 +43,10 @@ export interface OAuthGitLabConfig {
      * @default process.env.NUXT_OAUTH_GITLAB_REDIRECT_URL
      */
     redirectURL?: string;
+    /**
+     * URL of your instance, if you are self-hosting
+     * @default https://gitlab.com
+     */
+    baseURL?: string;
 }
 export declare function defineOAuthGitLabEventHandler({ config, onSuccess, onError, }: OAuthConfig<OAuthGitLabConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -14,9 +14,11 @@ export function defineOAuthGitLabEventHandler({
   onError
 }) {
   return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.gitlab, {
-      authorizationURL: "https://gitlab.com/oauth/authorize",
-      tokenURL: "https://gitlab.com/oauth/token",
+    const runtimeConfig = useRuntimeConfig(event).oauth?.gitlab;
+    const baseURL = config?.baseURL ?? runtimeConfig.baseURL ?? "https://gitlab.com";
+    config = defu(config, runtimeConfig, {
+      authorizationURL: `${baseURL}/oauth/authorize`,
+      tokenURL: `${baseURL}/oauth/token`,
       authorizationParams: {}
     });
     const query = getQuery(event);
@@ -70,7 +72,7 @@ export function defineOAuthGitLabEventHandler({
       return handleAccessTokenErrorResponse(event, "gitlab", tokens, onError);
     }
     const accessToken = tokens.access_token;
-    const user = await $fetch("https://gitlab.com/api/v4/user", {
+    const user = await $fetch(`${baseURL}/api/v4/user`, {
       headers: {
         Authorization: `Bearer ${accessToken}`
       }

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

@@ -1,8 +1,8 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { eventHandler, getQuery, sendRedirect, createError } from "h3";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
-import { useRuntimeConfig, createError } from "#imports";
+import { useRuntimeConfig } from "#imports";
 export function defineOAuthInstagramEventHandler({
   config,
   onSuccess,
@@ -64,7 +64,13 @@ export function defineOAuthInstagramEventHandler({
       `https://graph.instagram.com/v21.0/me?fields=${fields}&access_token=${accessToken}`
     );
     if (!user) {
-      throw new Error("Instagram login failed: no user found");
+      const error = createError({
+        statusCode: 500,
+        message: "Could not get Instagram user",
+        data: tokens
+      });
+      if (!onError) throw error;
+      return onError(event, error);
     }
     return onSuccess(event, {
       user,

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

@@ -0,0 +1,45 @@
+import type { OAuthConfig } from '#auth-utils';
+export interface OAuthLineConfig {
+    /**
+     * Line OAuth Client ID
+     * @default process.env.NUXT_OAUTH_LINE_CLIENT_ID
+     */
+    clientId?: string;
+    /**
+     * Line OAuth Client Secret
+     * @default process.env.NUXT_OAUTH_LINE_CLIENT_SECRET
+     */
+    clientSecret?: string;
+    /**
+     * Line OAuth Scope
+     * @default ['profile', 'openid']
+     * @see https://developers.line.biz/en/docs/line-login/integrate-line-login/
+     */
+    scope?: string[];
+    /**
+     * Line OAuth Authorization URL
+     * @default 'https://access.line.me/oauth2/v2.1/authorize'
+     */
+    authorizationURL?: string;
+    /**
+     * Line OAuth Token URL
+     * @default 'https://api.line.me/oauth2/v2.1/token'
+     */
+    tokenURL?: string;
+    /**
+     * Line OAuth User Info URL
+     * @default 'https://api.line.me/v2/profile'
+     */
+    userURL?: string;
+    /**
+     * Extra authorization parameters to provide to the authorization URL
+     * @example { bot_prompt: 'normal' }
+     */
+    authorizationParams?: Record<string, string>;
+    /**
+     * Redirect URL to to allow overriding for situations like prod failing to determine public hostname
+     * @default process.env.NUXT_OAUTH_LINE_REDIRECT_URL or current URL
+     */
+    redirectURL?: string;
+}
+export declare function defineOAuthLineEventHandler({ config, onSuccess, onError, }: OAuthConfig<OAuthLineConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -0,0 +1,75 @@
+import { eventHandler, getQuery, sendRedirect, createError } from "h3";
+import { withQuery } from "ufo";
+import { defu } from "defu";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
+import { useRuntimeConfig } from "#imports";
+export function defineOAuthLineEventHandler({
+  config,
+  onSuccess,
+  onError
+}) {
+  return eventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig(event).oauth?.line, {
+      authorizationURL: "https://access.line.me/oauth2/v2.1/authorize",
+      tokenURL: "https://api.line.me/oauth2/v2.1/token",
+      userURL: "https://api.line.me/v2/profile",
+      authorizationParams: {}
+    });
+    const query = getQuery(event);
+    if (query.error) {
+      return onError(
+        event,
+        new Error(`Line login failed: ${query.error || "Unknown error"}`)
+      );
+    }
+    if (!config.clientId || !config.clientSecret) {
+      return handleMissingConfiguration(event, "line", ["clientId", "clientSecret"], onError);
+    }
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
+      config.scope = config.scope || ["profile", "openid"];
+      return sendRedirect(
+        event,
+        withQuery(config.authorizationURL, {
+          response_type: "code",
+          client_id: config.clientId,
+          redirect_uri: redirectURL,
+          scope: config.scope.join(" "),
+          state: query.state || "",
+          ...config.authorizationParams
+        })
+      );
+    }
+    const tokens = await requestAccessToken(config.tokenURL, {
+      body: {
+        grant_type: "authorization_code",
+        code: query.code,
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        redirect_uri: redirectURL
+      }
+    });
+    if (tokens.error) {
+      return handleAccessTokenErrorResponse(event, "line", tokens, onError);
+    }
+    const accessToken = tokens.access_token;
+    const user = await $fetch(config.userURL, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+    if (!user) {
+      const error = createError({
+        statusCode: 500,
+        message: "Could not get Line user",
+        data: tokens
+      });
+      if (!onError) throw error;
+      return onError(event, error);
+    }
+    return onSuccess(event, {
+      tokens,
+      user
+    });
+  });
+}

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

@@ -1,5 +0,0 @@
-import type { WebAuthnAuthenticateEventHandlerOptions, WebAuthnCredential } from '#auth-utils';
-export declare function defineWebAuthnAuthenticateEventHandler<T extends WebAuthnCredential>({ storeChallenge, getChallenge, getCredential, allowCredentials, getOptions, onSuccess, onError, }: WebAuthnAuthenticateEventHandlerOptions<T>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void | import("@simplewebauthn/server").VerifiedAuthenticationResponse | {
-    requestOptions: import("@simplewebauthn/types").PublicKeyCredentialRequestOptionsJSON;
-    attemptId: string;
-}>>;

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

@@ -1,8 +0,0 @@
-import type { H3Event } from 'h3';
-import type { WebAuthnUser, WebAuthnRegisterEventHandlerOptions } from '#auth-utils';
-import type { ValidateUserFunction } from '~/src/runtime/types/webauthn';
-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;
-}>>;
-export declare function validateUserData<T>(userBody: WebAuthnUser, event: H3Event, fn: ValidateUserFunction<T>): Promise<T>;

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/server/plugins/ws.d.ts

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

package/dist/runtime/server/plugins/ws.js

@@ -0,0 +1,7 @@
+import { defineNitroPlugin } from "nitropack/runtime";
+import { getUserSession } from "../utils/session.js";
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook("request", async (event) => {
+    await getUserSession(event);
+  });
+});

package/dist/runtime/server/utils/session.d.ts

@@ -1,5 +1,7 @@
 import type { H3Event, SessionConfig } from 'h3';
+import { useSession } from 'h3';
 import type { UserSession, UserSessionRequired } from '#auth-utils';
+type UseSessionEvent = Parameters<typeof useSession>[0];
 export interface SessionHooks {
     /**
      * Called when fetching the session from the API
@@ -18,7 +20,7 @@ export declare const sessionHooks: import("hookable").Hookable<SessionHooks, imp
  * @param event The Request (h3) event
  * @returns The user session
  */
-export declare function getUserSession(event: H3Event): Promise<UserSession>;
+export declare function getUserSession(event: UseSessionEvent): Promise<UserSession>;
 /**
  * Set a user session
  * @param event The Request (h3) event
@@ -46,7 +48,8 @@ export declare function clearUserSession(event: H3Event, config?: Partial<Sessio
  * @param opts.message The message to use for the error (defaults to Unauthorized)
  * @see https://github.com/atinux/nuxt-auth-utils
  */
-export declare function requireUserSession(event: H3Event, opts?: {
+export declare function requireUserSession(event: UseSessionEvent, opts?: {
     statusCode?: number;
     message?: string;
 }): Promise<UserSessionRequired>;
+export {};

package/dist/runtime/server/utils/session.js

@@ -1,4 +1,4 @@
-import { useSession, createError } from "h3";
+import { useSession, createError, isEvent } from "h3";
 import { defu } from "defu";
 import { createHooks } from "hookable";
 import { useRuntimeConfig } from "#imports";
@@ -26,17 +26,23 @@ export async function clearUserSession(event, config) {
 export async function requireUserSession(event, opts = {}) {
   const userSession = await getUserSession(event);
   if (!userSession.user) {
-    throw createError({
-      statusCode: opts.statusCode || 401,
-      message: opts.message || "Unauthorized"
-    });
+    if (isEvent(event)) {
+      throw createError({
+        statusCode: opts.statusCode || 401,
+        message: opts.message || "Unauthorized"
+      });
+    } else {
+      throw new Response(opts.message || "Unauthorized", {
+        status: opts.statusCode || 401
+      });
+    }
   }
   return userSession;
 }
 let sessionConfig;
 function _useSession(event, config = {}) {
   if (!sessionConfig) {
-    const runtimeConfig = useRuntimeConfig(event);
+    const runtimeConfig = useRuntimeConfig(isEvent(event) ? event : void 0);
     const envSessionPassword = `${runtimeConfig.nitro?.envPrefix || "NUXT_"}SESSION_PASSWORD`;
     sessionConfig = defu({ password: process.env[envSessionPassword] }, runtimeConfig.session);
   }

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

@@ -1,5 +1,5 @@
 import type { H3Event, H3Error } from 'h3';
-export type OAuthProvider = 'auth0' | 'authentik' | 'battledotnet' | 'cognito' | 'discord' | 'dropbox' | 'facebook' | 'github' | 'gitlab' | 'google' | 'hubspot' | 'instagram' | 'keycloak' | 'linear' | 'linkedin' | 'microsoft' | 'paypal' | 'polar' | 'spotify' | 'seznam' | 'steam' | 'strava' | 'tiktok' | 'twitch' | 'vk' | 'workos' | 'x' | 'xsuaa' | 'yandex' | 'zitadel' | (string & {});
+export type OAuthProvider = 'atlassian' | 'auth0' | 'authentik' | 'battledotnet' | 'cognito' | 'discord' | 'dropbox' | 'facebook' | 'github' | 'gitlab' | 'google' | 'hubspot' | 'instagram' | 'keycloak' | 'line' | 'linear' | 'linkedin' | 'microsoft' | 'paypal' | 'polar' | 'spotify' | 'seznam' | 'steam' | 'strava' | 'tiktok' | 'twitch' | 'vk' | 'workos' | '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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-auth-utils",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Add Authentication to Nuxt applications with secured & sealed cookies sessions.",
   "repository": {
     "type": "git",
@@ -8,7 +8,7 @@
   },
   "license": "MIT",
   "type": "module",
-  "packageManager": "pnpm@9.15.0",
+  "packageManager": "pnpm@9.15.4",
   "exports": {
     ".": {
       "types": "./dist/types.d.ts",
@@ -36,14 +36,14 @@
   },
   "dependencies": {
     "@adonisjs/hash": "^9.0.5",
-    "@nuxt/kit": "^3.14.1592",
+    "@nuxt/kit": "^3.15.2",
     "defu": "^6.1.4",
-    "h3": "^1.13.0",
+    "h3": "^1.14.0",
     "hookable": "^5.5.3",
     "ofetch": "^1.4.1",
     "ohash": "^1.1.4",
     "openid-client": "^6.1.7",
-    "pathe": "^1.1.2",
+    "pathe": "^2.0.2",
     "scule": "^1.3.0",
     "uncrypto": "^0.1.3"
   },
@@ -60,20 +60,20 @@
     }
   },
   "devDependencies": {
-    "@iconify-json/simple-icons": "^1.2.15",
+    "@iconify-json/simple-icons": "^1.2.21",
     "@nuxt/devtools": "latest",
-    "@nuxt/eslint-config": "^0.7.3",
+    "@nuxt/eslint-config": "^0.7.5",
     "@nuxt/module-builder": "^0.8.4",
-    "@nuxt/schema": "^3.14.1592",
-    "@nuxt/test-utils": "^3.15.1",
-    "@nuxt/ui": "^2.20.0",
-    "@nuxt/ui-pro": "^1.6.0",
-    "@simplewebauthn/types": "^11.0.0",
+    "@nuxt/schema": "^3.15.2",
+    "@nuxt/test-utils": "^3.15.4",
+    "@nuxt/ui": "^2.21.0",
+    "@nuxt/ui-pro": "^1.7.0",
+    "@simplewebauthn/types": "^12.0.0",
     "changelogen": "^0.5.7",
-    "eslint": "^9.16.0",
-    "nuxt": "^3.14.1592",
-    "typescript": "^5.6.3",
-    "vitest": "^2.1.8",
-    "vue-tsc": "^2.1.10"
+    "eslint": "^9.18.0",
+    "nuxt": "^3.15.2",
+    "typescript": "5.6.3",
+    "vitest": "^3.0.3",
+    "vue-tsc": "^2.2.0"
   }
 }