nuxt-auther 1.0.2 → 1.0.4

package/dist/runtime/inc/id-token.mjs

@@ -0,0 +1,81 @@
+import { jwtDecode } from "jwt-decode";
+import { addTokenPrefix } from "../../utils";
+import { TokenStatus } from "./token-status.mjs";
+export class IdToken {
+  scheme;
+  $storage;
+  constructor(scheme, storage) {
+    this.scheme = scheme;
+    this.$storage = storage;
+  }
+  get() {
+    const key = this.scheme.options.idToken.prefix + this.scheme.name;
+    return this.$storage.getUniversal(key);
+  }
+  set(tokenValue) {
+    const idToken = addTokenPrefix(tokenValue, this.scheme.options.idToken.type);
+    this.#setToken(idToken);
+    this.#updateExpiration(idToken);
+    return idToken;
+  }
+  sync() {
+    const idToken = this.#syncToken();
+    this.#syncExpiration();
+    return idToken;
+  }
+  reset() {
+    this.#resetSSRToken();
+    this.#setToken(void 0);
+    this.#setExpiration(void 0);
+  }
+  status() {
+    return new TokenStatus(this.get(), this.#getExpiration(), this.scheme.options.idToken?.httpOnly);
+  }
+  #resetSSRToken() {
+    if (this.scheme.options.ssr && this.scheme.options.idToken?.httpOnly) {
+      const key = this.scheme.options.idToken.prefix + this.scheme.name;
+      this.scheme.$auth.request({ baseURL: "", url: "/_auth/reset", body: new URLSearchParams({ token: key }), method: "POST" });
+    }
+  }
+  #getExpiration() {
+    const key = this.scheme.options.idToken.expirationPrefix + this.scheme.name;
+    return this.$storage.getUniversal(key);
+  }
+  #setExpiration(expiration) {
+    const key = this.scheme.options.idToken.expirationPrefix + this.scheme.name;
+    return this.$storage.setUniversal(key, expiration);
+  }
+  #syncExpiration() {
+    const key = this.scheme.options.idToken.expirationPrefix + this.scheme.name;
+    return this.$storage.syncUniversal(key);
+  }
+  #updateExpiration(idToken) {
+    let idTokenExpiration;
+    const tokenIssuedAtMillis = Date.now();
+    const tokenTTLMillis = Number(this.scheme.options.idToken.maxAge) * 1e3;
+    const tokenExpiresAtMillis = tokenTTLMillis ? tokenIssuedAtMillis + tokenTTLMillis : 0;
+    try {
+      idTokenExpiration = jwtDecode(idToken).exp * 1e3 || tokenExpiresAtMillis;
+    } catch (error) {
+      idTokenExpiration = tokenExpiresAtMillis;
+      if (!(error && error.name === "InvalidTokenError")) {
+        throw error;
+      }
+    }
+    return this.#setExpiration(idTokenExpiration || false);
+  }
+  #setToken(idToken) {
+    const key = this.scheme.options.idToken.prefix + this.scheme.name;
+    return this.$storage.setUniversal(key, idToken);
+  }
+  #syncToken() {
+    const key = this.scheme.options.idToken.prefix + this.scheme.name;
+    return this.$storage.syncUniversal(key);
+  }
+  userInfo() {
+    const idToken = this.get();
+    if (typeof idToken === "string") {
+      return jwtDecode(idToken);
+    }
+  }
+}

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

@@ -0,0 +1,10 @@
+export * from './configuration-document-request-error';
+export * from './configuration-document';
+export * from './expired-auth-session-error';
+export * from './default-properties';
+export * from './refresh-controller';
+export * from './refresh-token';
+export * from './request-handler';
+export * from './token-status';
+export * from './token';
+export * from './id-token';

package/dist/runtime/inc/index.mjs

