nuxt-auth-utils 0.3.4 → 0.3.5

package/dist/module.d.mts

@@ -2,6 +2,6 @@ import * as _nuxt_schema from '@nuxt/schema';
 
 interface ModuleOptions {
 }
-declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
 export { type ModuleOptions, _default as default };

package/dist/module.d.ts

@@ -2,6 +2,6 @@ import * as _nuxt_schema from '@nuxt/schema';
 
 interface ModuleOptions {
 }
-declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
 export { type ModuleOptions, _default as default };

package/dist/module.json

@@ -1,9 +1,9 @@
 {
   "name": "auth-utils",
   "configKey": "auth",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "builder": {
-    "@nuxt/module-builder": "0.8.1",
+    "@nuxt/module-builder": "0.8.3",
     "unbuild": "2.0.0"
   }
 }

package/dist/runtime/app/plugins/session.client.js

@@ -1,6 +1,8 @@
 import { defineNuxtPlugin, useUserSession } from "#imports";
 export default defineNuxtPlugin(async (nuxtApp) => {
-  if (!nuxtApp.payload.serverRendered || Boolean(nuxtApp.payload.prerenderedAt) || Boolean(nuxtApp.payload.isCached)) {
+  if (!nuxtApp.payload.serverRendered) {
+    await useUserSession().fetch();
+  } else if (Boolean(nuxtApp.payload.prerenderedAt) || Boolean(nuxtApp.payload.isCached)) {
     nuxtApp.hook("app:mounted", async () => {
       await useUserSession().fetch();
     });

package/dist/runtime/server/lib/oauth/auth0.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 { handleMissingConfiguration, handleAccessTokenErrorResponse } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthAuth0EventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -9,12 +10,7 @@ export function oauthAuth0EventHandler({ config, onSuccess, onError }) {
     });
     const { code } = getQuery(event);
     if (!config.clientId || !config.clientSecret || !config.domain) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_AUTH0_CLIENT_ID or NUXT_OAUTH_AUTH0_CLIENT_SECRET or NUXT_OAUTH_AUTH0_DOMAIN env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "auth0", ["clientId", "clientSecret", "domain"], onError);
     }
     const authorizationURL = `https://${config.domain}/authorize`;
     const tokenURL = `https://${config.domain}/oauth/token`;
@@ -57,13 +53,7 @@ export function oauthAuth0EventHandler({ config, onSuccess, onError }) {
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `Auth0 login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "auth0", tokens, onError);
     }
     const tokenType = tokens.token_type;
     const accessToken = tokens.access_token;

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

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 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 oauthBattledotnetEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -22,12 +23,12 @@ export function oauthBattledotnetEventHandler({ config, onSuccess, onError }) {
       return onError(event, error);
     }
     if (!config.clientId || !config.clientSecret) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_BATTLEDOTNET_CLIENT_ID or NUXT_OAUTH_BATTLEDOTNET_CLIENT_SECRET env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(
+        event,
+        "battledotnet",
+        ["clientId", "clientSecret"],
+        onError
+      );
     }
     const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
@@ -74,13 +75,7 @@ export function oauthBattledotnetEventHandler({ config, onSuccess, onError }) {
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `Battle.net login failed: ${tokens.error || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "battle.net", tokens, onError);
     }
     const accessToken = tokens.access_token;
     const user = await $fetch("https://oauth.battle.net/userinfo", {

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

@@ -35,5 +35,10 @@ export interface OAuthCognitoConfig {
      * @default process.env.NUXT_OAUTH_COGNITO_REDIRECT_URL or current URL
      */
     redirectURL?: string;
+    /**
+     * AWS Cognito App Custom Domain – some pool configurations require this
+     * @default ''
+     */
+    domain?: string;
 }
 export declare function oauthCognitoEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthCognitoConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

package/dist/runtime/server/lib/oauth/cognito.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 oauthCognitoEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -9,15 +10,11 @@ export function oauthCognitoEventHandler({ config, onSuccess, onError }) {
     });
     const { code } = getQuery(event);
     if (!config.clientId || !config.clientSecret || !config.userPoolId || !config.region) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_COGNITO_CLIENT_ID, NUXT_OAUTH_COGNITO_CLIENT_SECRET, NUXT_OAUTH_COGNITO_USER_POOL_ID, or NUXT_OAUTH_COGNITO_REGION env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "cognito", ["clientId", "clientSecret", "userPoolId", "region"], onError);
     }
