nuxt-auth-utils 0.3.3 → 0.3.5

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

@@ -1,12 +1,12 @@
 import {
   eventHandler,
-  createError,
   getQuery,
   getRequestURL,
   sendRedirect
 } from "h3";
 import { withQuery, parsePath } from "ufo";
 import { defu } from "defu";
+import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthGoogleEventHandler({
   config,
@@ -22,14 +22,9 @@ export function oauthGoogleEventHandler({
     });
     const { code } = getQuery(event);
     if (!config.clientId) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_GOOGLE_CLIENT_ID env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "google", ["clientId"], onError);
     }
-    const redirectUrl = getRequestURL(event).href;
+    const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
       config.scope = config.scope || ["email", "profile"];
       return sendRedirect(
@@ -37,7 +32,7 @@ export function oauthGoogleEventHandler({
         withQuery(config.authorizationURL, {
           response_type: "code",
           client_id: config.clientId,
-          redirect_uri: redirectUrl,
+          redirect_uri: redirectURL,
           scope: config.scope.join(" "),
           ...config.authorizationParams
         })
@@ -45,7 +40,7 @@ export function oauthGoogleEventHandler({
     }
     const body = {
       grant_type: "authorization_code",
-      redirect_uri: parsePath(redirectUrl).pathname,
+      redirect_uri: parsePath(redirectURL).pathname,
       client_id: config.clientId,
       client_secret: config.clientSecret,
       code
@@ -57,13 +52,7 @@ export function oauthGoogleEventHandler({
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `Google login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "google", tokens, onError);
     }
     const accessToken = tokens.access_token;
     const user = await $fetch(

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

@@ -32,5 +32,10 @@ export interface OAuthKeycloakConfig {
      * Extra authorization parameters to provide to the authorization URL
      */
     authorizationParams?: Record<string, string>;
+    /**
+     * Redirect URL to to allow overriding for situations like prod failing to determine public hostname
+     * @default process.env.NUXT_OAUTH_KEYCLOAK_REDIRECT_URL or current URL
+     */
+    redirectURL?: string;
 }
 export declare function oauthKeycloakEventHandler({ config, onSuccess, onError, }: OAuthConfig<OAuthKeycloakConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -7,6 +7,7 @@ import {
 } from "h3";
 import { withQuery, parsePath } from "ufo";
 import { defu } from "defu";
+import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthKeycloakEventHandler({
   config,
@@ -29,24 +30,19 @@ export function oauthKeycloakEventHandler({
       return onError(event, error);
     }
     if (!config.clientId || !config.clientSecret || !config.serverUrl || !config.realm) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_KEYCLOAK_CLIENT_ID or NUXT_OAUTH_KEYCLOAK_CLIENT_SECRET or NUXT_OAUTH_KEYCLOAK_SERVER_URL or NUXT_OAUTH_KEYCLOAK_REALM env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "keycloak", ["clientId", "clientSecret", "serverUrl", "realm"], onError);
     }
     const realmURL = `${config.serverUrl}/realms/${config.realm}`;
     const authorizationURL = `${realmURL}/protocol/openid-connect/auth`;
     const tokenURL = `${realmURL}/protocol/openid-connect/token`;
-    const redirectUrl = getRequestURL(event).href;
+    const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
       config.scope = config.scope || ["openid"];
       return sendRedirect(
         event,
         withQuery(authorizationURL, {
           client_id: config.clientId,
-          redirect_uri: redirectUrl,
+          redirect_uri: redirectURL,
           scope: config.scope.join(" "),
           response_type: "code",
           ...config.authorizationParams
@@ -66,20 +62,14 @@ export function oauthKeycloakEventHandler({
         client_id: config.clientId,
         client_secret: config.clientSecret,
         grant_type: "authorization_code",
-        redirect_uri: parsePath(redirectUrl).pathname,
+        redirect_uri: parsePath(redirectURL).pathname,
         code
       }).toString()
     }).catch((error) => {
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `Keycloak login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "keycloak", tokens, onError);
     }
     const accessToken = tokens.access_token;
     const user = await $fetch(

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

@@ -36,6 +36,11 @@ export interface OAuthLinkedInConfig {
      * @see https://docs.microsoft.com/en-us/linkedin/shared/authentication/authorization-code-flow?context=linkedin/context
      */
     authorizationParams?: Record<string, string>;
+    /**
+     * Redirect URL to to allow overriding for situations like prod failing to determine public hostname
+     * @default process.env.NUXT_OAUTH_LINKEDIN_REDIRECT_URL or current URL
+     */
+    redirectURL?: string;
 }
 interface OAuthConfig {
     config?: OAuthLinkedInConfig;

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

@@ -1,6 +1,7 @@
-import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
+import { eventHandler, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parseURL, stringifyParsedURL } from "ufo";
 import { defu } from "defu";
+import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthLinkedInEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -11,14 +12,9 @@ export function oauthLinkedInEventHandler({ config, onSuccess, onError }) {
     });
     const { code } = getQuery(event);
     if (!config.clientId || !config.clientSecret) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_LINKEDIN_CLIENT_ID or NUXT_OAUTH_LINKEDIN_CLIENT_SECRET env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "linkedin", ["clientId", "clientSecret"], onError);
     }
-    const redirectUrl = getRequestURL(event).href;
+    const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
       config.scope = config.scope || [];
       if (!config.scope.length) {
@@ -32,13 +28,13 @@ export function oauthLinkedInEventHandler({ config, onSuccess, onError }) {
         withQuery(config.authorizationURL, {
           response_type: "code",
           client_id: config.clientId,
-          redirect_uri: redirectUrl,
+          redirect_uri: redirectURL,
           scope: config.scope.join(" "),
           ...config.authorizationParams
         })
       );
     }
-    const parsedRedirectUrl = parseURL(redirectUrl);
+    const parsedRedirectUrl = parseURL(redirectURL);
     parsedRedirectUrl.search = "";
     const tokens = await $fetch(
       config.tokenURL,
@@ -59,13 +55,7 @@ export function oauthLinkedInEventHandler({ config, onSuccess, onError }) {
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `LinkedIn login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "linkedin", tokens, onError);
     }
     const accessToken = tokens.access_token;
     const user = await $fetch("https://api.linkedin.com/v2/userinfo", {

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

@@ -49,7 +49,7 @@ export interface OAuthMicrosoftConfig {
      * @default process.env.NUXT_OAUTH_MICROSOFT_REDIRECT_URL
      * @see https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-auth-code-flow
      */
-    redirectUrl?: string;
+    redirectURL?: string;
 }
 interface OAuthConfig {
     config?: OAuthMicrosoftConfig;

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

@@ -1,6 +1,7 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parsePath } from "ufo";
 import { defu } from "defu";
+import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthMicrosoftEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -9,16 +10,11 @@ export function oauthMicrosoftEventHandler({ config, onSuccess, onError }) {
     });
     const { code } = getQuery(event);
     if (!config.clientId || !config.clientSecret || !config.tenant) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_MICROSOFT_CLIENT_ID or NUXT_OAUTH_MICROSOFT_CLIENT_SECRET or NUXT_OAUTH_MICROSOFT_TENANT env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "microsoft", ["clientId", "clientSecret", "tenant"], onError);
     }
     const authorizationURL = config.authorizationURL || `https://login.microsoftonline.com/${config.tenant}/oauth2/v2.0/authorize`;
     const tokenURL = config.tokenURL || `https://login.microsoftonline.com/${config.tenant}/oauth2/v2.0/token`;
-    const redirectUrl = config.redirectUrl || getRequestURL(event).href;
+    const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
       const scope = config.scope && config.scope.length > 0 ? config.scope : ["User.Read"];
       return sendRedirect(
@@ -26,7 +22,7 @@ export function oauthMicrosoftEventHandler({ config, onSuccess, onError }) {
         withQuery(authorizationURL, {
           client_id: config.clientId,
           response_type: "code",
-          redirect_uri: redirectUrl,
+          redirect_uri: redirectURL,
           scope: scope.join(" "),
           ...config.authorizationParams
         })
@@ -36,7 +32,7 @@ export function oauthMicrosoftEventHandler({ config, onSuccess, onError }) {
     data.append("grant_type", "authorization_code");
     data.append("client_id", config.clientId);
     data.append("client_secret", config.clientSecret);
-    data.append("redirect_uri", parsePath(redirectUrl).pathname);
+    data.append("redirect_uri", parsePath(redirectURL).pathname);
     data.append("code", String(code));
     const tokens = await $fetch(
       tokenURL,
@@ -51,13 +47,7 @@ export function oauthMicrosoftEventHandler({ config, onSuccess, onError }) {
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `Microsoft login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "microsoft", tokens, onError);
     }
     const tokenType = tokens.token_type;
     const accessToken = tokens.access_token;

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

@@ -43,5 +43,10 @@ export interface OAuthPaypalConfig {
      * @example { flowEntry: 'static' }
      */
     authorizationParams?: Record<string, string>;
+    /**
+     * Redirect URL to to allow overriding for situations like prod failing to determine public hostname
+     * @default process.env.NUXT_OAUTH_PAYPAL_REDIRECT_URL or current URL
+     */
+    redirectURL?: string;
 }
 export declare function oauthPaypalEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthPaypalConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -1,6 +1,7 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parsePath } from "ufo";
 import { defu } from "defu";
+import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthPaypalEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -12,12 +13,7 @@ export function oauthPaypalEventHandler({ config, onSuccess, onError }) {
     });
     const { code } = getQuery(event);
     if (!config.clientId) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_PAYPAL_CLIENT_ID env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "paypal", ["clientId"], onError);
     }
     let paypalAPI = "api-m.paypal.com";
     if (config.sandbox) {
@@ -25,7 +21,7 @@ export function oauthPaypalEventHandler({ config, onSuccess, onError }) {
       config.authorizationURL = "https://www.sandbox.paypal.com/signin/authorize";
       config.tokenURL = `https://${paypalAPI}/v1/oauth2/token`;
     }
-    const redirectUrl = getRequestURL(event).href;
+    const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
       config.scope = config.scope || [];
       if (!config.scope.includes("openid")) {
@@ -39,7 +35,7 @@ export function oauthPaypalEventHandler({ config, onSuccess, onError }) {
         withQuery(config.authorizationURL, {
           response_type: "code",
           client_id: config.clientId,
-          redirect_uri: redirectUrl,
+          redirect_uri: redirectURL,
           scope: config.scope.join(" "),
           flowEntry: "static",
           ...config.authorizationParams
@@ -57,7 +53,7 @@ export function oauthPaypalEventHandler({ config, onSuccess, onError }) {
         },
         params: {
           grant_type: "authorization_code",
-          redirect_uri: encodeURIComponent(parsePath(redirectUrl).pathname),
+          redirect_uri: encodeURIComponent(parsePath(redirectURL).pathname),
           code
         }
       }
@@ -65,13 +61,7 @@ export function oauthPaypalEventHandler({ config, onSuccess, onError }) {
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `PayPal login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "paypal", tokens, onError);
     }
     const accessToken = tokens.access_token;
     const users = await $fetch(`https://${paypalAPI}/v1/identity/openidconnect/userinfo`, {

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

@@ -38,5 +38,10 @@ export interface OAuthSpotifyConfig {
      * @example { show_dialog: 'true' }
      */
     authorizationParams?: Record<string, string>;
+    /**
+     * Redirect URL to to allow overriding for situations like prod failing to determine public hostname
+     * @default process.env.NUXT_OAUTH_SPOTIFY_REDIRECT_URL or current URL
+     */
+    redirectURL?: string;
 }
 export declare function oauthSpotifyEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthSpotifyConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -1,6 +1,7 @@
-import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
+import { eventHandler, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parsePath } from "ufo";
 import { defu } from "defu";
+import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthSpotifyEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -11,14 +12,9 @@ export function oauthSpotifyEventHandler({ config, onSuccess, onError }) {
     });
     const { code } = getQuery(event);
     if (!config.clientId || !config.clientSecret) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_SPOTIFY_CLIENT_ID or NUXT_OAUTH_SPOTIFY_CLIENT_SECRET env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "spotify", ["clientId", "clientSecret"], onError);
     }
-    const redirectUrl = getRequestURL(event).href;
+    const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
       config.scope = config.scope || [];
       if (config.emailRequired && !config.scope.includes("user-read-email")) {
@@ -29,7 +25,7 @@ export function oauthSpotifyEventHandler({ config, onSuccess, onError }) {
         withQuery(config.authorizationURL, {
           response_type: "code",
           client_id: config.clientId,
-          redirect_uri: redirectUrl,
+          redirect_uri: redirectURL,
           scope: config.scope.join(" "),
           ...config.authorizationParams
         })
@@ -46,7 +42,7 @@ export function oauthSpotifyEventHandler({ config, onSuccess, onError }) {
         },
         params: {
           grant_type: "authorization_code",
-          redirect_uri: parsePath(redirectUrl).pathname,
+          redirect_uri: parsePath(redirectURL).pathname,
           code
         }
       }
@@ -54,13 +50,7 @@ export function oauthSpotifyEventHandler({ config, onSuccess, onError }) {
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `Spotify login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "spotify", tokens, onError);
     }
     const accessToken = tokens.access_token;
     const user = await $fetch("https://api.spotify.com/v1/me", {

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

@@ -11,5 +11,10 @@ export interface OAuthSteamConfig {
      * @default 'https://steamcommunity.com/openid/login'
      */
     authorizationURL?: string;
+    /**
+     * Redirect URL to to allow overriding for situations like prod failing to determine public hostname
+     * @default process.env.NUXT_OAUTH_STEAM_REDIRECT_URL or current URL
+     */
+    redirectURL?: string;
 }
 export declare function oauthSteamEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthSteamConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -1,6 +1,7 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery } from "ufo";
 import { defu } from "defu";
+import { handleMissingConfiguration } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthSteamEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -9,19 +10,14 @@ export function oauthSteamEventHandler({ config, onSuccess, onError }) {
     });
     const query = getQuery(event);
     if (!config.apiKey) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_STEAM_API_KEY env variable."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "steam", ["apiKey"], onError);
     }
     if (!query["openid.claimed_id"]) {
-      const redirectUrl = getRequestURL(event).href;
+      const redirectURL = config.redirectURL || getRequestURL(event).href;
       const steamOpenIdParams = {
         "openid.ns": "http://specs.openid.net/auth/2.0",
         "openid.mode": "checkid_setup",
-        "openid.return_to": redirectUrl,
+        "openid.return_to": redirectURL,
         "openid.identity": "http://specs.openid.net/auth/2.0/identifier_select",
         "openid.claimed_id": "http://specs.openid.net/auth/2.0/identifier_select"
       };

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

@@ -38,5 +38,10 @@ export interface OAuthTwitchConfig {
      * @example { force_verify: 'true' }
      */
     authorizationParams?: Record<string, string>;
+    /**
+     * Redirect URL to to allow overriding for situations like prod failing to determine public hostname
+     * @default process.env.NUXT_OAUTH_TWITCH_REDIRECT_URL or current URL
+     */
+    redirectURL?: string;
 }
 export declare function oauthTwitchEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthTwitchConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -1,6 +1,7 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parsePath } from "ufo";
 import { defu } from "defu";
+import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthTwitchEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -11,14 +12,9 @@ export function oauthTwitchEventHandler({ config, onSuccess, onError }) {
     });
     const { code } = getQuery(event);
     if (!config.clientId) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_TWITCH_CLIENT_ID env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "twitch", ["clientId"], onError);
     }
-    const redirectUrl = getRequestURL(event).href;
+    const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
       config.scope = config.scope || [];
       if (config.emailRequired && !config.scope.includes("user:read:email")) {
@@ -29,7 +25,7 @@ export function oauthTwitchEventHandler({ config, onSuccess, onError }) {
         withQuery(config.authorizationURL, {
           response_type: "code",
           client_id: config.clientId,
-          redirect_uri: redirectUrl,
+          redirect_uri: redirectURL,
           scope: config.scope.join(" "),
           ...config.authorizationParams
         })
@@ -44,7 +40,7 @@ export function oauthTwitchEventHandler({ config, onSuccess, onError }) {
         },
         params: {
           grant_type: "authorization_code",
-          redirect_uri: parsePath(redirectUrl).pathname,
+          redirect_uri: parsePath(redirectURL).pathname,
           client_id: config.clientId,
           client_secret: config.clientSecret,
           code
@@ -54,13 +50,7 @@ export function oauthTwitchEventHandler({ config, onSuccess, onError }) {
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `Twitch login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "twitch", tokens, onError);
     }
     const accessToken = tokens.access_token;
     const users = await $fetch("https://api.twitch.tv/helix/users", {

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

@@ -17,11 +17,6 @@ export interface OAuthXConfig {
      * @example ['tweet.read', 'users.read', 'offline.access'],
      */
     scope?: string[];
-    /**
-     * Require email from user
-     * @default false
-     */
-    emailRequired?: boolean;
     /**
      * X OAuth Authorization URL
      * @default 'https://twitter.com/i/oauth2/authorize'
@@ -41,6 +36,11 @@ export interface OAuthXConfig {
      * Extra authorization parameters to provide to the authorization URL
      * @see https://developer.x.com/en/docs/authentication/oauth-2-0/user-access-token
      */
-    authorizationParams: Record<string, string>;
+    authorizationParams?: Record<string, string>;
+    /**
+     * Redirect URL to to allow overriding for situations like prod failing to determine public hostname
+     * @default process.env.NUXT_OAUTH_X_REDIRECT_URL or current URL
+     */
+    redirectURL?: string;
 }
 export declare function oauthXEventHandler({ config, onSuccess, onError, }: OAuthConfig<OAuthXConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;