nuxt-auth-utils 0.5.33 → 0.6.0

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

@@ -0,0 +1,110 @@
+import type { OAuthConfig } from '#auth-utils';
+export interface OAuthZendeskConfig {
+    /**
+     * Zendesk OAuth Client ID
+     * @default process.env.NUXT_OAUTH_ZENDESK_CLIENT_ID
+     */
+    clientId?: string;
+    /**
+     * Zendesk OAuth Client Secret
+     * @default process.env.NUXT_OAUTH_ZENDESK_CLIENT_SECRET
+     */
+    clientSecret?: string;
+    /**
+     * Zendesk subdomain, for example `mycompany` for `mycompany.zendesk.com`
+     * @default process.env.NUXT_OAUTH_ZENDESK_SUBDOMAIN
+     */
+    subdomain?: string;
+    /**
+     * Zendesk OAuth Scope
+     * @default ['read']
+     * @see https://support.zendesk.com/hc/en-us/articles/4408845965210-Using-OAuth-authentication-with-your-application
+     * @example ['read', 'write']
+     */
+    scope?: string[];
+    /**
+     * Redirect URL to allow overriding for situations like prod failing to determine public hostname
+     * @default process.env.NUXT_OAUTH_ZENDESK_REDIRECT_URL
+     */
+    redirectURL?: string;
+    /**
+     * Zendesk Marketplace name header value.
+     * Only required for apps published in the Zendesk Marketplace.
+     * @default process.env.NUXT_OAUTH_ZENDESK_MARKETPLACE_NAME
+     */
+    marketplaceName?: string;
+    /**
+     * Zendesk Marketplace organization ID header value.
+     * Only required for apps published in the Zendesk Marketplace.
+     * @default process.env.NUXT_OAUTH_ZENDESK_MARKETPLACE_ORG_ID
+     */
+    marketplaceOrgId?: string;
+    /**
+     * Zendesk Marketplace bot ID header value.
+     * Only required for marketplace bot integrations.
+     * @default process.env.NUXT_OAUTH_ZENDESK_MARKETPLACE_BOT_ID
+     */
+    marketplaceBotId?: string;
+    /**
+     * Zendesk Marketplace app ID header value.
+     * Only required for apps published in the Zendesk Marketplace.
+     * @default process.env.NUXT_OAUTH_ZENDESK_MARKETPLACE_APP_ID
+     */
+    marketplaceAppId?: string;
+}
+export interface ZendeskUser {
+    id: number;
+    url: string;
+    name: string;
+    email: string;
+    created_at: string;
+    updated_at: string;
+    time_zone: string | null;
+    iana_time_zone: string | null;
+    phone: string | null;
+    shared_phone_number: boolean | null;
+    photo: {
+        url: string | null;
+        content_url: string | null;
+    } | null;
+    locale_id: number;
+    locale: string;
+    organization_id: number | null;
+    role: string;
+    verified: boolean;
+    external_id: string | null;
+    tags: string[];
+    alias: string | null;
+    active: boolean;
+    shared: boolean;
+    shared_agent: boolean;
+    last_login_at: string | null;
+    two_factor_auth_enabled: boolean;
+    signature: string | null;
+    details: string | null;
+    notes: string | null;
+    role_type: number | null;
+    custom_role_id: number | null;
+    is_billing_admin: boolean;
+    moderator: boolean;
+    ticket_restriction: string | null;
+    only_private_comments: boolean;
+    restricted_agent: boolean;
+    suspended: boolean;
+    default_group_id: number | null;
+    report_csv: boolean;
+    user_fields: Record<string, unknown>;
+    suspension_details: unknown | null;
+}
+export interface ZendeskTokens {
+    access_token: string;
+    refresh_token?: string;
+    token_type: string;
+    scope: string;
+    expires_in?: number;
+    refresh_token_expires_in?: number;
+}
+export declare function defineOAuthZendeskEventHandler({ config, onSuccess, onError, }: OAuthConfig<OAuthZendeskConfig, {
+    user: ZendeskUser;
+    tokens: ZendeskTokens;
+}>): import("nuxt/server").EventHandler<Promise<any>>;

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