@@ -0,0 +1,10 @@
+export * from "./configuration-document-request-error.mjs";
+export * from "./configuration-document.mjs";
+export * from "./expired-auth-session-error.mjs";
+export * from "./default-properties.mjs";
+export * from "./refresh-controller.mjs";
+export * from "./refresh-token.mjs";
+export * from "./request-handler.mjs";
+export * from "./token-status.mjs";
+export * from "./token.mjs";
+export * from "./id-token.mjs";

package/dist/runtime/inc/refresh-controller.d.ts

@@ -0,0 +1,9 @@
+import type { RefreshableScheme, HTTPResponse } from '../../types';
+import type { Auth } from '../core';
+export declare class RefreshController {
+    #private;
+    scheme: RefreshableScheme;
+    $auth: Auth;
+    constructor(scheme: RefreshableScheme);
+    handleRefresh(): Promise<HTTPResponse<any> | void>;
+}

package/dist/runtime/inc/refresh-controller.mjs

@@ -0,0 +1,29 @@
+export class RefreshController {
+  constructor(scheme) {
+    this.scheme = scheme;
+    this.$auth = scheme.$auth;
+  }
+  $auth;
+  #refreshPromise = null;
+  // Multiple requests will be queued until the first has completed token refresh.
+  handleRefresh() {
+    if (this.#refreshPromise) {
+      return this.#refreshPromise;
+    }
+    return this.#doRefresh();
+  }
+  // Returns a promise which is resolved when refresh is completed
+  // Call this function when you intercept a request with an expired token.
+  #doRefresh() {
+    this.#refreshPromise = new Promise((resolve, reject) => {
+      this.scheme.refreshTokens().then((response) => {
+        this.#refreshPromise = null;
+        resolve(response);
+      }).catch((error) => {
+        this.#refreshPromise = null;
+        reject(error);
+      });
+    });
+    return this.#refreshPromise;
+  }
+}

package/dist/runtime/inc/refresh-token.d.ts

@@ -0,0 +1,14 @@
+import type { RefreshableScheme } from '../../types';
+import type { Storage } from '../core';
+import { TokenStatus } from './token-status';
+export declare class RefreshToken {
+    #private;
+    scheme: RefreshableScheme;
+    $storage: Storage;
+    constructor(scheme: RefreshableScheme, storage: Storage);
+    get(): string | boolean;
+    set(tokenValue: string | boolean): string | boolean | void | null | undefined;
+    sync(): string | boolean | void | null | undefined;
+    reset(): void;
+    status(): TokenStatus;
+}

package/dist/runtime/inc/refresh-token.mjs

