@better-auth/core 1.3.26 → 1.3.28

package/dist/oauth2/index.cjs

@@ -0,0 +1,368 @@
+'use strict';
+
+const base64 = require('@better-auth/utils/base64');
+const fetch = require('@better-fetch/fetch');
+const jose = require('jose');
+
+function getOAuth2Tokens(data) {
+  const getDate = (seconds) => {
+    const now = /* @__PURE__ */ new Date();
+    return new Date(now.getTime() + seconds * 1e3);
+  };
+  return {
+    tokenType: data.token_type,
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    accessTokenExpiresAt: data.expires_in ? getDate(data.expires_in) : void 0,
+    refreshTokenExpiresAt: data.refresh_token_expires_in ? getDate(data.refresh_token_expires_in) : void 0,
+    scopes: data?.scope ? typeof data.scope === "string" ? data.scope.split(" ") : data.scope : [],
+    idToken: data.id_token
+  };
+}
+async function generateCodeChallenge(codeVerifier) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(codeVerifier);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return base64.base64Url.encode(new Uint8Array(hash), {
+    padding: false
+  });
+}
+
+async function createAuthorizationURL({
+  id,
+  options,
+  authorizationEndpoint,
+  state,
+  codeVerifier,
+  scopes,
+  claims,
+  redirectURI,
+  duration,
+  prompt,
+  accessType,
+  responseType,
+  display,
+  loginHint,
+  hd,
+  responseMode,
+  additionalParams,
+  scopeJoiner
+}) {
+  const url = new URL(authorizationEndpoint);
+  url.searchParams.set("response_type", responseType || "code");
+  const primaryClientId = Array.isArray(options.clientId) ? options.clientId[0] : options.clientId;
+  url.searchParams.set("client_id", primaryClientId);
+  url.searchParams.set("state", state);
+  url.searchParams.set("scope", scopes.join(scopeJoiner || " "));
+  url.searchParams.set("redirect_uri", options.redirectURI || redirectURI);
+  duration && url.searchParams.set("duration", duration);
+  display && url.searchParams.set("display", display);
+  loginHint && url.searchParams.set("login_hint", loginHint);
+  prompt && url.searchParams.set("prompt", prompt);
+  hd && url.searchParams.set("hd", hd);
+  accessType && url.searchParams.set("access_type", accessType);
+  responseMode && url.searchParams.set("response_mode", responseMode);
+  if (codeVerifier) {
+    const codeChallenge = await generateCodeChallenge(codeVerifier);
+    url.searchParams.set("code_challenge_method", "S256");
+    url.searchParams.set("code_challenge", codeChallenge);
+  }
+  if (claims) {
+    const claimsObj = claims.reduce(
+      (acc, claim) => {
+        acc[claim] = null;
+        return acc;
+      },
+      {}
+    );
+    url.searchParams.set(
+      "claims",
+      JSON.stringify({
+        id_token: { email: null, email_verified: null, ...claimsObj }
+      })
+    );
+  }
+  if (additionalParams) {
+    Object.entries(additionalParams).forEach(([key, value]) => {
+      url.searchParams.set(key, value);
+    });
+  }
+  return url;
+}
+
+function createAuthorizationCodeRequest({
+  code,
+  codeVerifier,
+  redirectURI,
+  options,
+  authentication,
+  deviceId,
+  headers,
+  additionalParams = {},
+  resource
+}) {
+  const body = new URLSearchParams();
+  const requestHeaders = {
+    "content-type": "application/x-www-form-urlencoded",
+    accept: "application/json",
+    "user-agent": "better-auth",
+    ...headers
+  };
+  body.set("grant_type", "authorization_code");
+  body.set("code", code);
+  codeVerifier && body.set("code_verifier", codeVerifier);
+  options.clientKey && body.set("client_key", options.clientKey);
+  deviceId && body.set("device_id", deviceId);
+  body.set("redirect_uri", options.redirectURI || redirectURI);
+  if (resource) {
+    if (typeof resource === "string") {
+      body.append("resource", resource);
+    } else {
+      for (const _resource of resource) {
+        body.append("resource", _resource);
+      }
+    }
+  }
+  if (authentication === "basic") {
+    const primaryClientId = Array.isArray(options.clientId) ? options.clientId[0] : options.clientId;
+    const encodedCredentials = base64.base64.encode(
+      `${primaryClientId}:${options.clientSecret ?? ""}`
+    );
+    requestHeaders["authorization"] = `Basic ${encodedCredentials}`;
+  } else {
+    const primaryClientId = Array.isArray(options.clientId) ? options.clientId[0] : options.clientId;
+    body.set("client_id", primaryClientId);
+    if (options.clientSecret) {
+      body.set("client_secret", options.clientSecret);
+    }
+  }
+  for (const [key, value] of Object.entries(additionalParams)) {
+    if (!body.has(key)) body.append(key, value);
+  }
+  return {
+    body,
+    headers: requestHeaders
+  };
+}
+async function validateAuthorizationCode({
+  code,
+  codeVerifier,
+  redirectURI,
+  options,
+  tokenEndpoint,
+  authentication,
+  deviceId,
+  headers,
+  additionalParams = {},
+  resource
+}) {
+  const { body, headers: requestHeaders } = createAuthorizationCodeRequest({
+    code,
+    codeVerifier,
+    redirectURI,
+    options,
+    authentication,
+    deviceId,
+    headers,
+    additionalParams,
+    resource
+  });
+  const { data, error } = await fetch.betterFetch(tokenEndpoint, {
+    method: "POST",
+    body,
+    headers: requestHeaders
+  });
+  if (error) {
+    throw error;
+  }
+  const tokens = getOAuth2Tokens(data);
+  return tokens;
+}
+async function validateToken(token, jwksEndpoint) {
+  const { data, error } = await fetch.betterFetch(jwksEndpoint, {
+    method: "GET",
+    headers: {
+      accept: "application/json",
+      "user-agent": "better-auth"
+    }
+  });
+  if (error) {
+    throw error;
+  }
+  const keys = data["keys"];
+  const header = JSON.parse(atob(token.split(".")[0]));
+  const key = keys.find((key2) => key2.kid === header.kid);
+  if (!key) {
+    throw new Error("Key not found");
+  }
+  const verified = await jose.jwtVerify(token, key);
+  return verified;
+}
+
+function createRefreshAccessTokenRequest({
+  refreshToken,
+  options,
+  authentication,
+  extraParams,
+  resource
+}) {
+  const body = new URLSearchParams();
+  const headers = {
+    "content-type": "application/x-www-form-urlencoded",
+    accept: "application/json"
+  };
+  body.set("grant_type", "refresh_token");
+  body.set("refresh_token", refreshToken);
+  if (authentication === "basic") {
+    const primaryClientId = Array.isArray(options.clientId) ? options.clientId[0] : options.clientId;
+    if (primaryClientId) {
+      headers["authorization"] = "Basic " + base64.base64.encode(`${primaryClientId}:${options.clientSecret ?? ""}`);
+    } else {
+      headers["authorization"] = "Basic " + base64.base64.encode(`:${options.clientSecret ?? ""}`);
+    }
+  } else {
+    const primaryClientId = Array.isArray(options.clientId) ? options.clientId[0] : options.clientId;
+    body.set("client_id", primaryClientId);
+    if (options.clientSecret) {
+      body.set("client_secret", options.clientSecret);
+    }
+  }
+  if (resource) {
+    if (typeof resource === "string") {
+      body.append("resource", resource);
+    } else {
+      for (const _resource of resource) {
+        body.append("resource", _resource);
+      }
+    }
+  }
+  if (extraParams) {
+    for (const [key, value] of Object.entries(extraParams)) {
+      body.set(key, value);
+    }
+  }
+  return {
+    body,
+    headers
+  };
+}
+async function refreshAccessToken({
+  refreshToken,
+  options,
+  tokenEndpoint,
+  authentication,
+  extraParams
+}) {
+  const { body, headers } = createRefreshAccessTokenRequest({
+    refreshToken,
+    options,
+    authentication,
+    extraParams
+  });
+  const { data, error } = await fetch.betterFetch(tokenEndpoint, {
+    method: "POST",
+    body,
+    headers
+  });
+  if (error) {
+    throw error;
+  }
+  const tokens = {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    tokenType: data.token_type,
+    scopes: data.scope?.split(" "),
+    idToken: data.id_token
+  };
+  if (data.expires_in) {
+    const now = /* @__PURE__ */ new Date();
+    tokens.accessTokenExpiresAt = new Date(
+      now.getTime() + data.expires_in * 1e3
+    );
+  }
+  return tokens;
+}
+
+function createClientCredentialsTokenRequest({
+  options,
+  scope,
+  authentication,
+  resource
+}) {
+  const body = new URLSearchParams();
+  const headers = {
+    "content-type": "application/x-www-form-urlencoded",
+    accept: "application/json"
+  };
+  body.set("grant_type", "client_credentials");
+  scope && body.set("scope", scope);
+  if (resource) {
+    if (typeof resource === "string") {
+      body.append("resource", resource);
+    } else {
+      for (const _resource of resource) {
+        body.append("resource", _resource);
+      }
+    }
+  }
+  if (authentication === "basic") {
+    const primaryClientId = Array.isArray(options.clientId) ? options.clientId[0] : options.clientId;
+    const encodedCredentials = base64.base64Url.encode(
+      `${primaryClientId}:${options.clientSecret}`
+    );
+    headers["authorization"] = `Basic ${encodedCredentials}`;
+  } else {
+    const primaryClientId = Array.isArray(options.clientId) ? options.clientId[0] : options.clientId;
+    body.set("client_id", primaryClientId);
+    body.set("client_secret", options.clientSecret);
+  }
+  return {
+    body,
+    headers
+  };
+}
+async function clientCredentialsToken({
+  options,
+  tokenEndpoint,
+  scope,
+  authentication,
+  resource
+}) {
+  const { body, headers } = createClientCredentialsTokenRequest({
+    options,
+    scope,
+    authentication,
+    resource
+  });
+  const { data, error } = await fetch.betterFetch(tokenEndpoint, {
+    method: "POST",
+    body,
+    headers
+  });
+  if (error) {
+    throw error;
+  }
+  const tokens = {
+    accessToken: data.access_token,
+    tokenType: data.token_type,
+    scopes: data.scope?.split(" ")
+  };
+  if (data.expires_in) {
+    const now = /* @__PURE__ */ new Date();
+    tokens.accessTokenExpiresAt = new Date(
+      now.getTime() + data.expires_in * 1e3
+    );
+  }
+  return tokens;
+}
+
+exports.clientCredentialsToken = clientCredentialsToken;
+exports.createAuthorizationCodeRequest = createAuthorizationCodeRequest;
+exports.createAuthorizationURL = createAuthorizationURL;
+exports.createClientCredentialsTokenRequest = createClientCredentialsTokenRequest;
+exports.createRefreshAccessTokenRequest = createRefreshAccessTokenRequest;
+exports.generateCodeChallenge = generateCodeChallenge;
+exports.getOAuth2Tokens = getOAuth2Tokens;
+exports.refreshAccessToken = refreshAccessToken;
+exports.validateAuthorizationCode = validateAuthorizationCode;
+exports.validateToken = validateToken;