@@ -0,0 +1,109 @@
+import { defineEventHandler, getQuery, sendRedirect, useRuntimeConfig } from "nuxt/server";
+import { $fetch } from "ofetch";
+import { withQuery } from "ufo";
+import { defu } from "defu";
+import {
+  handleMissingConfiguration,
+  handleAccessTokenErrorResponse,
+  getOAuthRedirectURL,
+  handleInvalidState,
+  handleState,
+  requestAccessToken
+} from "../utils.js";
+function getMarketplaceHeaders(config) {
+  const headers = {};
+  if (config.marketplaceName) {
+    headers["X-Zendesk-Marketplace-Name"] = config.marketplaceName;
+  }
+  if (config.marketplaceOrgId) {
+    headers["X-Zendesk-Marketplace-Organization-Id"] = config.marketplaceOrgId;
+  }
+  if (config.marketplaceBotId) {
+    headers["X-Zendesk-Marketplace-Bot-Id"] = config.marketplaceBotId;
+  }
+  if (config.marketplaceAppId) {
+    headers["X-Zendesk-Marketplace-App-Id"] = config.marketplaceAppId;
+  }
+  return headers;
+}
+export function defineOAuthZendeskEventHandler({
+  config,
+  onSuccess,
+  onError
+}) {
+  return defineEventHandler(async (event) => {
+    const runtimeConfig = useRuntimeConfig().oauth?.zendesk;
+    config = defu(config, runtimeConfig);
+    config.scope = config.scope?.length ? config.scope : ["read"];
+    if (!config.scope.includes("read") && !config.scope.includes("users:read")) {
+      config.scope.push("users:read");
+    }
+    if (!config.clientId || !config.clientSecret || !config.subdomain) {
+      return handleMissingConfiguration(
+        event,
+        "zendesk",
+        ["clientId", "clientSecret", "subdomain"],
+        onError
+      );
+    }
+    const baseURL = `https://${config.subdomain}.zendesk.com`;
+    const query = getQuery(event);
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (query.error) {
+      return handleAccessTokenErrorResponse(
+        event,
+        "zendesk",
+        {
+          error: query.error,
+          error_description: query.error_description
+        },
+        onError
+      );
+    }
+    const state = await handleState(event);
+    if (!query.code) {
+      return sendRedirect(
+        event,
+        withQuery(`${baseURL}/oauth/authorizations/new`, {
+          response_type: "code",
+          client_id: config.clientId,
+          redirect_uri: redirectURL,
+          scope: config.scope.join(" "),
+          state
+        })
+      );
+    }
+    if (!state || query.state !== state) {
+      return handleInvalidState(event, "zendesk", onError);
+    }
+    const marketplaceHeaders = getMarketplaceHeaders(config);
+    const tokens = await requestAccessToken(`${baseURL}/oauth/tokens`, {
+      headers: {
+        // Zendesk documents JSON bodies for the token endpoint
+        "Content-Type": "application/json",
+        ...marketplaceHeaders
+      },
+      body: {
+        grant_type: "authorization_code",
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        redirect_uri: redirectURL,
+        code: query.code,
+        scope: config.scope.join(" ")
+      }
+    });
+    if (tokens.error) {
+      return handleAccessTokenErrorResponse(event, "zendesk", tokens, onError);
+    }
+    const data = await $fetch(`${baseURL}/api/v2/users/me.json`, {
+      headers: {
+        Authorization: `Bearer ${tokens.access_token}`,
+        ...marketplaceHeaders
+      }
+    });
+    return onSuccess(event, {
+      user: data.user,
+      tokens
+    });
+  });
+}

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

@@ -34,4 +34,4 @@ export interface OAuthZitadelConfig {
      */
     redirectURL?: string;
 }
-export declare function defineOAuthZitadelEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthZitadelConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export declare function defineOAuthZitadelEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthZitadelConfig>): import("nuxt/server").EventHandler<Promise<any>>;

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

