nuxt-auth-utils 0.1.0 → 0.2.1

package/README.md

@@ -5,7 +5,7 @@
 [![License][license-src]][license-href]
 [![Nuxt][nuxt-src]][nuxt-href]
 
-Minimalist Authentication module for Nuxt exposing Vue composables and server utils.
+Add Authentication to Nuxt applications with secured & sealed cookies sessions.
 
 - [Release Notes](/CHANGELOG.md)
 - [Demo](https://github.com/atinux/nuxt-todos-edge)
@@ -14,13 +14,20 @@ Minimalist Authentication module for Nuxt exposing Vue composables and server ut
 
 ## Features
 
-- Support for Hybrid Rendering (SSR / CSR / SWR / Prerendering)
-- Secured & sealed cookies sessions
-- [OAuth Providers](#supported-oauth-providers)
+- [Hybrid Rendering](#hybrid-rendering) support (SSR / CSR / SWR / Prerendering)
+- [15+ OAuth Providers](#supported-oauth-providers)
+- [Vue composable](#vue-composable)
+- [Server utils](#server-utils)
+- [`<AuthState>` component](#authstate-component)
+- [Extendable with hooks](#extend-session)
 
 ## Requirements
 
-This module only works with the Nuxt server running as it uses server API routes. This means that you cannot use this module with `nuxt generate`.
+This module only works with a Nuxt server running as it uses server API routes (`nuxt build`).
+
+This means that you cannot use this module with `nuxt generate`.
+
+You can anyway use [Hybrid Rendering](#hybrid-rendering) to pre-render pages of your application or disable server-side rendering completely.
 
 ## Quick Setup
 
@@ -41,7 +48,7 @@ Nuxt Auth Utils generates one for you when running Nuxt in development the first
 
 3. That's it! You can now add authentication to your Nuxt app ✨
 
-## Vue Composables
+## Vue Composable
 
 Nuxt Auth Utils automatically adds some plugins to fetch the current user session to let you access it from your Vue components.
 
@@ -153,8 +160,13 @@ It can also be set using environment variables:
 - Keycloak
 - LinkedIn
 - Microsoft
+- PayPal
 - Spotify
+- Steam
 - Twitch
+- X (Twitter)
+- XSUAA
+- Yandex
 
 You can add your favorite provider by creating a new file in [src/runtime/server/lib/oauth/](./src/runtime/server/lib/oauth/).
 

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "auth-utils",
   "configKey": "auth",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "builder": {
     "@nuxt/module-builder": "0.7.1",
     "unbuild": "2.0.0"

package/dist/module.mjs

@@ -43,7 +43,11 @@ const module = defineNuxtModule({
       const envPath = join(nuxt.options.rootDir, ".env");
       const envContent = await readFile(envPath, "utf-8").catch(() => "");
       if (!envContent.includes("NUXT_SESSION_PASSWORD")) {
-        await writeFile(envPath, `${envContent ? envContent + "\n" : envContent}NUXT_SESSION_PASSWORD=${runtimeConfig.session.password}`, "utf-8");
+        await writeFile(
+          envPath,
+          `${envContent ? envContent + "\n" : envContent}NUXT_SESSION_PASSWORD=${runtimeConfig.session.password}`,
+          "utf-8"
+        );
       }
     }
     runtimeConfig.oauth = defu(runtimeConfig.oauth, {});
@@ -106,6 +110,26 @@ const module = defineNuxtModule({
       clientId: "",
       clientSecret: ""
     });
+    runtimeConfig.oauth.paypal = defu(runtimeConfig.oauth.paypal, {
+      clientId: "",
+      clientSecret: ""
+    });
+    runtimeConfig.oauth.steam = defu(runtimeConfig.oauth.steam, {
+      apiKey: ""
+    });
+    runtimeConfig.oauth.x = defu(runtimeConfig.oauth.x, {
+      clientId: "",
+      clientSecret: ""
+    });
+    runtimeConfig.oauth.xsuaa = defu(runtimeConfig.oauth.xsuaa, {
+      clientId: "",
+      clientSecret: "",
+      domain: ""
+    });
+    runtimeConfig.oauth.yandex = defu(runtimeConfig.oauth.yandex, {
+      clientId: "",
+      clientSecret: ""
+    });
   }
 });
 

package/dist/runtime/app/components/AuthState.vue

@@ -1,14 +1,13 @@
-<script setup>
+<script lang="ts" setup>
 import { useUserSession } from '#imports'
 
-const userSession = useUserSession()
-const { ready } = userSession
+const { loggedIn, user, clear, ready } = useUserSession()
 </script>
 
 <template>
   <slot
     v-if="ready"
-    v-bind="userSession"
+    v-bind="{ loggedIn, user, clear }"
   />
   <slot
     v-else

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

@@ -1,6 +1,5 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parsePath } from "ufo";
-import { ofetch } from "ofetch";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
 export function auth0EventHandler({ config, onSuccess, onError }) {
@@ -40,7 +39,7 @@ export function auth0EventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const tokens = await ofetch(
+    const tokens = await $fetch(
       tokenURL,
       {
         method: "POST",
@@ -70,7 +69,7 @@ export function auth0EventHandler({ config, onSuccess, onError }) {
     }
     const tokenType = tokens.token_type;
     const accessToken = tokens.access_token;
-    const user = await ofetch(`https://${config.domain}/userinfo`, {
+    const user = await $fetch(`https://${config.domain}/userinfo`, {
       headers: {
         Authorization: `${tokenType} ${accessToken}`
       }

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

@@ -1,6 +1,5 @@
 import { randomUUID } from "node:crypto";
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
-import { ofetch } from "ofetch";
 import { withQuery, parsePath } from "ufo";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
@@ -88,7 +87,7 @@ export function battledotnetEventHandler({ config, onSuccess, onError }) {
       return onError(event, error);
     }
     const accessToken = tokens.access_token;
-    const user = await ofetch("https://oauth.battle.net/userinfo", {
+    const user = await $fetch("https://oauth.battle.net/userinfo", {
       headers: {
         "User-Agent": `Battledotnet-OAuth-${config.clientId}`,
         "Authorization": `Bearer ${accessToken}`

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

@@ -1,6 +1,5 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parsePath } from "ufo";
-import { ofetch } from "ofetch";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
 export function cognitoEventHandler({ config, onSuccess, onError }) {
@@ -34,7 +33,7 @@ export function cognitoEventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const tokens = await ofetch(
+    const tokens = await $fetch(
       tokenURL,
       {
         method: "POST",
@@ -58,7 +57,7 @@ export function cognitoEventHandler({ config, onSuccess, onError }) {
     }
     const tokenType = tokens.token_type;
     const accessToken = tokens.access_token;
-    const user = await ofetch(`https://${config.userPoolId}.auth.${config.region}.amazoncognito.com/oauth2/userInfo`, {
+    const user = await $fetch(`https://${config.userPoolId}.auth.${config.region}.amazoncognito.com/oauth2/userInfo`, {
       headers: {
         Authorization: `${tokenType} ${accessToken}`
       }

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

@@ -1,6 +1,5 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parseURL, stringifyParsedURL } from "ufo";
-import { ofetch } from "ofetch";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
 export function discordEventHandler({ config, onSuccess, onError }) {
@@ -43,7 +42,7 @@ export function discordEventHandler({ config, onSuccess, onError }) {
     }
     const parsedRedirectUrl = parseURL(redirectUrl);
     parsedRedirectUrl.search = "";
-    const tokens = await ofetch(
+    const tokens = await $fetch(
       config.tokenURL,
       {
         method: "POST",
@@ -72,7 +71,7 @@ export function discordEventHandler({ config, onSuccess, onError }) {
       return onError(event, error);
     }
     const accessToken = tokens.access_token;
-    const user = await ofetch("https://discord.com/api/users/@me", {
+    const user = await $fetch("https://discord.com/api/users/@me", {
       headers: {
         "user-agent": "Nuxt Auth Utils",
         "Authorization": `Bearer ${accessToken}`

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

@@ -5,7 +5,6 @@ import {
   getRequestURL,
   sendRedirect
 } from "h3";
-import { ofetch } from "ofetch";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
@@ -74,7 +73,7 @@ export function facebookEventHandler({
     const accessToken = tokens.access_token;
     config.fields = config.fields || ["id", "name"];
     const fields = config.fields.join(",");
-    const user = await ofetch(
+    const user = await $fetch(
       `https://graph.facebook.com/v19.0/me?fields=${fields}&access_token=${accessToken}`
     );
     if (!user) {

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

@@ -1,5 +1,4 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
-import { ofetch } from "ofetch";
 import { withQuery } from "ufo";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
@@ -68,14 +67,14 @@ export function githubEventHandler({ config, onSuccess, onError }) {
       return onError(event, error);
     }
     const accessToken = tokens.access_token;
-    const user = await ofetch("https://api.github.com/user", {
+    const user = await $fetch("https://api.github.com/user", {
       headers: {
         "User-Agent": `Github-OAuth-${config.clientId}`,
         "Authorization": `token ${accessToken}`
       }
     });
     if (!user.email && config.emailRequired) {
-      const emails = await ofetch("https://api.github.com/user/emails", {
+      const emails = await $fetch("https://api.github.com/user/emails", {
         headers: {
           "User-Agent": `Github-OAuth-${config.clientId}`,
           "Authorization": `token ${accessToken}`

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

@@ -6,7 +6,6 @@ import {
   sendRedirect
 } from "h3";
 import { withQuery, parsePath } from "ufo";
-import { ofetch } from "ofetch";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
 export function googleEventHandler({
@@ -52,7 +51,7 @@ export function googleEventHandler({
       client_secret: config.clientSecret,
       code
     };
-    const tokens = await ofetch(config.tokenURL, {
+    const tokens = await $fetch(config.tokenURL, {
       method: "POST",
       body
     }).catch((error) => {
@@ -69,7 +68,7 @@ export function googleEventHandler({
       return onError(event, error);
     }
     const accessToken = tokens.access_token;
-    const user = await ofetch(
+    const user = await $fetch(
       config.userURL,
       {
         headers: {

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

@@ -5,7 +5,6 @@ import {
   getRequestURL,
   sendRedirect
 } from "h3";
-import { ofetch } from "ofetch";
 import { withQuery, parsePath } from "ufo";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
@@ -60,7 +59,7 @@ export function keycloakEventHandler({
     if (!config.scope.includes("openid")) {
       config.scope.push("openid");
     }
-    const tokens = await ofetch(tokenURL, {
+    const tokens = await $fetch(tokenURL, {
       method: "POST",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
@@ -86,7 +85,7 @@ export function keycloakEventHandler({
       return onError(event, error);
     }
     const accessToken = tokens.access_token;
-    const user = await ofetch(
+    const user = await $fetch(
       `${realmURL}/protocol/openid-connect/userinfo`,
       {
         headers: {

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

@@ -1,6 +1,5 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parseURL, stringifyParsedURL } from "ufo";
-import { ofetch } from "ofetch";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
 export function linkedinEventHandler({ config, onSuccess, onError }) {
@@ -42,7 +41,7 @@ export function linkedinEventHandler({ config, onSuccess, onError }) {
     }
     const parsedRedirectUrl = parseURL(redirectUrl);
     parsedRedirectUrl.search = "";
-    const tokens = await ofetch(
+    const tokens = await $fetch(
       config.tokenURL,
       {
         method: "POST",
@@ -71,7 +70,7 @@ export function linkedinEventHandler({ config, onSuccess, onError }) {
       return onError(event, error);
     }
     const accessToken = tokens.access_token;
-    const user = await ofetch("https://api.linkedin.com/v2/userinfo", {
+    const user = await $fetch("https://api.linkedin.com/v2/userinfo", {
       headers: {
         "user-agent": "Nuxt Auth Utils",
         "Authorization": `Bearer ${accessToken}`

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

@@ -1,6 +1,5 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parsePath } from "ufo";
-import { ofetch } from "ofetch";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
 export function microsoftEventHandler({ config, onSuccess, onError }) {
@@ -40,7 +39,7 @@ export function microsoftEventHandler({ config, onSuccess, onError }) {
     data.append("client_secret", config.clientSecret);
     data.append("redirect_uri", parsePath(redirectUrl).pathname);
     data.append("code", String(code));
-    const tokens = await ofetch(
+    const tokens = await $fetch(
       tokenURL,
       {
         method: "POST",
@@ -65,7 +64,7 @@ export function microsoftEventHandler({ config, onSuccess, onError }) {
     const tokenType = tokens.token_type;
     const accessToken = tokens.access_token;
     const userURL = config.userURL || "https://graph.microsoft.com/v1.0/me";
-    const user = await ofetch(userURL, {
+    const user = await $fetch(userURL, {
       headers: {
         Authorization: `${tokenType} ${accessToken}`
       }

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

@@ -0,0 +1,47 @@
+import type { OAuthConfig } from '#auth-utils';
+export interface OAuthPaypalConfig {
+    /**
+     * PayPal Client ID
+     * @default process.env.NUXT_OAUTH_PAYPAL_CLIENT_ID
+     */
+    clientId?: string;
+    /**
+     * PayPal OAuth Client Secret
+     * @default process.env.NUXT_OAUTH_PAYPAL_CLIENT_SECRET
+     */
+    clientSecret?: string;
+    /**
+     * PayPal OAuth Scope
+     * @default []
+     * @see https://developer.paypal.com/docs/log-in-with-paypal/integrate/reference/#scope-attributes
+     * @example ['email', 'profile']
+     */
+    scope?: string[];
+    /**
+     * Require email from user, adds the ['email'] scope if not present
+     * @default false
+     */
+    emailRequired?: boolean;
+    /**
+     * Use PayPal sandbox environment
+     * @default import.meta.dev // true in development, false in production
+     */
+    sandbox?: boolean;
+    /**
+     * PayPal OAuth Authorization URL
+     * @default 'https://www.paypal.com/signin/authorize'
+     */
+    authorizationURL?: string;
+    /**
+     * PayPal OAuth Token URL
+     * @default 'https://api-m.paypal.com/v1/oauth2/token'
+     */
+    tokenURL?: string;
+    /**
+     * Extra authorization parameters to provide to the authorization URL
+     * @see https://developer.paypal.com/docs/log-in-with-paypal/integrate/build-button/#link-constructauthorizationendpoint
+     * @example { flowEntry: 'static' }
+     */
+    authorizationParams?: Record<string, string>;
+}
+export declare function paypalEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthPaypalConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -0,0 +1,104 @@
+import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
+import { withQuery, parsePath } from "ufo";
+import { defu } from "defu";
+import { useRuntimeConfig } from "#imports";
+export function paypalEventHandler({ config, onSuccess, onError }) {
+  return eventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig(event).oauth?.paypal, {
+      sandbox: import.meta.dev,
+      authorizationURL: "https://www.paypal.com/signin/authorize",
+      tokenURL: "https://api-m.paypal.com/v1/oauth2/token",
+      authorizationParams: {}
+    });
+    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);
+    }
+    let paypalAPI = "api-m.paypal.com";
+    if (config.sandbox) {
+      paypalAPI = "api-m.sandbox.paypal.com";
+      config.authorizationURL = "https://www.sandbox.paypal.com/signin/authorize";
+      config.tokenURL = `https://${paypalAPI}/v1/oauth2/token`;
+    }
+    const redirectUrl = getRequestURL(event).href;
+    if (!code) {
+      config.scope = config.scope || [];
+      if (!config.scope.includes("openid")) {
+        config.scope.push("openid");
+      }
+      if (config.emailRequired && !config.scope.includes("email")) {
+        config.scope.push("email");
+      }
+      return sendRedirect(
+        event,
+        withQuery(config.authorizationURL, {
+          response_type: "code",
+          client_id: config.clientId,
+          redirect_uri: redirectUrl,
+          scope: config.scope.join(" "),
+          flowEntry: "static",
+          ...config.authorizationParams
+        })
+      );
+    }
+    const authCode = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64");
+    const tokens = await $fetch(
+      config.tokenURL,
+      {
+        method: "POST",
+        headers: {
+          "Authorization": `Basic ${authCode}`,
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        params: {
+          grant_type: "authorization_code",
+          redirect_uri: encodeURIComponent(parsePath(redirectUrl).pathname),
+          code
+        }
+      }
+    ).catch((error) => {
+      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);
+    }
+    const accessToken = tokens.access_token;
+    const users = await $fetch(`https://${paypalAPI}/v1/identity/openidconnect/userinfo`, {
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      params: {
+        schema: "openid"
+      }
+    });
+    const user = users;
+    if (!user) {
+      const error = createError({
+        statusCode: 500,
+        message: "Could not get PayPal user",
+        data: tokens
+      });
+      if (!onError)
+        throw error;
+      return onError(event, error);
+    }
+    return onSuccess(event, {
+      tokens,
+      user
+    });
+  });
+}

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

@@ -1,6 +1,5 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parsePath } from "ufo";
-import { ofetch } from "ofetch";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
 export function spotifyEventHandler({ config, onSuccess, onError }) {
@@ -38,7 +37,7 @@ export function spotifyEventHandler({ config, onSuccess, onError }) {
       );
     }
     const authCode = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64");
-    const tokens = await ofetch(
+    const tokens = await $fetch(
       config.tokenURL,
       {
         method: "POST",
@@ -66,7 +65,7 @@ export function spotifyEventHandler({ config, onSuccess, onError }) {
       return onError(event, error);
     }
     const accessToken = tokens.access_token;
-    const user = await ofetch("https://api.spotify.com/v1/me", {
+    const user = await $fetch("https://api.spotify.com/v1/me", {
       headers: {
         Authorization: `Bearer ${accessToken}`
       }

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

@@ -0,0 +1,15 @@
+import type { OAuthConfig } from '#auth-utils';
+export interface OAuthSteamConfig {
+    /**
+     * Steam API Key
+     * @default process.env.NUXT_OAUTH_STEAM_API_KEY
+     * @see https://steamcommunity.com/dev
+     */
+    apiKey?: string;
+    /**
+     * Steam Open ID OAuth Authorization URL
+     * @default 'https://steamcommunity.com/openid/login'
+     */
+    authorizationURL?: string;
+}
+export declare function steamEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthSteamConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -0,0 +1,54 @@
+import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
+import { withQuery } from "ufo";
+import { defu } from "defu";
+import { useRuntimeConfig } from "#imports";
+export function steamEventHandler({ config, onSuccess, onError }) {
+  return eventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig(event).oauth?.steam, {
+      authorizationURL: "https://steamcommunity.com/openid/login"
+    });
+    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);
+    }
+    if (!query["openid.claimed_id"]) {
+      const redirectUrl = getRequestURL(event).href;
+      const steamOpenIdParams = {
+        "openid.ns": "http://specs.openid.net/auth/2.0",
+        "openid.mode": "checkid_setup",
+        "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"
+      };
+      return sendRedirect(event, withQuery(config.authorizationURL, steamOpenIdParams));
+    }
+    const validateAuth = await $fetch(withQuery(config.authorizationURL, {
+      ...query,
+      "openid.mode": "check_authentication"
+    }));
+    if (!validateAuth.includes("is_valid:true")) {
+      const error = createError({
+        statusCode: 401,
+        message: "Steam login failed: Unknown error"
+      });
+      if (!onError)
+        throw error;
+      return onError(event, error);
+    }
+    const steamId = query["openid.claimed_id"].split("/").pop();
+    const user = await $fetch(withQuery("https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v2/", {
+      key: config.apiKey,
+      steamids: steamId
+    }));
+    return onSuccess(event, {
+      user: user.response.players[0],
+      tokens: null
+    });
+  });
+}

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

@@ -1,6 +1,5 @@
 import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
 import { withQuery, parsePath } from "ufo";
-import { ofetch } from "ofetch";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
 export function twitchEventHandler({ config, onSuccess, onError }) {
@@ -37,7 +36,7 @@ export function twitchEventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const tokens = await ofetch(
+    const tokens = await $fetch(
       config.tokenURL,
       {
         method: "POST",
@@ -66,7 +65,7 @@ export function twitchEventHandler({ config, onSuccess, onError }) {
       return onError(event, error);
     }
     const accessToken = tokens.access_token;
-    const users = await ofetch("https://api.twitch.tv/helix/users", {
+    const users = await $fetch("https://api.twitch.tv/helix/users", {
       headers: {
         "Client-ID": config.clientId,
         "Authorization": `Bearer ${accessToken}`

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

@@ -0,0 +1,46 @@
+import type { OAuthConfig } from '#auth-utils';
+export interface OAuthXConfig {
+    /**
+     * X OAuth Client ID
+     * @default process.env.NUXT_OAUTH_X_CLIENT_ID
+     */
+    clientId?: string;
+    /**
+     * X OAuth Client Secret
+     * @default process.env.NUXT_OAUTH_X_CLIENT_SECRET
+     */
+    clientSecret?: string;
+    /**
+     * X OAuth Scope
+     * @default []
+     * @see https://developer.x.com/en/docs/authentication/oauth-2-0/user-access-token
+     * @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'
+     */
+    authorizationURL?: string;
+    /**
+     * X OAuth Token URL
+     * @default 'https://api.twitter.com/2/oauth2/token'
+     */
+    tokenURL?: string;
+    /**
+     * X OAuth User URL
+     * @default 'https://api.twitter.com/2/users/me'
+     */
+    userURL?: string;
+    /**
+     * 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>;
+}
+export declare function xEventHandler({ config, onSuccess, onError, }: OAuthConfig<OAuthXConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -0,0 +1,122 @@
+import { randomUUID } from "node:crypto";
+import {
+  eventHandler,
+  createError,
+  getQuery,
+  getRequestURL,
+  sendRedirect
+} from "h3";
+import { withQuery, parsePath } from "ufo";
+import { defu } from "defu";
+import { useRuntimeConfig } from "#imports";
+export function xEventHandler({
+  config,
+  onSuccess,
+  onError
+}) {
+  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",
+      authorizationParams: {
+        state: randomUUID(),
+        code_challenge: randomUUID()
+      }
+    });
+    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);
+    }
+    const redirectUrl = getRequestURL(event).href;
+    if (!code) {
+      config.scope = config.scope || ["tweet.read", "users.read", "offline.access"];
+      return sendRedirect(
+        event,
+        withQuery(config.authorizationURL, {
+          response_type: "code",
+          client_id: config.clientId,
+          code_challenge_method: "plain",
+          redirect_uri: redirectUrl,
+          scope: config.scope.join(" "),
+          ...config.authorizationParams
+        })
+      );
+    }
+    const params = {
+      grant_type: "authorization_code",
+      code_verifier: config.authorizationParams.code_challenge,
+      redirect_uri: parsePath(redirectUrl).pathname,
+      code
+    };
+    const authCode = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64");
+    const tokens = await $fetch(config.tokenURL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Authorization": `Basic ${authCode}`
+      },
+      params
+    }).catch((error) => {
+      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);
+    }
+    const accessToken = tokens.access_token;
+    const user = await $fetch(
+      config.userURL,
+      {
+        headers: {
+          Authorization: `Bearer ${accessToken}`
+        },
+        query: {
+          "user.fields": "description,id,name,profile_image_url,username,verified,verified_type"
+        }
+      }
+    ).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.d.ts

@@ -0,0 +1,26 @@
+import type { OAuthConfig } from '#auth-utils';
+export interface OAuthXSUAAConfig {
+    /**
+     * XSUAA OAuth Client ID
+     * @default process.env.NUXT_OAUTH_XSUAA_CLIENT_ID
+     */
+    clientId?: string;
+    /**
+     * XSUAA OAuth Client Secret
+     * @default process.env.NUXT_OAUTH_XSUAA_CLIENT_SECRET
+     */
+    clientSecret?: string;
+    /**
+     * XSUAA OAuth Issuer
+     * @default process.env.NUXT_OAUTH_XSUAA_DOMAIN
+     */
+    domain?: string;
+    /**
+     * XSUAA OAuth Scope
+     * @default []
+     * @see https://sap.github.io/cloud-sdk/docs/java/guides/cloud-foundry-xsuaa-service
+     * @example ['openid']
+     */
+    scope?: string[];
+}
+export declare function xsuaaEventHandler({ config, onSuccess, onError }: OAuthConfig<OAuthXSUAAConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -0,0 +1,73 @@
+import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
+import { withQuery, parsePath } from "ufo";
+import { defu } from "defu";
+import { useRuntimeConfig } from "#imports";
+export function xsuaaEventHandler({ 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);
+    }
+    const authorizationURL = `https://${config.domain}/oauth/authorize`;
+    const tokenURL = `https://${config.domain}/oauth/token`;
+    const redirectUrl = getRequestURL(event).href;
+    if (!code) {
+      config.scope = config.scope || [];
+      return sendRedirect(
+        event,
+        withQuery(authorizationURL, {
+          response_type: "code",
+          client_id: config.clientId,
+          redirect_uri: redirectUrl,
+          scope: config.scope.join(" ")
+        })
+      );
+    }
+    const tokens = await $fetch(
+      tokenURL,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: new URLSearchParams({
+          grant_type: "authorization_code",
+          client_id: config.clientId,
+          client_secret: config.clientSecret,
+          redirect_uri: parsePath(redirectUrl).pathname,
+          code: `${code}`
+        })
+      }
+    ).catch((error) => {
+      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);
+    }
+    const tokenType = tokens.token_type;
+    const accessToken = tokens.access_token;
+    const user = await $fetch(`https://${config.domain}/userinfo`, {
+      headers: {
+        Authorization: `${tokenType} ${accessToken}`
+      }
+    });
+    return onSuccess(event, {
+      tokens,
+      user
+    });
+  });
+}

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

@@ -0,0 +1,41 @@
+import type { OAuthConfig } from '#auth-utils';
+export interface OAuthYandexConfig {
+    /**
+     * Yandex OAuth Client ID
+     * @default process.env.NUXT_OAUTH_YANDEX_CLIENT_ID
+     */
+    clientId?: string;
+    /**
+     * Yandex OAuth Client Secret
+     * @default process.env.NUXT_OAUTH_YANDEX_CLIENT_SECRET
+     */
+    clientSecret?: string;
+    /**
+     * Yandex OAuth Scope
+     * @default []
+     * @see https://yandex.ru/dev/id/doc/en/codes/code-url#optional
+     * @example ["login:avatar", "login:birthday", "login:email", "login:info", "login:default_phone"]
+     */
+    scope?: string[];
+    /**
+     * Require email from user, adds the ['login:email'] scope if not present
+     * @default false
+     */
+    emailRequired?: boolean;
+    /**
+     * Yandex OAuth Authorization URL
+     * @default 'https://oauth.yandex.ru/authorize'
+     */
+    authorizationURL?: string;
+    /**
+     * Yandex OAuth Token URL
+     * @default 'https://oauth.yandex.ru/token'
+     */
+    tokenURL?: string;
+    /**
+     * Yandex OAuth User URL
+     * @default 'https://login.yandex.ru/info'
+     */
+    userURL?: string;
+}
+export declare function yandexEventHandler({ config, onSuccess, onError, }: OAuthConfig<OAuthYandexConfig>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;

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

@@ -0,0 +1,84 @@
+import {
+  eventHandler,
+  createError,
+  getQuery,
+  getRequestURL,
+  sendRedirect
+} from "h3";
+import { withQuery, parseURL, stringifyParsedURL } from "ufo";
+import { defu } from "defu";
+import { useRuntimeConfig } from "#imports";
+export function yandexEventHandler({
+  config,
+  onSuccess,
+  onError
+}) {
+  return eventHandler(async (event) => {
+    config = defu(config, useRuntimeConfig(event).oauth?.yandex, {
+      authorizationURL: "https://oauth.yandex.ru/authorize",
+      tokenURL: "https://oauth.yandex.ru/token",
+      userURL: "https://login.yandex.ru/info"
+    });
+    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);
+    }
+    const redirectUrl = getRequestURL(event).href;
+    if (!code) {
+      config.scope = config.scope || [];
+      if (config.emailRequired && !config.scope.includes("login:email")) {
+        config.scope.push("login:email");
+      }
+      return sendRedirect(
+        event,
+        withQuery(config.authorizationURL, {
+          response_type: "code",
+          client_id: config.clientId,
+          redirect_uri: redirectUrl,
+          scope: config.scope.join(" ")
+        })
+      );
+    }
+    const tokens = await $fetch(config.tokenURL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        grant_type: "authorization_code",
+        redirect_uri: stringifyParsedURL(parseURL(redirectUrl)),
+        code
+      }).toString()
+    }).catch((error) => {
+      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);
+    }
+    const accessToken = tokens.access_token;
+    const user = await $fetch(config.userURL, {
+      headers: {
+        Authorization: `OAuth ${accessToken}`
+      }
+    });
+    return onSuccess(event, {
+      tokens,
+      user
+    });
+  });
+}

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

@@ -10,6 +10,11 @@ import { keycloakEventHandler } from '../lib/oauth/keycloak.js';
 import { linkedinEventHandler } from '../lib/oauth/linkedin.js';
 import { cognitoEventHandler } from '../lib/oauth/cognito.js';
 import { facebookEventHandler } from '../lib/oauth/facebook.js';
+import { paypalEventHandler } from '../lib/oauth/paypal.js';
+import { steamEventHandler } from '../lib/oauth/steam.js';
+import { xEventHandler } from '../lib/oauth/x.js';
+import { xsuaaEventHandler } from '../lib/oauth/xsuaa.js';
+import { yandexEventHandler } from '../lib/oauth/yandex.js';
 export declare const oauth: {
     githubEventHandler: typeof githubEventHandler;
     spotifyEventHandler: typeof spotifyEventHandler;
@@ -23,4 +28,9 @@ export declare const oauth: {
     linkedinEventHandler: typeof linkedinEventHandler;
     cognitoEventHandler: typeof cognitoEventHandler;
     facebookEventHandler: typeof facebookEventHandler;
+    paypalEventHandler: typeof paypalEventHandler;
+    steamEventHandler: typeof steamEventHandler;
+    xEventHandler: typeof xEventHandler;
+    xsuaaEventHandler: typeof xsuaaEventHandler;
+    yandexEventHandler: typeof yandexEventHandler;
 };

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

@@ -10,6 +10,11 @@ import { keycloakEventHandler } from "../lib/oauth/keycloak.js";
 import { linkedinEventHandler } from "../lib/oauth/linkedin.js";
 import { cognitoEventHandler } from "../lib/oauth/cognito.js";
 import { facebookEventHandler } from "../lib/oauth/facebook.js";
+import { paypalEventHandler } from "../lib/oauth/paypal.js";
+import { steamEventHandler } from "../lib/oauth/steam.js";
+import { xEventHandler } from "../lib/oauth/x.js";
+import { xsuaaEventHandler } from "../lib/oauth/xsuaa.js";
+import { yandexEventHandler } from "../lib/oauth/yandex.js";
 export const oauth = {
   githubEventHandler,
   spotifyEventHandler,
@@ -22,5 +27,10 @@ export const oauth = {
   keycloakEventHandler,
   linkedinEventHandler,
   cognitoEventHandler,
-  facebookEventHandler
+  facebookEventHandler,
+  paypalEventHandler,
+  steamEventHandler,
+  xEventHandler,
+  xsuaaEventHandler,
+  yandexEventHandler
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-auth-utils",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Minimalist Auth module for Nuxt with SSR",
   "repository": "Atinux/nuxt-auth-utils",
   "license": "MIT",
@@ -25,6 +25,7 @@
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
     "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
     "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "test": "vitest run",
     "test:types": "vue-tsc --noEmit",
     "test:types:playground": "cd playground && vue-tsc --noEmit",