@@ -0,0 +1,75 @@
+import { addTokenPrefix } from "../../utils";
+import { TokenStatus } from "./token-status.mjs";
+import { jwtDecode } from "jwt-decode";
+export class RefreshToken {
+  scheme;
+  $storage;
+  constructor(scheme, storage) {
+    this.scheme = scheme;
+    this.$storage = storage;
+  }
+  get() {
+    const key = this.scheme.options.refreshToken.prefix + this.scheme.name;
+    return this.$storage.getUniversal(key);
+  }
+  set(tokenValue) {
+    const refreshToken = addTokenPrefix(tokenValue, this.scheme.options.refreshToken.type);
+    this.#setToken(refreshToken);
+    this.#updateExpiration(refreshToken);
+    return refreshToken;
+  }
+  sync() {
+    const refreshToken = this.#syncToken();
+    this.#syncExpiration();
+    return refreshToken;
+  }
+  reset() {
+    this.#resetSSRToken();
+    this.#setToken(void 0);
+    this.#setExpiration(void 0);
+  }
+  status() {
+    return new TokenStatus(this.get(), this.#getExpiration(), this.scheme.options.refreshToken?.httpOnly);
+  }
+  #resetSSRToken() {
+    if (this.scheme.options.ssr && this.scheme.options.refreshToken?.httpOnly) {
+      const key = this.scheme.options.refreshToken.prefix + this.scheme.name;
+      this.scheme.$auth.request({ baseURL: "", url: "/_auth/reset", body: new URLSearchParams({ token: key }), method: "POST" });
+    }
+  }
+  #getExpiration() {
+    const key = this.scheme.options.refreshToken.expirationPrefix + this.scheme.name;
+    return this.$storage.getUniversal(key);
+  }
+  #setExpiration(expiration) {
+    const key = this.scheme.options.refreshToken.expirationPrefix + this.scheme.name;
+    return this.$storage.setUniversal(key, expiration);
+  }
+  #syncExpiration() {
+    const key = this.scheme.options.refreshToken.expirationPrefix + this.scheme.name;
+    return this.$storage.syncUniversal(key);
+  }
+  #updateExpiration(refreshToken) {
+    let refreshTokenExpiration;
+    const tokenIssuedAtMillis = Date.now();
+    const tokenTTLMillis = Number(this.scheme.options.refreshToken.maxAge) * 1e3;
+    const tokenExpiresAtMillis = tokenTTLMillis ? tokenIssuedAtMillis + tokenTTLMillis : 0;
+    try {
+      refreshTokenExpiration = jwtDecode(refreshToken).exp * 1e3 || tokenExpiresAtMillis;
+    } catch (error) {
+      refreshTokenExpiration = tokenExpiresAtMillis;
+      if (!(error && error.name === "InvalidTokenError")) {
+        throw error;
+      }
+    }
+    return this.#setExpiration(refreshTokenExpiration || false);
+  }
+  #setToken(refreshToken) {
+    const key = this.scheme.options.refreshToken.prefix + this.scheme.name;
+    return this.$storage.setUniversal(key, refreshToken);
+  }
+  #syncToken() {
+    const key = this.scheme.options.refreshToken.prefix + this.scheme.name;
+    return this.$storage.syncUniversal(key);
+  }
+}

package/dist/runtime/inc/request-handler.d.ts

@@ -0,0 +1,17 @@
+import type { TokenableScheme, RefreshableScheme } from '../../types';
+import type { Auth } from '..';
+import { FetchInstance } from '@refactorjs/ofetch';
+export declare class RequestHandler {
+    #private;
+    scheme: TokenableScheme | RefreshableScheme;
+    auth: Auth;
+    http: FetchInstance;
+    requestInterceptor: number | null;
+    responseErrorInterceptor: number | null;
+    currentToken: string;
+    constructor(scheme: TokenableScheme | RefreshableScheme, http: FetchInstance, auth: Auth);
+    setHeader(token: string): void;
+    clearHeader(): void;
+    initializeRequestInterceptor(refreshEndpoint?: string | Request): void;
+    reset(): void;
+}

package/dist/runtime/inc/request-handler.mjs

