nuxt-auth-utils 0.3.4 → 0.3.6

package/README.md

@@ -199,6 +199,7 @@ It can also be set using environment variables:
 - PayPal
 - Spotify
 - Steam
+- TikTok
 - Twitch
 - X (Twitter)
 - XSUAA
@@ -250,7 +251,7 @@ export default defineNitroPlugin(() => {
     // throw createError({ ... }) if session is invalid for example
   })
 
-  // Called when we call useServerSession().clear() or clearUserSession(event)
+  // Called when we call useUserSession().clear() or clearUserSession(event)
   sessionHooks.hook('clear', async (session, event) => {
     // Log that user logged out
   })

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.6",
   "builder": {
-    "@nuxt/module-builder": "0.8.1",
+    "@nuxt/module-builder": "0.8.3",
     "unbuild": "2.0.0"
   }
 }

package/dist/module.mjs

@@ -149,6 +149,11 @@ const module = defineNuxtModule({
       clientSecret: "",
       redirectURL: ""
     });
+    runtimeConfig.oauth.tiktok = defu(runtimeConfig.oauth.tiktok, {
+      clientKey: "",
+      clientSecret: "",
+      redirectURL: ""
+    });
   }
 });
 

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,25 +1,21 @@
-import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
-import { withQuery, parsePath } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthAuth0EventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
     config = defu(config, useRuntimeConfig(event).oauth?.auth0, {
       authorizationParams: {}
     });
-    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`;
-    const redirectURL = config.redirectURL || getRequestURL(event).href;
-    if (!code) {
+    const query = getQuery(event);
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || ["openid", "offline_access"];
       if (config.emailRequired && !config.scope.includes("email")) {
         config.scope.push("email");
@@ -38,32 +34,20 @@ export function oauthAuth0EventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const tokens = await $fetch(
-      tokenURL,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: {
-          grant_type: "authorization_code",
-          client_id: config.clientId,
-          client_secret: config.clientSecret,
-          redirect_uri: parsePath(redirectURL).pathname,
-          code
-        }
+    const tokens = await requestAccessToken(tokenURL, {
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: {
+        grant_type: "authorization_code",
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        redirect_uri: redirectURL,
+        code: query.code
       }
-    ).catch((error) => {
-      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

@@ -1,8 +1,9 @@
-import { randomUUID } from "node:crypto";
-import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
-import { withQuery, parsePath } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
-import { useRuntimeConfig } from "#imports";
+import { randomUUID } from "uncrypto";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
+import { useRuntimeConfig, createError } from "#imports";
 export function oauthBattledotnetEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
     config = defu(config, useRuntimeConfig(event).oauth?.battledotnet, {
@@ -11,7 +12,6 @@ export function oauthBattledotnetEventHandler({ config, onSuccess, onError }) {
       authorizationParams: {}
     });
     const query = getQuery(event);
-    const { code } = query;
     if (query.error) {
       const error = createError({
         statusCode: 401,
@@ -22,15 +22,15 @@ 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) {
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || ["openid"];
       config.region = config.region || "EU";
       if (config.region === "CN") {
@@ -54,33 +54,19 @@ export function oauthBattledotnetEventHandler({ config, onSuccess, onError }) {
     if (!config.scope.includes("openid")) {
       config.scope.push("openid");
     }
-    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: {
-          code,
-          grant_type: "authorization_code",
-          scope: config.scope.join(" "),
-          redirect_uri: parsePath(redirectURL).pathname
-        }
+    const tokens = await requestAccessToken(config.tokenURL, {
+      headers: {
+        Authorization: `Basic ${Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64")}`
+      },
+      params: {
+        grant_type: "authorization_code",
+        scope: config.scope.join(" "),
+        redirect_uri: redirectURL,
+        code: query.code
       }