-    const authorizationURL = `https://${config.userPoolId}.auth.${config.region}.amazoncognito.com/oauth2/authorize`;
-    const tokenURL = `https://${config.userPoolId}.auth.${config.region}.amazoncognito.com/oauth2/token`;
+    const urlBase = config?.domain || `${config.userPoolId}.auth.${config.region}.amazoncognito.com`;
+    const authorizationURL = `https://${urlBase}/oauth2/authorize`;
+    const tokenURL = `https://${urlBase}/oauth2/token`;
     const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
       config.scope = config.scope || ["openid", "profile"];
@@ -45,17 +42,11 @@ export function oauthCognitoEventHandler({ config, onSuccess, onError }) {
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `Cognito login failed: ${tokens.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "cognito", tokens, onError);
     }
     const tokenType = tokens.token_type;
     const accessToken = tokens.access_token;
-    const user = await $fetch(`https://${config.userPoolId}.auth.${config.region}.amazoncognito.com/oauth2/userInfo`, {
+    const user = await $fetch(`https://${urlBase}/oauth2/userInfo`, {
       headers: {
         Authorization: `${tokenType} ${accessToken}`
       }

package/dist/runtime/server/lib/oauth/discord.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 oauthDiscordEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -12,12 +13,7 @@ export function oauthDiscordEventHandler({ config, onSuccess, onError }) {
     });
     const { code } = getQuery(event);
     if (!config.clientId || !config.clientSecret) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_DISCORD_CLIENT_ID or NUXT_OAUTH_DISCORD_CLIENT_SECRET env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "discord", ["clientId", "clientSecret"], onError);
     }
     const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
@@ -60,13 +56,7 @@ export function oauthDiscordEventHandler({ config, onSuccess, onError }) {
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `Discord login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "discord", tokens, onError);
     }
     const accessToken = tokens.access_token;
     const user = await $fetch("https://discord.com/api/users/@me", {

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

@@ -7,6 +7,7 @@ import {
 } from "h3";
 import { withQuery } from "ufo";
 import { defu } from "defu";
+import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthFacebookEventHandler({
   config,
@@ -30,12 +31,7 @@ export function oauthFacebookEventHandler({
       return onError(event, error);
     }
     if (!config.clientId) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_FACEBOOK_CLIENT_ID or NUXT_OAUTH_FACEBOOK_CLIENT_SECRET env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "facebook", ["clientId"], onError);
     }
     const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!query.code) {
@@ -59,13 +55,7 @@ export function oauthFacebookEventHandler({
       }
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `Facebook login failed: ${tokens.error || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "facebook", tokens, onError);
     }
     const accessToken = tokens.access_token;
     config.fields = config.fields || ["id", "name"];

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

@@ -1,6 +1,7 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery } from "ufo";
 import { defu } from "defu";
+import { handleAccessTokenErrorResponse, handleMissingConfiguration } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthGitHubEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -20,12 +21,7 @@ export function oauthGitHubEventHandler({ config, onSuccess, onError }) {
       return onError(event, error);
     }
     if (!config.clientId || !config.clientSecret) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_GITHUB_CLIENT_ID or NUXT_OAUTH_GITHUB_CLIENT_SECRET env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "github", ["clientId", "clientSecret"], onError);
     }
     if (!query.code) {
       config.scope = config.scope || [];
@@ -55,13 +51,7 @@ export function oauthGitHubEventHandler({ config, onSuccess, onError }) {
       }
     );
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `GitHub login failed: ${tokens.error || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "github", tokens, onError);
     }
     const accessToken = tokens.access_token;
     const user = await $fetch("https://api.github.com/user", {

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,12 +22,7 @@ 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 = config.redirectURL || getRequestURL(event).href;
     if (!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.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,12 +30,7 @@ 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`;