@@ -0,0 +1,93 @@
+import { ExpiredAuthSessionError } from "./expired-auth-session-error.mjs";
+export class RequestHandler {
+  scheme;
+  auth;
+  http;
+  requestInterceptor;
+  responseErrorInterceptor;
+  currentToken;
+  constructor(scheme, http, auth) {
+    this.scheme = scheme;
+    this.http = http;
+    this.auth = auth;
+    this.requestInterceptor = null;
+    this.responseErrorInterceptor = null;
+    this.currentToken = this.auth.$storage?.memory?.[this.scheme.options.token?.prefix + this.scheme.options.name];
+  }
+  setHeader(token) {
+    if (this.scheme.options.token && this.scheme.options.token.global) {
+      this.http.setHeader(this.scheme.options.token.name, token);
+    }
+  }
+  clearHeader() {
+    if (this.scheme.options.token && this.scheme.options.token.global) {
+      this.http.setHeader(this.scheme.options.token.name, null);
+    }
+  }
+  initializeRequestInterceptor(refreshEndpoint) {
+    this.requestInterceptor = this.http.onRequest(
+      async (config) => {
+        if (this.scheme.options.token && this.currentToken) {
+          this.setHeader(this.currentToken);
+        }
+        if (this.scheme.options.token && !this.#needToken(config) || config.url === refreshEndpoint) {
+          return config;
+        }
+        const { valid, tokenExpired, refreshTokenExpired, isRefreshable } = this.scheme.check(true);
+        let isValid = valid;
+        if (refreshTokenExpired) {
+          this.scheme.reset?.();
+          throw new ExpiredAuthSessionError();
+        }
+        if (tokenExpired) {
+          if (!isRefreshable) {
+            this.scheme.reset?.();
+            throw new ExpiredAuthSessionError();
+          }
+          isValid = await this.scheme.refreshController.handleRefresh().then(() => true).catch(() => {
+            this.scheme.reset?.();
+            throw new ExpiredAuthSessionError();
+          });
+        }
+        const token = this.scheme.token;
+        if (!isValid) {
+          if (token && !token.get() && this.#requestHasAuthorizationHeader(config)) {
+            throw new ExpiredAuthSessionError();
+          }
+          return config;
+        }
+        return this.#getUpdatedRequestConfig(config, token ? token.get() : false);
+      }
+    );
+    this.responseErrorInterceptor = this.http.onResponseError((error) => {
+      if (typeof this.auth.options.resetOnResponseError === "function") {
+        this.auth.options.resetOnResponseError(error, this.auth, this.scheme);
+      } else if (this.auth.options.resetOnResponseError && error?.response?.status === 401) {
+        this.scheme.reset?.();
+        throw new ExpiredAuthSessionError();
+      }
+    });
+  }
+  reset() {
+    this.http.interceptors.request.eject(this.requestInterceptor);
+    this.http.interceptors.response.eject(this.responseErrorInterceptor);
+    this.requestInterceptor = null;
+    this.responseErrorInterceptor = null;
+  }
+  #needToken(config) {
+    const options = this.scheme.options;
+    return options.token.global || Object.values(options.endpoints).some((endpoint) => typeof endpoint === "object" ? endpoint.url === config.url : endpoint === config.url);
+  }
+  // ---------------------------------------------------------------
+  // Watch requests for token expiration
+  // Refresh tokens if token has expired
+  #getUpdatedRequestConfig(config, token) {
+    if (typeof token === "string") {
+      config.headers[this.scheme.options.token.name] = token;
+    }
+    return config;
+  }
+  #requestHasAuthorizationHeader(config) {
+    return !!config.headers[this.scheme.options.token.name];
+  }
+}

package/dist/runtime/inc/token-status.d.ts

@@ -0,0 +1,12 @@
+export declare enum TokenStatusEnum {
+    UNKNOWN = "UNKNOWN",
+    VALID = "VALID",
+    EXPIRED = "EXPIRED"
+}
+export declare class TokenStatus {
+    #private;
+    constructor(token: string | boolean, tokenExpiresAt: number | false, httpOnly?: boolean);
+    unknown(): boolean;
+    valid(): boolean;
+    expired(): boolean;
+}

package/dist/runtime/inc/token-status.mjs

@@ -0,0 +1,39 @@
+export var TokenStatusEnum = /* @__PURE__ */ ((TokenStatusEnum2) => {
+  TokenStatusEnum2["UNKNOWN"] = "UNKNOWN";
+  TokenStatusEnum2["VALID"] = "VALID";
+  TokenStatusEnum2["EXPIRED"] = "EXPIRED";
+  return TokenStatusEnum2;
+})(TokenStatusEnum || {});
+export class TokenStatus {
+  #status;
+  #isHttpOnly;
+  constructor(token, tokenExpiresAt, httpOnly = false) {
+    this.#status = this.#calculate(token, tokenExpiresAt);
+    this.#isHttpOnly = httpOnly;
+  }
+  unknown() {
+    return "UNKNOWN" /* UNKNOWN */ === this.#status;
+  }
+  valid() {
+    return "VALID" /* VALID */ === this.#status;
+  }
+  expired() {
+    return "EXPIRED" /* EXPIRED */ === this.#status;
+  }
+  #calculate(token, tokenExpiresAt) {
+    const now = Date.now();
+    try {
+      if (this.#isHttpOnly && !tokenExpiresAt || (!this.#isHttpOnly && !token || !tokenExpiresAt)) {
+        return "UNKNOWN" /* UNKNOWN */;
+      }
+    } catch (error) {
+      return "UNKNOWN" /* UNKNOWN */;
+    }
+    const timeSlackMillis = 6e4;
+    tokenExpiresAt -= timeSlackMillis;
+    if (now < tokenExpiresAt) {
+      return "VALID" /* VALID */;
+    }
+    return "EXPIRED" /* EXPIRED */;
+  }
+}