@@ -1,17 +1,17 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { defineEventHandler, createError, getQuery, sendRedirect, useRuntimeConfig } from "nuxt/server";
+import { $fetch } from "ofetch";
 import { hasProtocol, withQuery } from "ufo";
 import { defu } from "defu";
 import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken, handleState, handlePkceVerifier, handleInvalidState } 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, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.zitadel, {
       authorizationParams: {}
     });
     const query = getQuery(event);
     if (query.error) {
       const error = createError({
-        statusCode: 401,
+        status: 401,
         message: `Zitadel login failed: ${query.error || "Unknown error"}`,
         data: query
       });
@@ -75,7 +75,7 @@ export function defineOAuthZitadelEventHandler({ config, onSuccess, onError }) {
     });
     if (!user) {
       const error = createError({
-        statusCode: 500,
+        status: 500,
         message: "Could not get Zitadel user",
         data: tokens
       });

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

@@ -1,8 +1,8 @@
-import { type H3Event } from 'h3';
+import type { RequestEvent } from 'nuxt/server';
 import * as jose from 'jose';
 import type { OAuthProvider, OnError } from '#auth-utils';
 export declare const isDevelopment: boolean;
-export declare function getOAuthRedirectURL(event: H3Event): string;
+export declare function getOAuthRedirectURL(event: RequestEvent): string;
 /**
  * Request an access token body.
  *
@@ -34,9 +34,9 @@ export declare function requestAccessToken<T = any>(url: string, options: Reques
  *
  * @see https://datatracker.ietf.org/doc/html/rfc6749#section-5.2
  */
-export declare function handleAccessTokenErrorResponse(event: H3Event, oauthProvider: OAuthProvider, oauthError: any, onError?: OnError): any;
-export declare function handleMissingConfiguration(event: H3Event, provider: OAuthProvider, missingKeys: string[], onError?: OnError): any;
-export declare function handleInvalidState(event: H3Event, provider: OAuthProvider, onError?: OnError): any;
+export declare function handleAccessTokenErrorResponse(event: RequestEvent, oauthProvider: OAuthProvider, oauthError: any, onError?: OnError): any;
+export declare function handleMissingConfiguration(event: RequestEvent, provider: OAuthProvider, missingKeys: string[], onError?: OnError): any;
+export declare function handleInvalidState(event: RequestEvent, provider: OAuthProvider, onError?: OnError): any;
 /**
  * JWT signing using jose
  *
@@ -62,7 +62,7 @@ interface JWTVerifyOptions {
     issuer: string;
 }
 export declare function verifyJwt<T>(token: string, options: JWTVerifyOptions): Promise<T>;
-export declare function handlePkceVerifier(event: H3Event): Promise<{
+export declare function handlePkceVerifier(event: RequestEvent): Promise<{
     code_verifier: string;
     code_challenge: string;
     code_challenge_method: string;
@@ -75,7 +75,7 @@ interface HandleStateOptions {
     isCallback?: boolean;
     sameSite?: 'lax' | 'none' | 'strict';
 }
-export declare function handleState(event: H3Event, options?: HandleStateOptions): Promise<string | undefined>;
+export declare function handleState(event: RequestEvent, options?: HandleStateOptions): Promise<string | undefined>;
 export declare function parseJwt(token: string): jose.JWTPayload;
-export declare function handleNonce(event: H3Event): string | undefined;
+export declare function handleNonce(event: RequestEvent): string | undefined;
 export {};

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

@@ -1,10 +1,8 @@
-import { deleteCookie, getCookie, getQuery, setCookie } from "h3";
-import { getRequestURL } from "h3";
-import { FetchError } from "ofetch";
+import { createError, deleteCookie, getCookie, getQuery, getRequestURL, setCookie } from "nuxt/server";
+import { $fetch, FetchError } from "ofetch";
 import { snakeCase, upperFirst } from "scule";
 import * as jose from "jose";
 import { subtle, getRandomValues } from "uncrypto";
-import { createError } from "#imports";
 export const isDevelopment = process.env.NODE_ENV === "development";
 const OAUTH_COOKIE_MAX_AGE = 60 * 10;
 export function getOAuthRedirectURL(event) {
@@ -33,7 +31,7 @@ export async function requestAccessToken(url, options) {
 export function handleAccessTokenErrorResponse(event, oauthProvider, oauthError, onError) {
   const message = `${upperFirst(oauthProvider)} login failed: ${oauthError.error_description || oauthError.error?.message || oauthError.error || "Unknown error"}`;
   const error = createError({
-    statusCode: 401,
+    status: 401,
     message,
     data: oauthError
   });
@@ -43,7 +41,7 @@ export function handleAccessTokenErrorResponse(event, oauthProvider, oauthError,
 export function handleMissingConfiguration(event, provider, missingKeys, onError) {
   const environmentVariables = missingKeys.map((key) => `NUXT_OAUTH_${provider.toUpperCase()}_${snakeCase(key).toUpperCase()}`);
   const error = createError({
-    statusCode: 500,
+    status: 500,
     message: `Missing ${environmentVariables.join(" or ")} env ${missingKeys.length > 1 ? "variables" : "variable"}.`
   });
   if (!onError) throw error;
@@ -52,7 +50,7 @@ export function handleMissingConfiguration(event, provider, missingKeys, onError
 export function handleInvalidState(event, provider, onError) {
   const message = `${upperFirst(provider)} login failed: state mismatch`;
   const error = createError({
-    statusCode: 500,
+    status: 500,
     message
   });
   if (!onError) throw error;

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

@@ -1,3 +1,3 @@
-import type { EventHandler } from 'h3';
+import type { EventHandler } from 'nuxt/server';
 import type { WebAuthnAuthenticateEventHandlerOptions, WebAuthnCredential } from '#auth-utils';
 export declare function defineWebAuthnAuthenticateEventHandler<T extends WebAuthnCredential>({ storeChallenge, getChallenge, getCredential, allowCredentials, getOptions, onSuccess, onError, }: WebAuthnAuthenticateEventHandlerOptions<T>): EventHandler;

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

@@ -1,9 +1,8 @@
-import { eventHandler, H3Error, createError, getRequestURL, readBody } from "h3";
+import { defineEventHandler, createError, getRequestURL, isNuxtError, readBody, useRuntimeConfig } from "nuxt/server";
 import { generateAuthenticationOptions, verifyAuthenticationResponse } from "@simplewebauthn/server";
 import defu from "defu";
 import { getRandomValues } from "uncrypto";
 import { base64URLStringToBuffer, bufferToBase64URLString } from "@simplewebauthn/browser";
-import { useRuntimeConfig } from "#imports";
 export function defineWebAuthnAuthenticateEventHandler({
   storeChallenge,
   getChallenge,
@@ -13,10 +12,10 @@ export function defineWebAuthnAuthenticateEventHandler({
   onSuccess,
   onError
 }) {
-  return eventHandler(async (event) => {
+  return defineEventHandler(async (event) => {
     const url = getRequestURL(event);
     const body = await readBody(event);
-    const _config = defu(await getOptions?.(event, body) ?? {}, useRuntimeConfig(event).webauthn.authenticate, {
+    const _config = defu(await getOptions?.(event, body) ?? {}, useRuntimeConfig().webauthn.authenticate, {
       rpID: url.hostname
     });
     if (!storeChallenge) {
@@ -38,7 +37,7 @@ export function defineWebAuthnAuthenticateEventHandler({
         };
       }
       if (!body.attemptId)
-        throw createError({ statusCode: 400 });
+        throw createError({ status: 400 });
       let expectedChallenge = "";
       if (getChallenge) {
         expectedChallenge = await getChallenge(event, body.attemptId);
@@ -59,7 +58,7 @@ export function defineWebAuthnAuthenticateEventHandler({
         }
       });
       if (!verification.verified)
-        throw createError({ statusCode: 400, message: "Failed to verify registration response" });
+        throw createError({ status: 400, message: "Failed to verify registration response" });
       await onSuccess(event, {
         credential,
         authenticationInfo: verification.authenticationInfo
@@ -67,9 +66,9 @@ export function defineWebAuthnAuthenticateEventHandler({
       return verification;
     } catch (error) {
       if (!onError) throw error;
-      if (error instanceof H3Error)
+      if (isNuxtError(error))
         return onError(event, error);
-      return onError(event, createError({ statusCode: 500, message: "Failed to authenticate credential" }));
+      return onError(event, createError({ status: 500, message: "Failed to authenticate credential" }));
     }
   });
 }

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

@@ -1,5 +1,5 @@
-import type { H3Event, EventHandler } from 'h3';
+import type { EventHandler, RequestEvent } from 'nuxt/server';
 import type { ValidateUserFunction } from '../../../types/webauthn.js';
 import type { WebAuthnUser, WebAuthnRegisterEventHandlerOptions } from '#auth-utils';
 export declare function defineWebAuthnRegisterEventHandler<T extends WebAuthnUser>({ storeChallenge, getChallenge, getOptions, validateUser, excludeCredentials, onSuccess, onError, }: WebAuthnRegisterEventHandlerOptions<T>): EventHandler;
-export declare function validateUserData<T>(userBody: WebAuthnUser, event: H3Event, fn: ValidateUserFunction<T>): Promise<T>;
+export declare function validateUserData<T>(userBody: WebAuthnUser, event: RequestEvent, fn: ValidateUserFunction<T>): Promise<T>;

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

@@ -1,9 +1,8 @@
-import { eventHandler, H3Error, createError, getRequestURL, readBody } from "h3";
+import { defineEventHandler, createError, getRequestURL, isNuxtError, readBody, useRuntimeConfig } from "nuxt/server";
 import { generateRegistrationOptions, verifyRegistrationResponse } from "@simplewebauthn/server";
 import defu from "defu";
 import { bufferToBase64URLString } from "@simplewebauthn/browser";
 import { getRandomValues } from "uncrypto";
-import { useRuntimeConfig } from "#imports";
 export function defineWebAuthnRegisterEventHandler({
   storeChallenge,
   getChallenge,
@@ -13,19 +12,19 @@ export function defineWebAuthnRegisterEventHandler({
   onSuccess,
   onError
 }) {
-  return eventHandler(async (event) => {
+  return defineEventHandler(async (event) => {
     const url = getRequestURL(event);
     const body = await readBody(event);
     if (body.verify === void 0 || !body.user?.userName)
       throw createError({
         message: "Invalid request, missing userName or verify property",
-        statusCode: 400
+        status: 400
       });
     let user = body.user;
     if (validateUser) {
       user = await validateUserData(body.user, event, validateUser);
     }
-    const _config = defu(await getOptions?.(event, body) ?? {}, useRuntimeConfig(event).webauthn.register, {
+    const _config = defu(await getOptions?.(event, body) ?? {}, useRuntimeConfig().webauthn.register, {
       rpID: url.hostname,
       rpName: url.hostname,
       userName: user.userName,
@@ -55,7 +54,7 @@ export function defineWebAuthnRegisterEventHandler({
       if (!body.attemptId) {
         throw createError({
           message: "Invalid request, missing attemptId",
-          statusCode: 400
+          status: 400
         });
       }
       let expectedChallenge = "";
@@ -74,7 +73,7 @@ export function defineWebAuthnRegisterEventHandler({
       if (!verification.verified) {
         throw createError({
           message: "Failed to verify registration response",
-          statusCode: 400
+          status: 400
         });
       }
       await onSuccess(event, {
@@ -92,9 +91,9 @@ export function defineWebAuthnRegisterEventHandler({
       return verification;
     } catch (error) {
       if (!onError) throw error;
-      if (error instanceof H3Error)
+      if (isNuxtError(error))
         return onError(event, error);
-      return onError(event, createError({ statusCode: 500, message: "Failed to register credential" }));
+      return onError(event, createError({ status: 500, message: "Failed to register credential" }));
     }
   });
 }
@@ -114,7 +113,7 @@ export async function validateUserData(userBody, event, fn) {
 }
 function createUserValidationError(validateError) {
   throw createError({
-    status: validateError?.statusCode || 400,
+    status: validateError?.status || validateError?.statusCode || 400,
     message: validateError?.message || "User Validation Error",
     data: validateError
   });

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

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/dist/runtime/server/plugins/oauth-hash.js

@@ -0,0 +1,8 @@
+import { useRuntimeConfig, useServerHooks } from "nuxt/server";
+export default () => {
+  useServerHooks().hook("render:html", (html) => {
+    const oauth = useRuntimeConfig().oauth;
+    if (!oauth?.facebook?.clientId && !oauth?.instagram?.clientId) return;
+    html.head.unshift('<script>if(window.location.hash==="#_=_"){history.replaceState?history.replaceState(null,null,window.location.href.split("#")[0]):window.location.hash=""}<\/script>');
+  });
+};

package/dist/runtime/server/routes/atproto/client-metadata.json.get.d.ts

@@ -1,4 +1,4 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, {
+declare const _default: import("nuxt/server").EventHandler<{
     redirect_uris: [string, ...string[]];
     scope?: string | undefined;
     response_types?: ["code" | "none" | "token" | "code id_token token" | "code id_token" | "code token" | "id_token token" | "id_token", ...("code" | "none" | "token" | "code id_token token" | "code id_token" | "code token" | "id_token token" | "id_token")[]] | undefined;

package/dist/runtime/server/routes/atproto/client-metadata.json.get.js

@@ -1,10 +1,10 @@
-import { defineEventHandler, createError } from "h3";
+import { createError, defineEventHandler, getRequestURL, useRuntimeConfig } from "nuxt/server";
+import { withoutBase } from "ufo";
 import { getAtprotoClientMetadata } from "../../utils/atproto.js";
 import { atprotoProviders, getClientMetadataFilename } from "../../../utils/atproto.js";
-import { useRuntimeConfig } from "#imports";
 export default defineEventHandler((event) => {
-  const path = event.path.slice(1);
-  const runtimeConfig = useRuntimeConfig(event);
+  const runtimeConfig = useRuntimeConfig();
+  const path = withoutBase(getRequestURL(event).pathname, runtimeConfig.app.baseURL).slice(1);
   for (const provider of atprotoProviders) {
     const config = runtimeConfig.oauth[provider];
     if (getClientMetadataFilename(provider, config) === path) {
@@ -12,7 +12,7 @@ export default defineEventHandler((event) => {
     }
   }
   throw createError({
-    statusCode: 404,
+    status: 404,
     message: "Provider not found"
   });
 });

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

@@ -1,5 +1,5 @@
-import type { H3Event } from 'h3';
+import type { RequestEvent } from 'nuxt/server';
 import type { OAuthClientMetadataInput } from '@atproto/oauth-client-node';
 import type { OAuthBlueskyConfig } from '../lib/atproto/bluesky.js';
 import type { ATProtoProvider, OAuthConfig } from '#auth-utils';
-export declare function getAtprotoClientMetadata(event: H3Event, provider: ATProtoProvider, config?: OAuthConfig<OAuthBlueskyConfig>['config']): OAuthClientMetadataInput;
+export declare function getAtprotoClientMetadata(event: RequestEvent, provider: ATProtoProvider, config?: OAuthConfig<OAuthBlueskyConfig>['config']): OAuthClientMetadataInput;

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

@@ -1,9 +1,8 @@
-import { getRequestURL } from "h3";
+import { getRequestURL, useRuntimeConfig } from "nuxt/server";
 import { getOAuthRedirectURL } from "../lib/utils.js";
 import { getClientMetadataFilename } from "../../utils/atproto.js";
-import { useRuntimeConfig } from "#imports";
 export function getAtprotoClientMetadata(event, provider, config) {
-  const providerRuntimeConfig = useRuntimeConfig(event).oauth[provider];
+  const providerRuntimeConfig = useRuntimeConfig().oauth[provider];
   const scopes = [.../* @__PURE__ */ new Set(["atproto", ...config?.scope ?? [], ...providerRuntimeConfig.scope ?? []])];
   const scope = scopes.join(" ");
   const grantTypes = [.../* @__PURE__ */ new Set(["authorization_code", ...providerRuntimeConfig.grantTypes ?? []])];

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

