nuxt-auth-utils 0.0.25 → 0.2.0

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.mjs → 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.mjs → 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,41 @@
+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[];
+    /**
+     * 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,98 @@
+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;
+    });
+    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/utils/oauth.d.ts

@@ -1,15 +1,19 @@
-import { githubEventHandler } from '../lib/oauth/github';
-import { googleEventHandler } from '../lib/oauth/google';
-import { spotifyEventHandler } from '../lib/oauth/spotify';
-import { twitchEventHandler } from '../lib/oauth/twitch';
-import { auth0EventHandler } from '../lib/oauth/auth0';
-import { microsoftEventHandler } from '../lib/oauth/microsoft';
-import { discordEventHandler } from '../lib/oauth/discord';
-import { battledotnetEventHandler } from '../lib/oauth/battledotnet';
-import { keycloakEventHandler } from '../lib/oauth/keycloak';
-import { linkedinEventHandler } from '../lib/oauth/linkedin';
-import { cognitoEventHandler } from '../lib/oauth/cognito';
-import { facebookEventHandler } from '../lib/oauth/facebook';
+import { githubEventHandler } from '../lib/oauth/github.js';
+import { googleEventHandler } from '../lib/oauth/google.js';
+import { spotifyEventHandler } from '../lib/oauth/spotify.js';
+import { twitchEventHandler } from '../lib/oauth/twitch.js';
+import { auth0EventHandler } from '../lib/oauth/auth0.js';
+import { microsoftEventHandler } from '../lib/oauth/microsoft.js';
+import { discordEventHandler } from '../lib/oauth/discord.js';
+import { battledotnetEventHandler } from '../lib/oauth/battledotnet.js';
+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';
 export declare const oauth: {
     githubEventHandler: typeof githubEventHandler;
     spotifyEventHandler: typeof spotifyEventHandler;
@@ -23,4 +27,8 @@ 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;
 };

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

@@ -0,0 +1,34 @@
+import { githubEventHandler } from "../lib/oauth/github.js";
+import { googleEventHandler } from "../lib/oauth/google.js";
+import { spotifyEventHandler } from "../lib/oauth/spotify.js";
+import { twitchEventHandler } from "../lib/oauth/twitch.js";
+import { auth0EventHandler } from "../lib/oauth/auth0.js";
+import { microsoftEventHandler } from "../lib/oauth/microsoft.js";
+import { discordEventHandler } from "../lib/oauth/discord.js";
+import { battledotnetEventHandler } from "../lib/oauth/battledotnet.js";
+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";
+export const oauth = {
+  githubEventHandler,
+  spotifyEventHandler,
+  googleEventHandler,
+  twitchEventHandler,
+  auth0EventHandler,
+  microsoftEventHandler,
+  discordEventHandler,
+  battledotnetEventHandler,
+  keycloakEventHandler,
+  linkedinEventHandler,
+  cognitoEventHandler,
+  facebookEventHandler,
+  paypalEventHandler,
+  steamEventHandler,
+  xEventHandler,
+  xsuaaEventHandler
+};

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

@@ -13,26 +13,38 @@ export interface SessionHooks {
     clear: (session: UserSession, event: H3Event) => void | Promise<void>;
 }
 export declare const sessionHooks: import("hookable").Hookable<SessionHooks, import("hookable").HookKeys<SessionHooks>>;
+/**
+ * Get the user session from the current request
+ * @param event The Request (h3) event
+ * @returns The user session
+ */
 export declare function getUserSession(event: H3Event): Promise<UserSession>;
 /**
  * Set a user session
- * @param event
+ * @param event The Request (h3) event
  * @param data User session data, please only store public information since it can be decoded with API calls
+ * @see https://github.com/atinux/nuxt-auth-utils
  */
 export declare function setUserSession(event: H3Event, data: UserSession): Promise<UserSession>;
 /**
  * Replace a user session
- * @param event
+ * @param event The Request (h3) event
  * @param data User session data, please only store public information since it can be decoded with API calls
  */
 export declare function replaceUserSession(event: H3Event, data: UserSession): Promise<UserSession>;
+/**
+ * Clear the user session and removing the session cookie
+ * @param event The Request (h3) event
+ * @returns true if the session was cleared
+ */
 export declare function clearUserSession(event: H3Event): Promise<boolean>;
 /**
- * Require a user session
+ * Require a user session, throw a 401 error if the user is not logged in
  * @param event
  * @param opts Options to customize the error message and status code
  * @param opts.statusCode The status code to use for the error (defaults to 401)
  * @param opts.message The message to use for the error (defaults to Unauthorized)
+ * @see https://github.com/atinux/nuxt-auth-utils
  */
 export declare function requireUserSession(event: H3Event, opts?: {
     statusCode?: number;

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

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

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

@@ -8,9 +8,28 @@ export interface UserSessionRequired extends UserSession {
     user: User;
 }
 export interface UserSessionComposable {
+    /**
+     * Computed indicating if the auth session is ready
+     */
+    ready: ComputedRef<boolean>;
+    /**
+     * Computed indicating if the user is logged in.
+     */
     loggedIn: ComputedRef<boolean>;
+    /**
+     * The user object if logged in, null otherwise.
+     */
     user: ComputedRef<User | null>;
+    /**
+     * The session object.
+     */
     session: Ref<UserSession>;
+    /**
+     * Fetch the user session from the server.
+     */
     fetch: () => Promise<void>;
+    /**
+     * Clear the user session and remove the session cookie.
+     */
     clear: () => Promise<void>;
 }

package/dist/types.d.mts

@@ -2,6 +2,7 @@
 import type { ModuleOptions } from './module.js'
 
 
+
 declare module '@nuxt/schema' {
   interface NuxtConfig { ['auth']?: Partial<ModuleOptions> }
   interface NuxtOptions { ['auth']?: ModuleOptions }

package/dist/types.d.ts

@@ -2,6 +2,7 @@
 import type { ModuleOptions } from './module'
 
 
+
 declare module '@nuxt/schema' {
   interface NuxtConfig { ['auth']?: Partial<ModuleOptions> }
   interface NuxtOptions { ['auth']?: ModuleOptions }