package/dist/oauth2/index.d.cts

@@ -0,0 +1,100 @@
+import { O as OAuth2Tokens, P as ProviderOptions } from '../shared/core.DyEdx0m7.cjs';
+export { b as OAuth2UserInfo, a as OAuthProvider } from '../shared/core.DyEdx0m7.cjs';
+import * as jose from 'jose';
+import '../shared/core.CajxAutx.cjs';
+import 'zod';
+
+declare function getOAuth2Tokens(data: Record<string, any>): OAuth2Tokens;
+declare function generateCodeChallenge(codeVerifier: string): Promise<string>;
+
+declare function createAuthorizationURL({ id, options, authorizationEndpoint, state, codeVerifier, scopes, claims, redirectURI, duration, prompt, accessType, responseType, display, loginHint, hd, responseMode, additionalParams, scopeJoiner, }: {
+    id: string;
+    options: ProviderOptions;
+    redirectURI: string;
+    authorizationEndpoint: string;
+    state: string;
+    codeVerifier?: string;
+    scopes: string[];
+    claims?: string[];
+    duration?: string;
+    prompt?: string;
+    accessType?: string;
+    responseType?: string;
+    display?: string;
+    loginHint?: string;
+    hd?: string;
+    responseMode?: string;
+    additionalParams?: Record<string, string>;
+    scopeJoiner?: string;
+}): Promise<URL>;
+
+declare function createAuthorizationCodeRequest({ code, codeVerifier, redirectURI, options, authentication, deviceId, headers, additionalParams, resource, }: {
+    code: string;
+    redirectURI: string;
+    options: Partial<ProviderOptions>;
+    codeVerifier?: string;
+    deviceId?: string;
+    authentication?: "basic" | "post";
+    headers?: Record<string, string>;
+    additionalParams?: Record<string, string>;
+    resource?: string | string[];
+}): {
+    body: URLSearchParams;
+    headers: Record<string, any>;
+};
+declare function validateAuthorizationCode({ code, codeVerifier, redirectURI, options, tokenEndpoint, authentication, deviceId, headers, additionalParams, resource, }: {
+    code: string;
+    redirectURI: string;
+    options: Partial<ProviderOptions>;
+    codeVerifier?: string;
+    deviceId?: string;
+    tokenEndpoint: string;
+    authentication?: "basic" | "post";
+    headers?: Record<string, string>;
+    additionalParams?: Record<string, string>;
+    resource?: string | string[];
+}): Promise<OAuth2Tokens>;
+declare function validateToken(token: string, jwksEndpoint: string): Promise<jose.JWTVerifyResult<jose.JWTPayload>>;
+
+declare function createRefreshAccessTokenRequest({ refreshToken, options, authentication, extraParams, resource, }: {
+    refreshToken: string;
+    options: Partial<ProviderOptions>;
+    authentication?: "basic" | "post";
+    extraParams?: Record<string, string>;
+    resource?: string | string[];
+}): {
+    body: URLSearchParams;
+    headers: Record<string, any>;
+};
+declare function refreshAccessToken({ refreshToken, options, tokenEndpoint, authentication, extraParams, }: {
+    refreshToken: string;
+    options: Partial<ProviderOptions>;
+    tokenEndpoint: string;
+    authentication?: "basic" | "post";
+    extraParams?: Record<string, string>;
+    /** @deprecated always "refresh_token" */
+    grantType?: string;
+}): Promise<OAuth2Tokens>;
+
+declare function createClientCredentialsTokenRequest({ options, scope, authentication, resource, }: {
+    options: ProviderOptions & {
+        clientSecret: string;
+    };
+    scope?: string;
+    authentication?: "basic" | "post";
+    resource?: string | string[];
+}): {
+    body: URLSearchParams;
+    headers: Record<string, any>;
+};
+declare function clientCredentialsToken({ options, tokenEndpoint, scope, authentication, resource, }: {
+    options: ProviderOptions & {
+        clientSecret: string;
+    };
+    tokenEndpoint: string;
+    scope: string;
+    authentication?: "basic" | "post";
+    resource?: string | string[];
+}): Promise<OAuth2Tokens>;
+
+export { OAuth2Tokens, ProviderOptions, clientCredentialsToken, createAuthorizationCodeRequest, createAuthorizationURL, createClientCredentialsTokenRequest, createRefreshAccessTokenRequest, generateCodeChallenge, getOAuth2Tokens, refreshAccessToken, validateAuthorizationCode, validateToken };

