@better-auth/core 1.4.0-beta.7 → 1.4.0-beta.8

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,277 @@
+import { a as LiteralString } from '../shared/core.DeNN5HMO.cjs';
+import * as jose from 'jose';
+import 'zod';
+
+interface OAuth2Tokens {
+    tokenType?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    accessTokenExpiresAt?: Date;
+    refreshTokenExpiresAt?: Date;
+    scopes?: string[];
+    idToken?: string;
+}
+type OAuth2UserInfo = {
+    id: string | number;
+    name?: string;
+    email?: string | null;
+    image?: string;
+    emailVerified: boolean;
+};
+interface OAuthProvider<T extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Partial<ProviderOptions>> {
+    id: LiteralString;
+    createAuthorizationURL: (data: {
+        state: string;
+        codeVerifier: string;
+        scopes?: string[];
+        redirectURI: string;
+        display?: string;
+        loginHint?: string;
+    }) => Promise<URL> | URL;
+    name: string;
+    validateAuthorizationCode: (data: {
+        code: string;
+        redirectURI: string;
+        codeVerifier?: string;
+        deviceId?: string;
+    }) => Promise<OAuth2Tokens>;
+    getUserInfo: (token: OAuth2Tokens & {
+        /**
+         * The user object from the provider
+         * This is only available for some providers like Apple
+         */
+        user?: {
+            name?: {
+                firstName?: string;
+                lastName?: string;
+            };
+            email?: string;
+        };
+    }) => Promise<{
+        user: OAuth2UserInfo;
+        data: T;
+    } | null>;
+    /**
+     * Custom function to refresh a token
+     */
+    refreshAccessToken?: (refreshToken: string) => Promise<OAuth2Tokens>;
+    revokeToken?: (token: string) => Promise<void>;
+    /**
+     * Verify the id token
+     * @param token - The id token
+     * @param nonce - The nonce
+     * @returns True if the id token is valid, false otherwise
+     */
+    verifyIdToken?: (token: string, nonce?: string) => Promise<boolean>;
+    /**
+     * Disable implicit sign up for new users. When set to true for the provider,
+     * sign-in need to be called with with requestSignUp as true to create new users.
+     */
+    disableImplicitSignUp?: boolean;
+    /**
+     * Disable sign up for new users.
+     */
+    disableSignUp?: boolean;
+    /**
+     * Options for the provider
+     */
+    options?: O;
+}
+type ProviderOptions<Profile extends Record<string, any> = any> = {
+    /**
+     * The client ID of your application.
+     *
+     * This is usually a string but can be any type depending on the provider.
+     */
+    clientId?: unknown;
+    /**
+     * The client secret of your application
+     */
+    clientSecret?: string;
+    /**
+     * The scopes you want to request from the provider
+     */
+    scope?: string[];
+    /**
+     * Remove default scopes of the provider
+     */
+    disableDefaultScope?: boolean;
+    /**
+     * The redirect URL for your application. This is where the provider will
+     * redirect the user after the sign in process. Make sure this URL is
+     * whitelisted in the provider's dashboard.
+     */
+    redirectURI?: string;
+    /**
+     * The client key of your application
+     * Tiktok Social Provider uses this field instead of clientId
+     */
+    clientKey?: string;
+    /**
+     * Disable provider from allowing users to sign in
+     * with this provider with an id token sent from the
+     * client.
+     */
+    disableIdTokenSignIn?: boolean;
+    /**
+     * verifyIdToken function to verify the id token
+     */
+    verifyIdToken?: (token: string, nonce?: string) => Promise<boolean>;
+    /**
+     * Custom function to get user info from the provider
+     */
+    getUserInfo?: (token: OAuth2Tokens) => Promise<{
+        user: {
+            id: string;
+            name?: string;
+            email?: string | null;
+            image?: string;
+            emailVerified: boolean;
+            [key: string]: any;
+        };
+        data: any;
+    }>;
+    /**
+     * Custom function to refresh a token
+     */
+    refreshAccessToken?: (refreshToken: string) => Promise<OAuth2Tokens>;
+    /**
+     * Custom function to map the provider profile to a
+     * user.
+     */
+    mapProfileToUser?: (profile: Profile) => {
+        id?: string;
+        name?: string;
+        email?: string | null;
+        image?: string;
+        emailVerified?: boolean;
+        [key: string]: any;
+    } | Promise<{
+        id?: string;
+        name?: string;
+        email?: string | null;
+        image?: string;
+        emailVerified?: boolean;
+        [key: string]: any;
+    }>;
+    /**
+     * Disable implicit sign up for new users. When set to true for the provider,
+     * sign-in need to be called with with requestSignUp as true to create new users.
+     */
+    disableImplicitSignUp?: boolean;
+    /**
+     * Disable sign up for new users.
+     */
+    disableSignUp?: boolean;
+    /**
+     * The prompt to use for the authorization code request
+     */
+    prompt?: "select_account" | "consent" | "login" | "none" | "select_account consent";
+    /**
+     * The response mode to use for the authorization code request
+     */
+    responseMode?: "query" | "form_post";
+    /**
+     * If enabled, the user info will be overridden with the provider user info
+     * This is useful if you want to use the provider user info to update the user info
+     *
+     * @default false
+     */
+    overrideUserInfoOnSignIn?: boolean;
+};
+
+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 { clientCredentialsToken, createAuthorizationCodeRequest, createAuthorizationURL, createClientCredentialsTokenRequest, createRefreshAccessTokenRequest, generateCodeChallenge, getOAuth2Tokens, refreshAccessToken, validateAuthorizationCode, validateToken };
+export type { OAuth2Tokens, OAuth2UserInfo, OAuthProvider, ProviderOptions };