package/dist/runtime/inc/token.d.ts

@@ -0,0 +1,14 @@
+import type { TokenableScheme } from '../../types';
+import type { Storage } from '../core';
+import { TokenStatus } from './token-status';
+export declare class Token {
+    #private;
+    scheme: TokenableScheme;
+    $storage: Storage;
+    constructor(scheme: TokenableScheme, storage: Storage);
+    get(): string | boolean;
+    set(tokenValue: string | boolean, expiresIn?: number | boolean): string | boolean | void | null | undefined;
+    sync(): string | boolean | void | null | undefined;
+    reset(): void;
+    status(): TokenStatus;
+}

package/dist/runtime/inc/token.mjs

@@ -0,0 +1,83 @@
+import { addTokenPrefix } from "../../utils";
+import { TokenStatus } from "./token-status.mjs";
+import { jwtDecode } from "jwt-decode";
+export class Token {
+  scheme;
+  $storage;
+  constructor(scheme, storage) {
+    this.scheme = scheme;
+    this.$storage = storage;
+  }
+  get() {
+    const key = this.scheme.options.token.prefix + this.scheme.name;
+    return this.$storage.getUniversal(key);
+  }
+  set(tokenValue, expiresIn = false) {
+    const token = addTokenPrefix(tokenValue, this.scheme.options.token.type);
+    this.#setToken(token);
+    this.#updateExpiration(token, expiresIn);
+    if (typeof token === "string") {
+      this.scheme.requestHandler.setHeader(token);
+    }
+    return token;
+  }
+  sync() {
+    const token = this.#syncToken();
+    this.#syncExpiration();
+    if (typeof token === "string") {
+      this.scheme.requestHandler.setHeader(token);
+    }
+    return token;
+  }
+  reset() {
+    this.scheme.requestHandler.clearHeader();
+    this.#resetSSRToken();
+    this.#setToken(void 0);
+    this.#setExpiration(void 0);
+  }
+  status() {
+    return new TokenStatus(this.get(), this.#getExpiration(), this.scheme.options.token?.httpOnly);
+  }
+  #resetSSRToken() {
+    if (this.scheme.options.ssr && this.scheme.options.token?.httpOnly) {
+      const key = this.scheme.options.token.prefix + this.scheme.name;
+      this.scheme.$auth.request({ baseURL: "", url: "/_auth/reset", body: new URLSearchParams({ token: key }), method: "POST" });
+    }
+  }
+  #getExpiration() {
+    const key = this.scheme.options.token.expirationPrefix + this.scheme.name;
+    return this.$storage.getUniversal(key);
+  }
+  #setExpiration(expiration) {
+    const key = this.scheme.options.token.expirationPrefix + this.scheme.name;
+    return this.$storage.setUniversal(key, expiration);
+  }
+  #syncExpiration() {
+    const key = this.scheme.options.token.expirationPrefix + this.scheme.name;
+    return this.$storage.syncUniversal(key);
+  }
+  #updateExpiration(token, expiresIn) {
+    let tokenExpiration;
+    const tokenIssuedAtMillis = Date.now();
+    const maxAge = expiresIn ? expiresIn : this.scheme.options.token.maxAge;
+    const tokenTTLMillis = Number(maxAge) * 1e3;
+    const tokenExpiresAtMillis = tokenTTLMillis ? tokenIssuedAtMillis + tokenTTLMillis : 0;
+    try {
+      tokenExpiration = jwtDecode(token).exp * 1e3 || tokenExpiresAtMillis;
+    } catch (error) {
+      tokenExpiration = tokenExpiresAtMillis;
+      if (!(error && error.name === "InvalidTokenError")) {
+        throw error;
+      }
+    }
+    return this.#setExpiration(tokenExpiration || false);
+  }
+  #setToken(token) {
+    const key = this.scheme.options.token.prefix + this.scheme.name;
+    return this.$storage.setUniversal(key, token);
+  }
+  #syncToken() {
+    const key = this.scheme.options.token.prefix + this.scheme.name;
+    return this.$storage.syncUniversal(key);
+  }
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./core";
+export * from "./inc";
+export * from "./schemes";