@@ -1,6 +1,6 @@
 import { Hash } from "@adonisjs/hash";
 import { Scrypt } from "@adonisjs/hash/drivers/scrypt";
-import { useRuntimeConfig } from "#imports";
+import { useRuntimeConfig } from "nuxt/server";
 let _hash;
 function getHash() {
   if (!_hash) {

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

@@ -1,55 +1,68 @@
-import type { H3Event, SessionConfig } from 'h3';
-import { useSession } from 'h3';
+import type { RequestEvent, SessionConfig } from 'nuxt/server';
 import type { OmitWithIndexSignature } from '../../types/utils.js';
-import type { SessionEvent, UserSession, UserSessionRequired } from '#auth-utils';
-type UseSessionEvent = Parameters<typeof useSession>[0] | SessionEvent;
+import type { LegacyH3Event, SessionEvent, UserSession, UserSessionRequired } from '#auth-utils';
+/**
+ * Name of the cookie the user session is sealed into.
+ */
+export declare const USER_SESSION_COOKIE_NAME = "nuxt-auth-session";
+type UserSessionData = OmitWithIndexSignature<UserSession, 'id'>;
+/**
+ * Session options, the session is always sealed with a secret derived from `appSecret`.
+ */
+type UserSessionConfig = Omit<SessionConfig, 'password'>;
+/**
+ * An event the session can be written with, WebSocket peers and upgrade requests are read-only.
+ */
+type WritableSessionEvent = RequestEvent | LegacyH3Event;
 export interface SessionHooks {
     /**
      * Called when fetching the session from the API
      * - Add extra properties to the session
      * - Throw an error if the session could not be verified (with a database for example)
      */
-    fetch: (session: UserSession, event: H3Event) => void | Promise<void>;
+    fetch: (session: UserSession, event: RequestEvent) => void | Promise<void>;
     /**
      * Called before clearing the session
      */
-    clear: (session: UserSession, event: H3Event) => void | Promise<void>;
+    clear: (session: UserSession, event: RequestEvent) => void | Promise<void>;
 }
 export declare const sessionHooks: import("hookable").Hookable<SessionHooks, import("hookable").HookKeys<SessionHooks>>;
 /**
  * Get the user session from the current request
- * @param event The Request (h3) event
+ * @param event The request event
  * @returns The user session
  */
-export declare function getUserSession(event: UseSessionEvent): Promise<UserSession>;
+export declare function getUserSession(event: SessionEvent): Promise<UserSession>;
 /**
  * Set a user session
- * @param event The Request (h3) event
+ * @param event The request event
  * @param data User session data, please only store public information since it can be decoded with API calls
  * @see https://github.com/atinux/nuxt-auth-utils
  */
-export declare function setUserSession(event: SessionEvent, data: OmitWithIndexSignature<UserSession, 'id'>, config?: Partial<SessionConfig>): Promise<UserSession>;
+export declare function setUserSession(event: WritableSessionEvent, data: UserSessionData, config?: UserSessionConfig): Promise<UserSession>;
 /**
  * Replace a user session
- * @param event The Request (h3) event
+ * @param event The request event
  * @param data User session data, please only store public information since it can be decoded with API calls
  */
-export declare function replaceUserSession(event: SessionEvent, data: OmitWithIndexSignature<UserSession, 'id'>, config?: Partial<SessionConfig>): Promise<UserSession>;
+export declare function replaceUserSession(event: WritableSessionEvent, data: UserSessionData, config?: UserSessionConfig): Promise<UserSession>;
 /**
  * Clear the user session and removing the session cookie
- * @param event The Request (h3) event
+ * @param event The request event
  * @returns true if the session was cleared
  */
-export declare function clearUserSession(event: SessionEvent, config?: Partial<SessionConfig>): Promise<boolean>;
+export declare function clearUserSession(event: WritableSessionEvent, config?: UserSessionConfig): Promise<boolean>;
 /**
  * Require a user session, throw a 401 error if the user is not logged in
  * @param event
  * @param opts Options to customize the error message and status code
- * @param opts.statusCode The status code to use for the error (defaults to 401)
+ * @param opts.status The status code to use for the error (defaults to 401)
+ * @param opts.statusCode Deprecated, use `status`
  * @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: UseSessionEvent, opts?: {
+export declare function requireUserSession(event: SessionEvent, opts?: {
+    status?: number;
     statusCode?: number;
     message?: string;
 }): Promise<UserSessionRequired>;