-    ).catch((error) => {
-      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,25 +1,22 @@
-import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
-import { withQuery, parsePath } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthCognitoEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
     config = defu(config, useRuntimeConfig(event).oauth?.cognito, {
       authorizationParams: {}
     });
-    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 redirectURL = config.redirectURL || getRequestURL(event).href;
-    if (!code) {
+    const urlBase = config?.domain || `${config.userPoolId}.auth.${config.region}.amazoncognito.com`;
+    const authorizationURL = `https://${urlBase}/oauth2/authorize`;
+    const tokenURL = `https://${urlBase}/oauth2/token`;
+    const query = getQuery(event);
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || ["openid", "profile"];
       return sendRedirect(
         event,
@@ -32,30 +29,24 @@ export function oauthCognitoEventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const tokens = await $fetch(
+    const tokens = await requestAccessToken(
       tokenURL,
       {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        body: `grant_type=authorization_code&client_id=${config.clientId}&client_secret=${config.clientSecret}&redirect_uri=${parsePath(redirectURL).pathname}&code=${code}`
+        body: {
+          grant_type: "authorization_code",
+          client_id: config.clientId,
+          client_secret: config.clientSecret,
+          redirect_uri: redirectURL,
+          code: query.code
+        }
       }
-    ).catch((error) => {
-      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 { withQuery, parseURL, stringifyParsedURL } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthDiscordEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
@@ -10,17 +11,12 @@ export function oauthDiscordEventHandler({ config, onSuccess, onError }) {
       profileRequired: true,
       authorizationParams: {}
     });
-    const { code } = getQuery(event);
+    const query = 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) {
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || [];
       if (config.emailRequired && !config.scope.includes("email")) {
         config.scope.push("email");
@@ -39,34 +35,17 @@ export function oauthDiscordEventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const parsedRedirectUrl = parseURL(redirectURL);
-    parsedRedirectUrl.search = "";
-    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(parsedRedirectUrl),
-          code
-        }).toString()
+    const tokens = await requestAccessToken(config.tokenURL, {
+      body: {
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        grant_type: "authorization_code",
+        redirect_uri: redirectURL,
+        code: query.code
       }
-    ).catch((error) => {
-      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

@@ -1,13 +1,8 @@
-import {
-  eventHandler,
-  createError,
-  getQuery,
-  getRequestURL,
-  sendRedirect
-} from "h3";
+import { eventHandler, getQuery, sendRedirect } from "h3";
 import { withQuery } from "ufo";
 import { defu } from "defu";
-import { useRuntimeConfig } from "#imports";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
+import { useRuntimeConfig, createError } from "#imports";
 export function oauthFacebookEventHandler({
   config,
   onSuccess,
@@ -30,14 +25,9 @@ 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;
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
     if (!query.code) {
       config.scope = config.scope || [];
       return sendRedirect(
@@ -49,23 +39,17 @@ export function oauthFacebookEventHandler({
         })
       );
     }
-    const tokens = await $fetch(config.tokenURL, {
-      method: "POST",
+    const tokens = await requestAccessToken(config.tokenURL, {
       body: {
         client_id: config.clientId,
         client_secret: config.clientSecret,
+        grant_type: "authorization_code",
         redirect_uri: redirectURL,
         code: query.code
       }
     });
     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,7 +1,8 @@
-import { eventHandler, createError, getQuery, getRequestURL, sendRedirect } from "h3";
+import { eventHandler, getQuery, sendRedirect } from "h3";
 import { withQuery } from "ufo";
 import { defu } from "defu";
-import { useRuntimeConfig } from "#imports";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
+import { useRuntimeConfig, createError } from "#imports";
 export function oauthGitHubEventHandler({ config, onSuccess, onError }) {
   return eventHandler(async (event) => {
     config = defu(config, useRuntimeConfig(event).oauth?.github, {
@@ -20,19 +21,14 @@ 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);
     }
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
     if (!query.code) {
       config.scope = config.scope || [];
       if (config.emailRequired && !config.scope.includes("user:email")) {
         config.scope.push("user:email");
       }
-      const redirectURL = config.redirectURL || getRequestURL(event).href;
       return sendRedirect(
         event,
         withQuery(config.authorizationURL, {
@@ -43,25 +39,17 @@ export function oauthGitHubEventHandler({ config, onSuccess, onError }) {
         })
       );
     }
-    const tokens = await $fetch(
-      config.tokenURL,
-      {
-        method: "POST",
-        body: {
-          client_id: config.clientId,
-          client_secret: config.clientSecret,
-          code: query.code
-        }
+    const tokens = await requestAccessToken(config.tokenURL, {
+      body: {
+        grant_type: "authorization_code",
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        redirect_uri: redirectURL,
+        code: query.code
       }
-    );
+    });
     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,7 @@
-import {
-  eventHandler,
-  createError,
-  getQuery,
-  getRequestURL,
-  sendRedirect
-} from "h3";
-import { withQuery, parsePath } from "ufo";
+import { eventHandler, getQuery, sendRedirect } from "h3";
+import { withQuery } from "ufo";
 import { defu } from "defu";
+import { handleMissingConfiguration, handleAccessTokenErrorResponse, getOAuthRedirectURL, requestAccessToken } from "../utils.js";
 import { useRuntimeConfig } from "#imports";
 export function oauthGoogleEventHandler({
   config,
@@ -20,17 +15,12 @@ export function oauthGoogleEventHandler({
       userURL: "https://www.googleapis.com/oauth2/v3/userinfo",
       authorizationParams: {}
     });
-    const { code } = getQuery(event);
+    const query = 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) {
+    const redirectURL = config.redirectURL || getOAuthRedirectURL(event);
+    if (!query.code) {
       config.scope = config.scope || ["email", "profile"];
       return sendRedirect(
         event,
@@ -43,27 +33,17 @@ export function oauthGoogleEventHandler({
         })
       );
     }
-    const body = {
-      grant_type: "authorization_code",
-      redirect_uri: parsePath(redirectURL).pathname,
-      client_id: config.clientId,
-      client_secret: config.clientSecret,
-      code
-    };
-    const tokens = await $fetch(config.tokenURL, {
-      method: "POST",
-      body
-    }).catch((error) => {
-      return { error };
+    const tokens = await requestAccessToken(config.tokenURL, {
+      body: {
+        grant_type: "authorization_code",
+        code: query.code,
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        redirect_uri: redirectURL
+      }
     });
     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(