package/dist/runtime/index.mjs

@@ -0,0 +1,3 @@
+export * from "./core/index.mjs";
+export * from "./inc/index.mjs";
+export * from "./schemes/index.mjs";

package/dist/runtime/providers/auth0.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderOptions, ProviderPartialOptions } from '../../types';
+import type { Oauth2SchemeOptions } from '..';
+import type { Nuxt } from '@nuxt/schema';
+export interface Auth0ProviderOptions extends ProviderOptions, Oauth2SchemeOptions {
+    domain: string;
+}
+export declare function auth0(nuxt: Nuxt, strategy: ProviderPartialOptions<Auth0ProviderOptions>): void;

package/dist/runtime/providers/auth0.mjs

@@ -0,0 +1,15 @@
+import { assignDefaults } from "../../utils/provider";
+import { OAUTH2DEFAULTS } from "../inc/index.mjs";
+export function auth0(nuxt, strategy) {
+  const DEFAULTS = Object.assign(OAUTH2DEFAULTS, {
+    scheme: "auth0",
+    endpoints: {
+      authorization: `https://${strategy.domain}/authorize`,
+      userInfo: `https://${strategy.domain}/userinfo`,
+      token: `https://${strategy.domain}/oauth/token`,
+      logout: `https://${strategy.domain}/v2/logout`
+    },
+    scope: ["openid", "profile", "email"]
+  });
+  assignDefaults(strategy, DEFAULTS);
+}

package/dist/runtime/providers/discord.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderOptions, ProviderPartialOptions } from '../../types';
+import type { Oauth2SchemeOptions } from '..';
+import type { Nuxt } from '@nuxt/schema';
+export interface DiscordProviderOptions extends ProviderOptions, Oauth2SchemeOptions {
+}
+export declare function discord(nuxt: Nuxt, strategy: ProviderPartialOptions<DiscordProviderOptions>): void;

package/dist/runtime/providers/discord.mjs

@@ -0,0 +1,18 @@
+import { assignDefaults, addAuthorize } from "../../utils/provider";
+import { OAUTH2DEFAULTS } from "../inc/index.mjs";
+export function discord(nuxt, strategy) {
+  const DEFAULTS = Object.assign(OAUTH2DEFAULTS, {
+    scheme: "oauth2",
+    endpoints: {
+      authorization: "https://discord.com/api/oauth2/authorize",
+      token: "https://discord.com/api/oauth2/token",
+      userInfo: "https://discord.com/api/users/@me"
+      //   logout: 'https://discord.com/api/oauth2/token/revoke' //TODO: add post method, because discord using the post method to logout
+    },
+    grantType: "authorization_code",
+    codeChallengeMethod: "S256",
+    scope: ["identify", "email"]
+  });
+  assignDefaults(strategy, DEFAULTS);
+  addAuthorize(nuxt, strategy, true);
+}

package/dist/runtime/providers/facebook.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderPartialOptions, ProviderOptions } from '../../types';
+import type { Oauth2SchemeOptions } from '..';
+import type { Nuxt } from '@nuxt/schema';
+export interface FacebookProviderOptions extends ProviderOptions, Oauth2SchemeOptions {
+}
+export declare function facebook(nuxt: Nuxt, strategy: ProviderPartialOptions<FacebookProviderOptions>): void;

package/dist/runtime/providers/facebook.mjs