package/dist/oauth2/index.d.mts

@@ -0,0 +1,100 @@
+import { O as OAuth2Tokens, P as ProviderOptions } from '../shared/core.Bl6TpxyD.mjs';
+export { b as OAuth2UserInfo, a as OAuthProvider } from '../shared/core.Bl6TpxyD.mjs';
+import * as jose from 'jose';
+import '../shared/core.CajxAutx.mjs';
+import 'zod';
+
+declare function getOAuth2Tokens(data: Record<string, any>): OAuth2Tokens;
+declare function generateCodeChallenge(codeVerifier: string): Promise<string>;
+
+declare function createAuthorizationURL({ id, options, authorizationEndpoint, state, codeVerifier, scopes, claims, redirectURI, duration, prompt, accessType, responseType, display, loginHint, hd, responseMode, additionalParams, scopeJoiner, }: {
+    id: string;
+    options: ProviderOptions;
+    redirectURI: string;
+    authorizationEndpoint: string;
+    state: string;
+    codeVerifier?: string;
+    scopes: string[];
+    claims?: string[];
+    duration?: string;
+    prompt?: string;
+    accessType?: string;
+    responseType?: string;
+    display?: string;
+    loginHint?: string;
+    hd?: string;
+    responseMode?: string;
+    additionalParams?: Record<string, string>;
+    scopeJoiner?: string;
+}): Promise<URL>;
+
+declare function createAuthorizationCodeRequest({ code, codeVerifier, redirectURI, options, authentication, deviceId, headers, additionalParams, resource, }: {
+    code: string;
+    redirectURI: string;
+    options: Partial<ProviderOptions>;
+    codeVerifier?: string;
+    deviceId?: string;
+    authentication?: "basic" | "post";
+    headers?: Record<string, string>;
+    additionalParams?: Record<string, string>;
+    resource?: string | string[];
+}): {
+    body: URLSearchParams;
+    headers: Record<string, any>;
+};
+declare function validateAuthorizationCode({ code, codeVerifier, redirectURI, options, tokenEndpoint, authentication, deviceId, headers, additionalParams, resource, }: {
+    code: string;
+    redirectURI: string;
+    options: Partial<ProviderOptions>;
+    codeVerifier?: string;
+    deviceId?: string;
+    tokenEndpoint: string;
+    authentication?: "basic" | "post";
+    headers?: Record<string, string>;
+    additionalParams?: Record<string, string>;
+    resource?: string | string[];
+}): Promise<OAuth2Tokens>;
+declare function validateToken(token: string, jwksEndpoint: string): Promise<jose.JWTVerifyResult<jose.JWTPayload>>;
+
+declare function createRefreshAccessTokenRequest({ refreshToken, options, authentication, extraParams, resource, }: {
+    refreshToken: string;
+    options: Partial<ProviderOptions>;
+    authentication?: "basic" | "post";
+    extraParams?: Record<string, string>;
+    resource?: string | string[];
+}): {
+    body: URLSearchParams;
+    headers: Record<string, any>;
+};
+declare function refreshAccessToken({ refreshToken, options, tokenEndpoint, authentication, extraParams, }: {
+    refreshToken: string;
+    options: Partial<ProviderOptions>;
+    tokenEndpoint: string;
+    authentication?: "basic" | "post";
+    extraParams?: Record<string, string>;
+    /** @deprecated always "refresh_token" */
+    grantType?: string;
+}): Promise<OAuth2Tokens>;
+
+declare function createClientCredentialsTokenRequest({ options, scope, authentication, resource, }: {
+    options: ProviderOptions & {
+        clientSecret: string;
+    };
+    scope?: string;
+    authentication?: "basic" | "post";
+    resource?: string | string[];
+}): {
+    body: URLSearchParams;
+    headers: Record<string, any>;
+};
+declare function clientCredentialsToken({ options, tokenEndpoint, scope, authentication, resource, }: {
+    options: ProviderOptions & {
+        clientSecret: string;
+    };
+    tokenEndpoint: string;
+    scope: string;
+    authentication?: "basic" | "post";
+    resource?: string | string[];
+}): Promise<OAuth2Tokens>;
+
+export { OAuth2Tokens, ProviderOptions, clientCredentialsToken, createAuthorizationCodeRequest, createAuthorizationURL, createClientCredentialsTokenRequest, createRefreshAccessTokenRequest, generateCodeChallenge, getOAuth2Tokens, refreshAccessToken, validateAuthorizationCode, validateToken };