@@ -73,13 +69,7 @@ export function oauthKeycloakEventHandler({
       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.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,12 +12,7 @@ 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 = config.redirectURL || getRequestURL(event).href;
     if (!code) {
@@ -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.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,12 +10,7 @@ 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`;
@@ -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.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) {
@@ -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.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,12 +12,7 @@ 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 = config.redirectURL || getRequestURL(event).href;
     if (!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.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,12 +10,7 @@ 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 = config.redirectURL || getRequestURL(event).href;

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,12 +12,7 @@ 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 = config.redirectURL || getRequestURL(event).href;
     if (!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,7 +36,7 @@ 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

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

@@ -1,13 +1,13 @@
 import { randomUUID } from "node:crypto";
 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 oauthXEventHandler({
   config,
@@ -16,9 +16,9 @@ export function oauthXEventHandler({
 }) {
   return eventHandler(async (event) => {
     config = defu(config, useRuntimeConfig(event).oauth?.x, {
-      authorizationURL: "https://twitter.com/i/oauth2/authorize",
-      tokenURL: "https://api.twitter.com/2/oauth2/token",
-      userURL: "https://api.twitter.com/2/users/me",
+      authorizationURL: "https://x.com/i/oauth2/authorize",
+      tokenURL: "https://api.x.com/2/oauth2/token",
+      userURL: "https://api.x.com/2/users/me",
       authorizationParams: {
         state: randomUUID(),
         code_challenge: randomUUID()
@@ -26,12 +26,7 @@ export function oauthXEventHandler({
     });
     const { code } = getQuery(event);
     if (!config.clientId) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_X_CLIENT_ID env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "x", ["clientId"], onError);
     }
     const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
@@ -50,7 +45,7 @@ export function oauthXEventHandler({
     }
     const params = {
       grant_type: "authorization_code",
-      code_verifier: config.authorizationParams.code_challenge,
+      code_verifier: config.authorizationParams?.code_challenge,
       redirect_uri: parsePath(redirectURL).pathname,
       code
     };
@@ -66,13 +61,7 @@ export function oauthXEventHandler({
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `X login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "x", tokens, onError);
     }
     const accessToken = tokens.access_token;
     const user = await $fetch(
@@ -88,29 +77,6 @@ export function oauthXEventHandler({
     ).catch((error) => {
       return error;
     });
-    if (config.emailRequired) {
-      const emailData = await $fetch("https://api.twitter.com/1.1/account/verify_credentials.json", {
-        headers: {
-          Authorization: `Bearer ${accessToken}`
-        },
-        query: {
-          include_email: "true",
-          skip_status: "true"
-        }
-      }).catch((error) => {
-        return error;
-      });
-      if (emailData && emailData.email) {
-        user.email = emailData.email;
-      } else {
-        const error = createError({
-          statusCode: 401,
-          message: "Twitter login failed: no user email found"
-        });
-        if (!onError) throw error;
-        return onError(event, error);
-      }
-    }
     return onSuccess(event, {
       tokens,
       user: user?.data

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

@@ -1,18 +1,14 @@
-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 oauthXSUAAEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
     config = defu(config, useRuntimeConfig(event).oauth?.xsuaa);
     const { code } = getQuery(event);
     if (!config.clientId || !config.clientSecret || !config.domain) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_XSUAA_CLIENT_ID or NUXT_OAUTH_XSUAA_CLIENT_SECRET or NUXT_OAUTH_XSUAA_DOMAIN env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "xsuaa", ["clientId", "clientSecret", "domain"], onError);
     }
     const authorizationURL = `https://${config.domain}/oauth/authorize`;
     const tokenURL = `https://${config.domain}/oauth/token`;
@@ -48,13 +44,7 @@ export function oauthXSUAAEventHandler({ config, onSuccess, onError }) {
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `XSUAA login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "auth0", tokens, onError);
     }
     const tokenType = tokens.token_type;
     const accessToken = tokens.access_token;

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

@@ -1,12 +1,12 @@
 import {
   eventHandler,
-  createError,
   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 oauthYandexEventHandler({
   config,
@@ -21,12 +21,7 @@ export function oauthYandexEventHandler({
     });
     const { code } = getQuery(event);
     if (!config.clientId || !config.clientSecret) {
-      const error = createError({
-        statusCode: 500,
-        message: "Missing NUXT_OAUTH_YANDEX_CLIENT_ID or NUXT_OAUTH_YANDEX_CLIENT_SECRET env variables."
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleMissingConfiguration(event, "yandex", ["clientId", "clientSecret"], onError);
     }
     const redirectURL = config.redirectURL || getRequestURL(event).href;
     if (!code) {
@@ -60,13 +55,7 @@ export function oauthYandexEventHandler({
       return { error };
     });
     if (tokens.error) {
-      const error = createError({
-        statusCode: 401,
-        message: `Yandex login failed: ${tokens.error?.data?.error_description || "Unknown error"}`,
-        data: tokens
-      });
-      if (!onError) throw error;
-      return onError(event, error);
+      return handleAccessTokenErrorResponse(event, "yandex", tokens, onError);
     }
     const accessToken = tokens.access_token;
     const user = await $fetch(config.userURL, {

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

@@ -0,0 +1,9 @@
+import type { H3Event } from 'h3';
+import type { OnError, OAuthProvider } from '#auth-utils';
+/**
+ * Handle OAuth access token error response
+ *
+ * @see https://datatracker.ietf.org/doc/html/rfc6749#section-5.2
+ */
+export declare function handleAccessTokenErrorResponse(event: H3Event, oauthProvider: OAuthProvider, oauthError: any, onError?: OnError): void | Promise<void>;
+export declare function handleMissingConfiguration(event: H3Event, provider: OAuthProvider, missingKeys: string[], onError?: OnError): void | Promise<void>;

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

@@ -0,0 +1,21 @@
+import { snakeCase, upperFirst } from "scule";
+import { createError } from "#imports";
+export function handleAccessTokenErrorResponse(event, oauthProvider, oauthError, onError) {
+  const message = `${upperFirst(oauthProvider)} login failed: ${oauthError.error_description || oauthError.error || "Unknown error"}`;
+  const error = createError({
+    statusCode: 401,
+    message,
+    data: oauthError
+  });
+  if (!onError) throw error;
+  return onError(event, error);
+}
+export function handleMissingConfiguration(event, provider, missingKeys, onError) {
+  const environmentVariables = missingKeys.map((key) => `NUXT_OAUTH_${provider.toUpperCase()}_${snakeCase(key).toUpperCase()}`);
+  const error = createError({
+    statusCode: 500,
+    message: `Missing ${environmentVariables.join(" or ")} env ${missingKeys.length > 1 ? "variables" : "variable"}.`
+  });
+  if (!onError) throw error;
+  return onError(event, error);
+}

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

@@ -1,2 +1,2 @@
 export type { User, UserSession, UserSessionRequired, UserSessionComposable } from './session.js';
-export type { OAuthConfig } from './oauth-config.js';
+export type { OAuthConfig, OAuthProvider, OnError } from './oauth-config.js';

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

@@ -1,9 +1,11 @@
 import type { H3Event, H3Error } from 'h3';
+export type OAuthProvider = 'auth0' | 'battledotnet' | 'cognito' | 'discord' | 'facebook' | 'github' | 'google' | 'keycloak' | 'linkedin' | 'microsoft' | 'paypal' | 'spotify' | 'steam' | 'twitch' | 'x' | 'xsuaa' | 'yandex' | (string & {});
+export type OnError = (event: H3Event, error: H3Error) => Promise<void> | void;
 export interface OAuthConfig<TConfig, TUser = any, TTokens = any> {
     config?: TConfig;
     onSuccess: (event: H3Event, result: {
         user: TUser;
         tokens: TTokens;
     }) => Promise<void> | void;
-    onError?: (event: H3Event, error: H3Error) => Promise<void> | void;
+    onError?: OnError;
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "nuxt-auth-utils",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Minimalist Auth module for Nuxt with SSR",
   "repository": "Atinux/nuxt-auth-utils",
   "license": "MIT",
   "type": "module",
-  "packageManager": "pnpm@9.7.0",
+  "packageManager": "pnpm@9.9.0",
   "exports": {
     ".": {
       "types": "./dist/types.d.ts",
@@ -32,26 +32,27 @@
     "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@nuxt/kit": "^3.12.4",
+    "@nuxt/kit": "^3.13.0",
     "defu": "^6.1.4",
     "hookable": "^5.5.3",
     "ofetch": "^1.3.4",
     "ohash": "^1.1.3",
     "pathe": "^1.1.2",
+    "scule": "^1.3.0",
     "uncrypto": "^0.1.3"
   },
   "devDependencies": {
-    "@iconify-json/simple-icons": "^1.1.113",
+    "@iconify-json/simple-icons": "^1.1.115",
     "@nuxt/devtools": "latest",
-    "@nuxt/eslint-config": "^0.5.0",
-    "@nuxt/module-builder": "^0.8.1",
-    "@nuxt/schema": "^3.12.4",
-    "@nuxt/test-utils": "^3.14.0",
+    "@nuxt/eslint-config": "^0.5.3",
+    "@nuxt/module-builder": "^0.8.3",
+    "@nuxt/schema": "^3.13.0",
+    "@nuxt/test-utils": "^3.14.1",
     "@nuxt/ui": "^2.18.4",
     "@nuxt/ui-pro": "^1.4.1",
     "changelogen": "^0.5.5",
-    "eslint": "^9.9.0",
-    "nuxt": "^3.12.4",
+    "eslint": "^9.9.1",
+    "nuxt": "^3.13.0",
     "typescript": "^5.5.4",
     "vitest": "^2.0.5",
     "vue-tsc": "^2.0.29"