@@ -0,0 +1,13 @@
+import { assignDefaults } from "../../utils/provider";
+import { OAUTH2DEFAULTS } from "../inc/index.mjs";
+export function facebook(nuxt, strategy) {
+  const DEFAULTS = Object.assign(OAUTH2DEFAULTS, {
+    scheme: "oauth2",
+    endpoints: {
+      authorization: "https://facebook.com/v2.12/dialog/oauth",
+      userInfo: "https://graph.facebook.com/v2.12/me?fields=about,name,picture{url},email"
+    },
+    scope: ["public_profile", "email"]
+  });
+  assignDefaults(strategy, DEFAULTS);
+}

package/dist/runtime/providers/github.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderOptions, ProviderPartialOptions } from '../../types';
+import type { Oauth2SchemeOptions } from '..';
+import type { Nuxt } from '@nuxt/schema';
+export interface GithubProviderOptions extends ProviderOptions, Oauth2SchemeOptions {
+}
+export declare function github(nuxt: Nuxt, strategy: ProviderPartialOptions<GithubProviderOptions>): void;

package/dist/runtime/providers/github.mjs

@@ -0,0 +1,15 @@
+import { assignDefaults, addAuthorize } from "../../utils/provider";
+import { OAUTH2DEFAULTS } from "../inc/index.mjs";
+export function github(nuxt, strategy) {
+  const DEFAULTS = Object.assign(OAUTH2DEFAULTS, {
+    scheme: "oauth2",
+    endpoints: {
+      authorization: "https://github.com/login/oauth/authorize",
+      token: "https://github.com/login/oauth/access_token",
+      userInfo: "https://api.github.com/user"
+    },
+    scope: ["user", "email"]
+  });
+  assignDefaults(strategy, DEFAULTS);
+  addAuthorize(nuxt, strategy);
+}

package/dist/runtime/providers/google.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderPartialOptions, ProviderOptions } from '../../types';
+import type { Oauth2SchemeOptions } from '..';
+import type { Nuxt } from '@nuxt/schema';
+export interface GoogleProviderOptions extends ProviderOptions, Oauth2SchemeOptions {
+}
+export declare function google(nuxt: Nuxt, strategy: ProviderPartialOptions<GoogleProviderOptions>): void;

package/dist/runtime/providers/google.mjs

@@ -0,0 +1,13 @@
+import { assignDefaults } from "../../utils/provider";
+import { OAUTH2DEFAULTS } from "../inc/index.mjs";
+export function google(nuxt, strategy) {
+  const DEFAULTS = Object.assign(OAUTH2DEFAULTS, {
+    scheme: "oauth2",
+    endpoints: {
+      authorization: "https://accounts.google.com/o/oauth2/v2/auth",
+      userInfo: "https://www.googleapis.com/oauth2/v3/userinfo"
+    },
+    scope: ["openid", "profile", "email"]
+  });
+  assignDefaults(strategy, DEFAULTS);
+}

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

@@ -0,0 +1,8 @@
+export * from './auth0';
+export * from './discord';
+export * from './facebook';
+export * from './github';
+export * from './google';
+export * from './laravel-jwt';
+export * from './laravel-passport';
+export * from './laravel-sanctum';

package/dist/runtime/providers/index.mjs

@@ -0,0 +1,8 @@
+export * from "./auth0.mjs";
+export * from "./discord.mjs";
+export * from "./facebook.mjs";
+export * from "./github.mjs";
+export * from "./google.mjs";
+export * from "./laravel-jwt.mjs";
+export * from "./laravel-passport.mjs";
+export * from "./laravel-sanctum.mjs";

package/dist/runtime/providers/laravel-jwt.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderPartialOptions, ProviderOptions } from '../../types';
+import type { RefreshSchemeOptions } from '..';
+import type { Nuxt } from '@nuxt/schema';
+export interface LaravelJWTProviderOptions extends ProviderOptions, RefreshSchemeOptions {
+    url: string;
+}
+export declare function laravelJWT(nuxt: Nuxt, strategy: ProviderPartialOptions<LaravelJWTProviderOptions>): void;