nuxt-auth-utils 0.5.34 → 0.6.1

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

@@ -1,11 +1,11 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { defineEventHandler, createError, getQuery, sendRedirect, useRuntimeConfig } from "nuxt/server";
+import { $fetch } from "ofetch";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import { handleAccessTokenErrorResponse, handleInvalidState, handleMissingConfiguration, getOAuthRedirectURL, requestAccessToken, handlePkceVerifier, handleState } from "../utils.js";
-import { useRuntimeConfig, createError } from "#imports";
 export function defineOAuthKickEventHandler({ config, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.kick, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.kick, {
       authorizationURL: "https://id.kick.com/oauth/authorize",
       tokenURL: "https://id.kick.com/oauth/token"
     });
@@ -58,7 +58,7 @@ export function defineOAuthKickEventHandler({ config, onSuccess, onError }) {
     });
     if (!data || !data.length) {
       const error = createError({
-        statusCode: 500,
+        status: 500,
         message: "Could not get Kick user",
         data: tokens
       });

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

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

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

@@ -1,15 +1,15 @@
-import { eventHandler, getQuery, sendRedirect, createError } from "h3";
+import { defineEventHandler, createError, 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";
-import { useRuntimeConfig } from "#imports";
 export function defineOAuthLineEventHandler({
   config,
   onSuccess,
   onError
 }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.line, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().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",
@@ -18,7 +18,7 @@ export function defineOAuthLineEventHandler({
     const query = getQuery(event);
     if (query.error) {
       const error = createError({
-        statusCode: 401,
+        status: 401,
         message: `Line login failed: ${query.error || "Unknown error"}`,
         data: query
       });
@@ -67,7 +67,7 @@ export function defineOAuthLineEventHandler({
     });
     if (!user) {
       const error = createError({
-        statusCode: 500,
+        status: 500,
         message: "Could not get Line user",
         data: tokens
       });

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

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

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

@@ -1,11 +1,11 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { defineEventHandler, createError, 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";
-import { useRuntimeConfig, createError } from "#imports";
 export function defineOAuthLinearEventHandler({ config, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.linear, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.linear, {
       authorizationURL: "https://linear.app/oauth/authorize",
       tokenURL: "https://api.linear.app/oauth/token",
       authorizationParams: {}
@@ -13,7 +13,7 @@ export function defineOAuthLinearEventHandler({ config, onSuccess, onError }) {
     const query = getQuery(event);
     if (query.error) {
       const error = createError({
-        statusCode: 401,
+        status: 401,
         message: `Linear login failed: ${query.error || "Unknown error"}`,
         data: query
       });
@@ -70,7 +70,7 @@ export function defineOAuthLinearEventHandler({ config, onSuccess, onError }) {
     });
     if (!user.data || !user.data.viewer) {
       const error = createError({
-        statusCode: 500,
+        status: 500,
         message: "Could not get Linear user",
         data: tokens
       });

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

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

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

@@ -1,11 +1,11 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+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";
-import { useRuntimeConfig } from "#imports";
 export function defineOAuthLinkedInEventHandler({ config, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.linkedin, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.linkedin, {
       authorizationURL: "https://www.linkedin.com/oauth/v2/authorization",
       tokenURL: "https://www.linkedin.com/oauth/v2/accessToken",
       authorizationParams: {}

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

@@ -70,4 +70,4 @@ export interface LiveChatConfig {
      */
     authorizationParams?: Record<string, string>;
 }
-export declare function defineOAuthLiveChatEventHandler({ config, onSuccess, onError, }: OAuthConfig<LiveChatConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export declare function defineOAuthLiveChatEventHandler({ config, onSuccess, onError, }: OAuthConfig<LiveChatConfig>): import("nuxt/server").EventHandler<Promise<any>>;

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

@@ -1,4 +1,5 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { defineEventHandler, getQuery, sendRedirect, useRuntimeConfig } from "nuxt/server";
+import { $fetch } from "ofetch";
 import { defu } from "defu";
 import { withQuery } from "ufo";
 import {
@@ -9,14 +10,13 @@ import {
   handleState,
   requestAccessToken
 } from "../utils.js";
-import { useRuntimeConfig } from "#imports";
 export function defineOAuthLiveChatEventHandler({
   config,
   onSuccess,
   onError
 }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.livechat, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.livechat, {
       authorizationURL: "https://accounts.livechat.com",
       tokenURL: "https://accounts.livechat.com/v2/token",
       userURL: "https://accounts.livechat.com/v2/accounts/me",

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

@@ -58,5 +58,5 @@ interface MastodonTokens {
 export declare function defineOAuthMastodonEventHandler<TUser = OAuthMastodonUser>({ config: userConfig, onSuccess, onError }: OAuthConfig<OAuthMastodonConfig, {
     user: TUser;
     tokens: MastodonTokens;
-}>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+}>): import("nuxt/server").EventHandler<Promise<any>>;
 export {};

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

@@ -1,9 +1,8 @@
-import { createError, deleteCookie, eventHandler, getCookie, getQuery, sendRedirect, setCookie } from "h3";
+import { createError, defineEventHandler, deleteCookie, getCookie, getQuery, sendRedirect, setCookie, useRuntimeConfig } from "nuxt/server";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import { $fetch } from "ofetch";
-import { getOAuthRedirectURL, handleAccessTokenErrorResponse, handleInvalidState, handleState, isDevelopment, requestAccessToken } from "../utils.js";
-import { useRuntimeConfig } from "#imports";
+import { getOAuthRedirectURL, handleAccessTokenErrorResponse, handleInvalidState, handleState, isOAuthCookieSecure, requestAccessToken } from "../utils.js";
 const FLOW_COOKIE_NAME = "nuxt-auth-mastodon-flow";
 const appRegistry = /* @__PURE__ */ new Map();
 const pendingRegistrations = /* @__PURE__ */ new Map();
@@ -64,15 +63,15 @@ async function getOrRegisterApp(instance, redirectURL, scope, clientName) {
   return registration;
 }
 export function defineOAuthMastodonEventHandler({ config: userConfig, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    const config = defu({}, userConfig, useRuntimeConfig(event).oauth?.mastodon, {
+  return defineEventHandler(async (event) => {
+    const config = defu({}, userConfig, useRuntimeConfig().oauth?.mastodon, {
       clientName: "Nuxt Auth Utils"
     });
     config.scope ||= ["read"];
     const query = getQuery(event);
     if (query.error) {
       const error = createError({
-        statusCode: 401,
+        status: 401,
         message: `Mastodon login failed: ${query.error || "Unknown error"}`,
         data: query
       });
@@ -86,7 +85,7 @@ export function defineOAuthMastodonEventHandler({ config: userConfig, onSuccess,
       const rawInstance = query.instance?.toString() || config.instance;
       if (!rawInstance) {
         const error = createError({
-          statusCode: 400,
+          status: 400,
           message: "Mastodon login failed: missing instance. Provide it via the `instance` query parameter (e.g. `/auth/mastodon?instance=mastodon.social`), a full handle (`@user@mastodon.social`), or the `instance` config/`NUXT_OAUTH_MASTODON_INSTANCE` env variable."
         });
         if (!onError) throw error;
@@ -95,7 +94,7 @@ export function defineOAuthMastodonEventHandler({ config: userConfig, onSuccess,
       const instance2 = resolveInstanceDomain(rawInstance);
       if (!isPubliclyAddressableInstance(instance2)) {
         const error = createError({
-          statusCode: 400,
+          status: 400,
           message: `Mastodon login failed: "${instance2}" is not a valid instance domain.`
         });
         if (!onError) throw error;
@@ -106,7 +105,7 @@ export function defineOAuthMastodonEventHandler({ config: userConfig, onSuccess,
         app = await getOrRegisterApp(instance2, redirectURL, scope, config.clientName || "Nuxt Auth Utils");
       } catch {
         const error = createError({
-          statusCode: 500,
+          status: 500,
           message: `Mastodon login failed: could not register the application with instance "${instance2}". Make sure it is a reachable Mastodon (or compatible) server.`
         });
         if (!onError) throw error;
@@ -115,7 +114,7 @@ export function defineOAuthMastodonEventHandler({ config: userConfig, onSuccess,
       const flowState2 = { instance: instance2, clientId: app.client_id, clientSecret: app.client_secret };
       setCookie(event, FLOW_COOKIE_NAME, btoa(JSON.stringify(flowState2)), {
         httpOnly: true,
-        secure: !isDevelopment,
+        secure: isOAuthCookieSecure(),
         sameSite: "lax",
         maxAge: 60 * 10,
         path: "/"
@@ -141,7 +140,7 @@ export function defineOAuthMastodonEventHandler({ config: userConfig, onSuccess,
     }
     if (!flowState || !isPubliclyAddressableInstance(flowState.instance)) {
       const error = createError({
-        statusCode: 400,
+        status: 400,
         message: "Mastodon login failed: could not recover the application credentials for this login (missing or invalid flow cookie, the flow may have taken too long or cookies are blocked)."
       });
       if (!onError) throw error;

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

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

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

@@ -1,11 +1,11 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { defineEventHandler, createError, 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";
-import { useRuntimeConfig, createError } from "#imports";
 export function defineOAuthMicrosoftEventHandler({ config, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.microsoft, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.microsoft, {
       authorizationParams: {}
     });
     const query = getQuery(event);
@@ -58,7 +58,7 @@ export function defineOAuthMicrosoftEventHandler({ config, onSuccess, onError })
     });
     if (user.error) {
       const error = createError({
-        statusCode: 401,
+        status: 401,
         message: `Microsoft login failed: ${user.error || "Unknown error"}`,
         data: user
       });

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

@@ -211,5 +211,5 @@ interface OIDCConfiguration {
 export declare function defineOAuthOidcEventHandler<TUser = OidcUser>({ config, onSuccess, onError }: OAuthConfig<OAuthOidcConfig, {
     user: TUser;
     tokens: OidcTokens;
-}>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+}>): import("nuxt/server").EventHandler<Promise<any>>;
 export {};

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

@@ -1,15 +1,15 @@
-import { useRuntimeConfig } from "#imports";
+import { defineEventHandler, createError, getQuery, sendRedirect, useRuntimeConfig } from "nuxt/server";
+import { $fetch } from "ofetch";
 import { defu } from "defu";
-import { createError, eventHandler, getQuery, sendRedirect } from "h3";
 import { withQuery } from "ufo";
 import { getOAuthRedirectURL, handleAccessTokenErrorResponse, handleInvalidState, handleMissingConfiguration, handlePkceVerifier, handleState, requestAccessToken, handleNonce, parseJwt } from "../utils.js";
 export function defineOAuthOidcEventHandler({ config, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth.oidc);
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth.oidc);
     const query = getQuery(event);
     if (query.error) {
       const error = createError({
-        statusCode: 401,
+        status: 401,
         message: `OIDC login failed: ${query.error || "Unknown error"}`,
         data: query
       });
@@ -67,7 +67,7 @@ export function defineOAuthOidcEventHandler({ config, onSuccess, onError }) {
       const claims = parseJwt(tokens.id_token);
       if (claims.nonce !== nonce) {
         const error = createError({
-          statusCode: 401,
+          status: 401,
           message: "OIDC login failed: nonce mismatch"
         });
         if (!onError) throw error;

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

@@ -1,4 +1,4 @@
-import type { H3Event } from 'h3';
+import type { RequestEvent } from 'nuxt/server';
 import type { OAuthConfig } from '#auth-utils';
 export interface OpenIdConfig {
     authorization_endpoint: string;
@@ -13,8 +13,8 @@ export interface OAuthConfigExt<TConfig, TResult = {
     openIdConfig: OpenIdConfig;
 }> extends OAuthConfig<TConfig, TResult> {
     config?: TConfig;
-    onSuccess: (event: H3Event, result: TResult) => Promise<void> | void;
-    onError?: (event: H3Event, error: unknown) => Promise<void> | void;
+    onSuccess: (event: RequestEvent, result: TResult) => unknown;
+    onError?: (event: RequestEvent, error: unknown) => unknown;
 }
 export interface OAuthOktaConfig {
     /**
@@ -85,4 +85,4 @@ export interface OAuthOktaConfig {
      */
     openIdConfigCacheTTL?: number;
 }
-export declare function defineOAuthOktaEventHandler({ config, onSuccess, onError }: OAuthConfigExt<OAuthOktaConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export declare function defineOAuthOktaEventHandler({ config, onSuccess, onError }: OAuthConfigExt<OAuthOktaConfig>): import("nuxt/server").EventHandler<Promise<any>>;

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

@@ -1,8 +1,8 @@
-import { eventHandler, getQuery, sendRedirect, createError } from "h3";
+import { defineEventHandler, createError, getQuery, sendRedirect, useRuntimeConfig } from "nuxt/server";
+import { $fetch } from "ofetch";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import { handleMissingConfiguration, handleState, handleInvalidState, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
-import { useRuntimeConfig } from "#imports";
 const openIdConfigCache = /* @__PURE__ */ new Map();
 const DEFAULT_CACHE_TTL = 1e3 * 60 * 60 * 24;
 export function defineOAuthOktaEventHandler({ config, onSuccess, onError }) {
@@ -23,8 +23,8 @@ export function defineOAuthOktaEventHandler({ config, onSuccess, onError }) {
     }
     return result;
   }
-  return eventHandler(async (event) => {
-    const runtimeConfig = useRuntimeConfig(event);
+  return defineEventHandler(async (event) => {
+    const runtimeConfig = useRuntimeConfig();
     config = defu(config, runtimeConfig.oauth?.okta, {
       authorizationParams: {}
     });
@@ -34,7 +34,7 @@ export function defineOAuthOktaEventHandler({ config, onSuccess, onError }) {
     const query = getQuery(event);
     if (query.error) {
       const error = createError({
-        statusCode: 401,
+        status: 401,
         message: `Okta login failed: ${query.error || "Unknown error"} - ${query.error_description || ""}`,
         data: query
       });
@@ -79,7 +79,7 @@ export function defineOAuthOktaEventHandler({ config, onSuccess, onError }) {
         } else {
           console.error("Failed to fetch Okta OpenID configuration. Please check your Okta domain and network connectivity:", error);
           const err = createError({
-            statusCode: 500,
+            status: 500,
             message: "Could not get Okta OpenID configuration. Please verify that your Okta domain is correct and reachable, and that the OpenID configuration endpoint is accessible.",
             data: error
           });
@@ -136,7 +136,7 @@ export function defineOAuthOktaEventHandler({ config, onSuccess, onError }) {
     }
     if (!tokens.access_token || typeof tokens.access_token !== "string" || !tokens.token_type || typeof tokens.token_type !== "string") {
       const err = createError({
-        statusCode: 400,
+        status: 400,
         message: "Invalid token response from Okta",
         data: tokens
       });
@@ -154,7 +154,7 @@ export function defineOAuthOktaEventHandler({ config, onSuccess, onError }) {
       });
     } catch (error) {
       const err = createError({
-        statusCode: 410,
+        status: 410,
         message: `Could not get Okta user info - ${error instanceof Error ? error.message : String(error)}`,
         data: tokens
       });

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

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

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

@@ -1,4 +1,5 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { defineEventHandler, createError, getQuery, sendRedirect, useRuntimeConfig } from "nuxt/server";
+import { $fetch } from "ofetch";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import {
@@ -10,10 +11,9 @@ import {
   handleState,
   requestAccessToken
 } from "../utils.js";
-import { createError, useRuntimeConfig } from "#imports";
 export function defineOAuthOryEventHandler({ config, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.ory, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.ory, {
       scope: ["openid", "offline"],
       sdkURL: "https://playground.projects.oryapis.com",
       authorizationURL: "/oauth2/auth",
@@ -24,7 +24,7 @@ export function defineOAuthOryEventHandler({ config, onSuccess, onError }) {
     const query = getQuery(event);
     if (query.error) {
       const error = createError({
-        statusCode: 401,
+        status: 401,
         message: `Ory login failed: ${query.error || "Unknown error"}`,
         data: query
       });
@@ -86,7 +86,7 @@ export function defineOAuthOryEventHandler({ config, onSuccess, onError }) {
     });
     if (user.error) {
       const error = createError({
-        statusCode: 401,
+        status: 401,
         message: `Ory userinfo failed: ${user.error || "Unknown error"}`,
         data: user
       });

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

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

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

@@ -1,11 +1,11 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { defineEventHandler, getQuery, sendRedirect, useRuntimeConfig } from "nuxt/server";
+import { $fetch } from "ofetch";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken, handleState, handleInvalidState } from "../utils.js";
-import { useRuntimeConfig } from "#imports";
 export function defineOAuthOsuEventHandler({ config, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.osu, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.osu, {
       authorizationURL: "https://osu.ppy.sh/oauth/authorize",
       tokenURL: "https://osu.ppy.sh/oauth/token",
       authorizationParams: {}

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

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

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

@@ -1,11 +1,11 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { defineEventHandler, createError, 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";
-import { useRuntimeConfig, createError } from "#imports";
 export function defineOAuthPaypalEventHandler({ config, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.paypal, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.paypal, {
       sandbox: import.meta.dev,
       authorizationURL: "https://www.paypal.com/signin/authorize",
       tokenURL: "https://api-m.paypal.com/v1/oauth2/token",
@@ -74,7 +74,7 @@ export function defineOAuthPaypalEventHandler({ config, onSuccess, onError }) {
     const user = users;
     if (!user) {
       const error = createError({
-        statusCode: 500,
+        status: 500,
         message: "Could not get PayPal user",
         data: tokens
       });

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

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

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

@@ -1,11 +1,11 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+import { defineEventHandler, createError, getQuery, sendRedirect, useRuntimeConfig } from "nuxt/server";
+import { $fetch } from "ofetch";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import { handleAccessTokenErrorResponse, handleInvalidState, handleMissingConfiguration, getOAuthRedirectURL, handleState, requestAccessToken } from "../utils.js";
-import { useRuntimeConfig, createError } from "#imports";
 export function defineOAuthPolarEventHandler({ config, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.polar, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.polar, {
       authorizationURL: "https://polar.sh/oauth2/authorize",
       tokenURL: "https://api.polar.sh/v1/oauth2/token"
     });
@@ -57,7 +57,7 @@ export function defineOAuthPolarEventHandler({ config, onSuccess, onError }) {
     });
     if (!user) {
       const error = createError({
-        statusCode: 500,
+        status: 500,
         message: "Could not get Polar user",
         data: tokens
       });

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

@@ -70,5 +70,5 @@ interface RiotGamesTokens {
 export declare function defineOAuthRiotGamesEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthRiotGamesConfig, {
     user: RiotGamesUser;
     tokens: RiotGamesTokens;
-}>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+}>): import("nuxt/server").EventHandler<Promise<any>>;
 export {};

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

@@ -1,11 +1,11 @@
-import { createError, eventHandler, getQuery, sendRedirect } from "h3";
+import { defineEventHandler, createError, getQuery, sendRedirect, useRuntimeConfig } from "nuxt/server";
+import { $fetch } from "ofetch";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import { getOAuthRedirectURL, handleAccessTokenErrorResponse, handleInvalidState, handleMissingConfiguration, handleState, requestAccessToken } from "../utils.js";
-import { useRuntimeConfig } from "#imports";
 export function defineOAuthRiotGamesEventHandler({ config, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.riotgames, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.riotgames, {
       authorizationURL: "https://auth.riotgames.com/authorize",
       tokenURL: "https://auth.riotgames.com/token",
       apiURL: "https://auth.riotgames.com",
@@ -14,7 +14,7 @@ export function defineOAuthRiotGamesEventHandler({ config, onSuccess, onError })
     const query = getQuery(event);
     if (query.error) {
       const error = createError({
-        statusCode: 401,
+        status: 401,
         message: `RiotGames login failed: ${query.error || "Unknown error"}`,
         data: query
       });

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

@@ -123,4 +123,4 @@ export interface OAuthRobloxUser {
         visibility: 'SOCIAL_NETWORK_VISIBILITY_UNSPECIFIED' | 'NO_ONE' | 'FRIENDS' | 'FRIENDS_AND_FOLLOWING' | 'FRIENDS_FOLLOWING_AND_FOLLOWERS' | 'EVERYONE';
     };
 }
-export declare function defineOAuthRobloxEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthRobloxConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export declare function defineOAuthRobloxEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthRobloxConfig>): import("nuxt/server").EventHandler<Promise<any>>;

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

@@ -1,11 +1,11 @@
-import { eventHandler, getQuery, sendRedirect } from "h3";
+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";
-import { useRuntimeConfig } from "#imports";
 export function defineOAuthRobloxEventHandler({ config, onSuccess, onError }) {
-  return eventHandler(async (event) => {
-    config = defu(config, useRuntimeConfig(event).oauth?.roblox, {
+  return defineEventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig().oauth?.roblox, {
       authorizationURL: "https://apis.roblox.com/oauth/v1/authorize",
       tokenURL: "https://apis.roblox.com/oauth/v1/token",
       authorizationParams: {}

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

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