package/dist/oauth2/index.d.ts

@@ -0,0 +1,100 @@
+import { O as OAuth2Tokens, P as ProviderOptions } from '../shared/core.DkdZ1o38.js';
+export { b as OAuth2UserInfo, a as OAuthProvider } from '../shared/core.DkdZ1o38.js';
+import * as jose from 'jose';
+import '../shared/core.CajxAutx.js';
+import 'zod';
+
+declare function getOAuth2Tokens(data: Record<string, any>): OAuth2Tokens;
+declare function generateCodeChallenge(codeVerifier: string): Promise<string>;
+
+declare function createAuthorizationURL({ id, options, authorizationEndpoint, state, codeVerifier, scopes, claims, redirectURI, duration, prompt, accessType, responseType, display, loginHint, hd, responseMode, additionalParams, scopeJoiner, }: {
+    id: string;
+    options: ProviderOptions;
+    redirectURI: string;
+    authorizationEndpoint: string;
+    state: string;
+    codeVerifier?: string;
+    scopes: string[];
+    claims?: string[];
+    duration?: string;
+    prompt?: string;
+    accessType?: string;
+    responseType?: string;
+    display?: string;
+    loginHint?: string;
+    hd?: string;
+    responseMode?: string;
+    additionalParams?: Record<string, string>;
+    scopeJoiner?: string;
+}): Promise<URL>;
+
+declare function createAuthorizationCodeRequest({ code, codeVerifier, redirectURI, options, authentication, deviceId, headers, additionalParams, resource, }: {
+    code: string;
+    redirectURI: string;
+    options: Partial<ProviderOptions>;
+    codeVerifier?: string;
+    deviceId?: string;
+    authentication?: "basic" | "post";
+    headers?: Record<string, string>;
+    additionalParams?: Record<string, string>;
+    resource?: string | string[];
+}): {
+    body: URLSearchParams;
+    headers: Record<string, any>;
+};
+declare function validateAuthorizationCode({ code, codeVerifier, redirectURI, options, tokenEndpoint, authentication, deviceId, headers, additionalParams, resource, }: {
+    code: string;
+    redirectURI: string;
+    options: Partial<ProviderOptions>;
+    codeVerifier?: string;
+    deviceId?: string;
+    tokenEndpoint: string;
+    authentication?: "basic" | "post";
+    headers?: Record<string, string>;
+    additionalParams?: Record<string, string>;
+    resource?: string | string[];
+}): Promise<OAuth2Tokens>;
+declare function validateToken(token: string, jwksEndpoint: string): Promise<jose.JWTVerifyResult<jose.JWTPayload>>;
+
+declare function createRefreshAccessTokenRequest({ refreshToken, options, authentication, extraParams, resource, }: {
+    refreshToken: string;
+    options: Partial<ProviderOptions>;
+    authentication?: "basic" | "post";
+    extraParams?: Record<string, string>;
+    resource?: string | string[];
+}): {
+    body: URLSearchParams;
+    headers: Record<string, any>;
+};
+declare function refreshAccessToken({ refreshToken, options, tokenEndpoint, authentication, extraParams, }: {
+    refreshToken: string;
+    options: Partial<ProviderOptions>;
+    tokenEndpoint: string;
+    authentication?: "basic" | "post";
+    extraParams?: Record<string, string>;
+    /** @deprecated always "refresh_token" */
+    grantType?: string;
+}): Promise<OAuth2Tokens>;
+
+declare function createClientCredentialsTokenRequest({ options, scope, authentication, resource, }: {
+    options: ProviderOptions & {
+        clientSecret: string;
+    };
+    scope?: string;
+    authentication?: "basic" | "post";
+    resource?: string | string[];
+}): {
+    body: URLSearchParams;
+    headers: Record<string, any>;
+};
+declare function clientCredentialsToken({ options, tokenEndpoint, scope, authentication, resource, }: {
+    options: ProviderOptions & {
+        clientSecret: string;
+    };
+    tokenEndpoint: string;
+    scope: string;
+    authentication?: "basic" | "post";
+    resource?: string | string[];
+}): Promise<OAuth2Tokens>;
+
+export { OAuth2Tokens, ProviderOptions, clientCredentialsToken, createAuthorizationCodeRequest, createAuthorizationURL, createClientCredentialsTokenRequest, createRefreshAccessTokenRequest, generateCodeChallenge, getOAuth2Tokens, refreshAccessToken, validateAuthorizationCode, validateToken };