@better-auth/core 1.6.25 → 1.6.27

package/dist/api/index.d.mts

@@ -6,14 +6,11 @@ import { AuthContext } from "../types/context.mjs";
 import "../types/index.mjs";
 import { OAuthProvider } from "../oauth2/oauth-provider.mjs";
 import "../oauth2/index.mjs";
-import { EndpointContext, EndpointOptions, StrictEndpoint } from "better-call";
+import { EndpointHandler, EndpointOptions, MiddlewareHandler, StrictEndpoint } from "better-call";
 //#region src/api/index.d.ts
-declare const optionsMiddleware: <InputCtx extends import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>>(inputContext: InputCtx) => Promise<AuthContext>;
+declare const optionsMiddleware: import("better-call").Middleware<import("better-call").MiddlewareOptions, <InputCtx extends import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>>(inputContext: InputCtx) => Promise<AuthContext>>;
 declare const createAuthMiddleware: {
-  <Options extends import("better-call").MiddlewareOptions, R>(options: Options, handler: (ctx: import("better-call").MiddlewareContext<Options, {
-    returned?: unknown | undefined;
-    responseHeaders?: Headers | undefined;
-  } & import("@better-auth/core").PluginContext<import("@better-auth/core").BetterAuthOptions> & import("@better-auth/core").InfoContext & {
+  <Options extends import("better-call").MiddlewareOptions, R>(options: Options, handler: (ctx: import("better-call").MiddlewareContext<Options, import("@better-auth/core").PluginContext<import("@better-auth/core").BetterAuthOptions> & import("@better-auth/core").InfoContext & {
     options: import("@better-auth/core").BetterAuthOptions;
     trustedOrigins: string[];
     trustedProviders: string[];
@@ -138,11 +135,11 @@ declare const createAuthMiddleware: {
     skipCSRFCheck: boolean;
     runInBackground: (promise: Promise<unknown>) => void;
     runInBackgroundOrAwait: (promise: Promise<unknown> | void) => import("@better-auth/core").Awaitable<unknown>;
-  }>) => Promise<R>): (inputContext: import("better-call").MiddlewareInputContext<Options>) => Promise<R>;
-  <Options extends import("better-call").MiddlewareOptions, R_1>(handler: (ctx: import("better-call").MiddlewareContext<Options, {
+  } & {
     returned?: unknown | undefined;
     responseHeaders?: Headers | undefined;
-  } & import("@better-auth/core").PluginContext<import("@better-auth/core").BetterAuthOptions> & import("@better-auth/core").InfoContext & {
+  }>) => Promise<R>): import("better-call").Middleware<Options, (inputContext: import("better-call").MiddlewareInputContext<Options>) => Promise<R>>;
+  <Options extends import("better-call").MiddlewareOptions, R_1>(handler: (ctx: import("better-call").MiddlewareContext<Options, import("@better-auth/core").PluginContext<import("@better-auth/core").BetterAuthOptions> & import("@better-auth/core").InfoContext & {
     options: import("@better-auth/core").BetterAuthOptions;
     trustedOrigins: string[];
     trustedProviders: string[];
@@ -267,15 +264,19 @@ declare const createAuthMiddleware: {
     skipCSRFCheck: boolean;
     runInBackground: (promise: Promise<unknown>) => void;
     runInBackgroundOrAwait: (promise: Promise<unknown> | void) => import("@better-auth/core").Awaitable<unknown>;
-  }>) => Promise<R_1>): (inputContext: import("better-call").MiddlewareInputContext<Options>) => Promise<R_1>;
+  } & {
+    returned?: unknown | undefined;
+    responseHeaders?: Headers | undefined;
+  }>) => Promise<R_1>): import("better-call").Middleware<Options, (inputContext: import("better-call").MiddlewareInputContext<Options>) => Promise<R_1>>;
 };
-type EndpointHandler<Path extends string, Options extends EndpointOptions, R> = (context: EndpointContext<Path, Options, AuthContext>) => Promise<R>;
-declare function createAuthEndpoint<Path extends string, Options extends EndpointOptions, R>(path: Path, options: Options, handler: EndpointHandler<Path, Options, R>): StrictEndpoint<Path, Options, R>;
-declare function createAuthEndpoint<Path extends string, Options extends EndpointOptions, R>(options: Options, handler: EndpointHandler<Path, Options, R>): StrictEndpoint<Path, Options, R>;
+type AuthEndpointHandler<Path extends string, Options extends EndpointOptions, R> = EndpointHandler<Path, Options, R, AuthContext>;
+type PathlessAuthEndpointHandler<Options extends EndpointOptions, R> = AuthEndpointHandler<string, Options, R>;
+declare function createAuthEndpoint<Path extends string, Options extends EndpointOptions, R>(path: Path, options: Options, handler: AuthEndpointHandler<Path, Options, R>): StrictEndpoint<Path, Options, R>;
+declare function createAuthEndpoint<InferredPath extends string, Options extends EndpointOptions, R>(options: Options, handler: PathlessAuthEndpointHandler<Options, R>): StrictEndpoint<InferredPath, Options, R>;
 declare namespace createAuthEndpoint {
-  var serverOnly: <Path extends string, Options extends EndpointOptions, R>(options: Options, handler: EndpointHandler<Path, Options, R>) => StrictEndpoint<Path, Options, R>;
+  var serverOnly: <InferredPath extends string, Options extends EndpointOptions, R>(options: Options, handler: PathlessAuthEndpointHandler<Options, R>) => StrictEndpoint<InferredPath, Options, R>;
 }
 type AuthEndpoint<Path extends string, Opts extends EndpointOptions, R> = ReturnType<typeof createAuthEndpoint<Path, Opts, R>>;
-type AuthMiddleware = ReturnType<typeof createAuthMiddleware>;
+type AuthMiddleware = MiddlewareHandler;
 //#endregion
 export { AuthEndpoint, AuthMiddleware, createAuthEndpoint, createAuthMiddleware, optionsMiddleware };

package/dist/api/index.mjs

@@ -29,28 +29,24 @@ const optionsMiddleware = createMiddleware(async () => {
 const createAuthMiddleware = createMiddleware.create({ use: [optionsMiddleware, createMiddleware(async () => {
 	return {};
 })] });
-const use = [optionsMiddleware];
-function createAuthEndpoint(pathOrOptions, handlerOrOptions, handlerOrNever) {
-	const path = typeof pathOrOptions === "string" ? pathOrOptions : void 0;
-	const options = typeof handlerOrOptions === "object" ? handlerOrOptions : pathOrOptions;
-	const handler = typeof handlerOrOptions === "function" ? handlerOrOptions : handlerOrNever;
-	const wrapped = async (ctx) => {
-		const runtimeCtx = ctx;
+const createEndpointWithAuthContext = createEndpoint.create({ use: [optionsMiddleware] });
+function wrapEndpointHandler(handler) {
+	return async (context) => {
 		try {
-			return await runWithEndpointContext(ctx, () => handler(ctx));
-		} catch (e) {
-			attachResponseHeadersToAPIError(runtimeCtx.responseHeaders, e);
-			throw e;
+			return await runWithEndpointContext(context, () => handler(context));
+		} catch (error) {
+			attachResponseHeadersToAPIError(context.responseHeaders, error);
+			throw error;
 		}
 	};
-	if (path) return createEndpoint(path, {
-		...options,
-		use: [...options?.use || [], ...use]
-	}, wrapped);
-	return createEndpoint({
-		...options,
-		use: [...options?.use || [], ...use]
-	}, wrapped);
+}
+function createAuthEndpoint(...args) {
+	if (args.length === 3) {
+		const [path, options, handler] = args;
+		return createEndpointWithAuthContext(path, options, wrapEndpointHandler(handler));
+	}
+	const [options, handler] = args;
+	return createEndpointWithAuthContext(options, wrapEndpointHandler(handler));
 }
 /**
 * Set `metadata.SERVER_ONLY` while preserving any existing metadata

package/dist/context/global.mjs

@@ -2,7 +2,7 @@
 const symbol = Symbol.for("better-auth:global");
 let bind = null;
 const __context = {};
-const __betterAuthVersion = "1.6.25";
+const __betterAuthVersion = "1.6.27";
 /**
 * We store context instance in the globalThis.
 *

package/dist/instrumentation/tracer.mjs

@@ -2,7 +2,7 @@ import { ATTR_HTTP_RESPONSE_STATUS_CODE } from "./attributes.mjs";
 import { getOpenTelemetryAPI } from "./api.mjs";
 //#region src/instrumentation/tracer.ts
 const INSTRUMENTATION_SCOPE = "better-auth";
-const INSTRUMENTATION_VERSION = "1.6.25";
+const INSTRUMENTATION_VERSION = "1.6.27";
 /**
 * Better-auth uses `throw ctx.redirect(url)` for flow control (e.g. OAuth
 * callbacks). These are APIErrors with 3xx status codes and should not be

package/dist/utils/email.d.mts

@@ -0,0 +1,19 @@
+//#region src/utils/email.d.ts
+interface PlaceholderEmailOptions {
+  /**
+   * A stable identifier that distinguishes the account within the namespace.
+   */
+  identifier: string;
+  /**
+   * A namespace that distinguishes identical identifiers from different sources.
+   */
+  namespace: string;
+}
+/**
+ * Creates a stable, non-routable email address for an account without an email.
+ *
+ * @throws TypeError if the generated email is invalid.
+ */
+declare function createPlaceholderEmail({ identifier, namespace }: PlaceholderEmailOptions): string;
+//#endregion
+export { PlaceholderEmailOptions, createPlaceholderEmail };

package/dist/utils/email.mjs

@@ -0,0 +1,18 @@
+import * as z from "zod";
+//#region src/utils/email.ts
+/**
+* @see https://www.rfc-editor.org/rfc/rfc6761.html#section-6.4
+*/
+const PLACEHOLDER_EMAIL_DOMAIN = "placeholder.invalid";
+/**
+* Creates a stable, non-routable email address for an account without an email.
+*
+* @throws TypeError if the generated email is invalid.
+*/
+function createPlaceholderEmail({ identifier, namespace }) {
+	const result = z.email().safeParse(`${identifier}@${namespace}.${PLACEHOLDER_EMAIL_DOMAIN}`);
+	if (!result.success) throw new TypeError("Invalid placeholder email");
+	return result.data;
+}
+//#endregion
+export { createPlaceholderEmail };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-auth/core",
-  "version": "1.6.25",
+  "version": "1.6.27",
   "description": "The most comprehensive authentication framework for TypeScript.",
   "type": "module",
   "license": "MIT",
@@ -155,9 +155,9 @@
     "@better-auth/utils": "0.4.2",
     "@better-fetch/fetch": "1.3.1",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/sdk-trace-base": "^1.30.0",
-    "@opentelemetry/sdk-trace-node": "^1.30.0",
-    "better-call": "1.3.7",
+    "@opentelemetry/sdk-trace-base": "^2.10.0",
+    "@opentelemetry/sdk-trace-node": "^2.10.0",
+    "better-call": "1.4.0",
     "@cloudflare/workers-types": "^4.20250121.0",
     "jose": "^6.1.3",
     "kysely": "^0.28.17 || ^0.29.0",
@@ -168,7 +168,7 @@
     "@better-auth/utils": "0.4.2",
     "@better-fetch/fetch": "1.3.1",
     "@opentelemetry/api": "^1.9.0",
-    "better-call": "1.3.7",
+    "better-call": "1.4.0",
     "@cloudflare/workers-types": ">=4",
     "jose": "^6.1.0",
     "kysely": "^0.28.5 || ^0.29.0",

package/src/api/index.ts

@@ -1,6 +1,7 @@
 import type {
-	EndpointContext,
+	EndpointHandler,
 	EndpointOptions,
+	MiddlewareHandler,
 	StrictEndpoint,
 } from "better-call";
 import {
@@ -56,13 +57,37 @@ export const createAuthMiddleware = createMiddleware.create({
 	],
 });
 
-const use = [optionsMiddleware];
+const createEndpointWithAuthContext = createEndpoint.create({
+	use: [optionsMiddleware],
+});
 
-type EndpointHandler<
+type AuthEndpointHandler<
 	Path extends string,
 	Options extends EndpointOptions,
 	R,
-> = (context: EndpointContext<Path, Options, AuthContext>) => Promise<R>;
+> = EndpointHandler<Path, Options, R, AuthContext>;
+
+type PathlessAuthEndpointHandler<
+	Options extends EndpointOptions,
+	R,
+> = AuthEndpointHandler<string, Options, R>;
+
+function wrapEndpointHandler<
+	Path extends string,
+	Options extends EndpointOptions,
+	R,
+>(
+	handler: AuthEndpointHandler<Path, Options, R>,
+): AuthEndpointHandler<Path, Options, R> {
+	return async (context) => {
+		try {
+			return await runWithEndpointContext(context, () => handler(context));
+		} catch (error) {
+			attachResponseHeadersToAPIError(context.responseHeaders, error);
+			throw error;
+		}
+	};
+}
 
 export function createAuthEndpoint<
 	Path extends string,
@@ -71,65 +96,42 @@ export function createAuthEndpoint<
 >(
 	path: Path,
 	options: Options,
-	handler: EndpointHandler<Path, Options, R>,
+	handler: AuthEndpointHandler<Path, Options, R>,
 ): StrictEndpoint<Path, Options, R>;
 
 export function createAuthEndpoint<
-	Path extends string,
+	InferredPath extends string,
 	Options extends EndpointOptions,
 	R,
 >(
 	options: Options,
-	handler: EndpointHandler<Path, Options, R>,
-): StrictEndpoint<Path, Options, R>;
+	handler: PathlessAuthEndpointHandler<Options, R>,
+): StrictEndpoint<InferredPath, Options, R>;
 
 export function createAuthEndpoint<
 	Path extends string,
-	Opts extends EndpointOptions,
+	Options extends EndpointOptions,
 	R,
 >(
-	pathOrOptions: Path | Opts,
-	handlerOrOptions: EndpointHandler<Path, Opts, R> | Opts,
-	handlerOrNever?: any,
+	...args:
+		| [
+				path: Path,
+				options: Options,
+				handler: AuthEndpointHandler<Path, Options, R>,
+		  ]
+		| [options: Options, handler: PathlessAuthEndpointHandler<Options, R>]
 ) {
-	const path: Path | undefined =
-		typeof pathOrOptions === "string" ? pathOrOptions : undefined;
-	const options: Opts =
-		typeof handlerOrOptions === "object"
-			? handlerOrOptions
-			: (pathOrOptions as Opts);
-	const handler: EndpointHandler<Path, Opts, R> =
-		typeof handlerOrOptions === "function" ? handlerOrOptions : handlerOrNever;
-
-	// todo: prettify the code, we want to call `runWithEndpointContext` to top level
-	const wrapped: EndpointHandler<Path, Opts, R> = async (ctx) => {
-		const runtimeCtx = ctx as unknown as { responseHeaders?: Headers };
-		try {
-			return await runWithEndpointContext(ctx as any, () => handler(ctx));
-		} catch (e) {
-			attachResponseHeadersToAPIError(runtimeCtx.responseHeaders, e);
-			throw e;
-		}
-	};
-
-	if (path) {
-		return createEndpoint(
+	if (args.length === 3) {
+		const [path, options, handler] = args;
+		return createEndpointWithAuthContext(
 			path,
-			{
-				...options,
-				use: [...(options?.use || []), ...use],
-			},
-			wrapped,
+			options,
+			wrapEndpointHandler(handler),
 		);
 	}
 
-	return createEndpoint(
-		{
-			...options,
-			use: [...(options?.use || []), ...use],
-		},
-		wrapped,
-	);
+	const [options, handler] = args;
+	return createEndpointWithAuthContext(options, wrapEndpointHandler(handler));
 }
 
 /**
@@ -168,18 +170,22 @@ function withServerOnly<Options extends EndpointOptions>(
  * ```
  */
 createAuthEndpoint.serverOnly = <
-	Path extends string,
+	InferredPath extends string,
 	Options extends EndpointOptions,
 	R,
 >(
 	options: Options,
-	handler: EndpointHandler<Path, Options, R>,
-): StrictEndpoint<Path, Options, R> =>
-	createAuthEndpoint(withServerOnly(options), handler);
+	handler: PathlessAuthEndpointHandler<Options, R>,
+): StrictEndpoint<InferredPath, Options, R> =>
+	createAuthEndpoint<InferredPath, Options, R>(
+		withServerOnly(options),
+		handler,
+	);
 
 export type AuthEndpoint<
 	Path extends string,
 	Opts extends EndpointOptions,
 	R,
 > = ReturnType<typeof createAuthEndpoint<Path, Opts, R>>;
-export type AuthMiddleware = ReturnType<typeof createAuthMiddleware>;
+
+export type AuthMiddleware = MiddlewareHandler;

package/src/utils/email.ts

@@ -0,0 +1,36 @@
+import * as z from "zod";
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc6761.html#section-6.4
+ */
+const PLACEHOLDER_EMAIL_DOMAIN = "placeholder.invalid";
+
+export interface PlaceholderEmailOptions {
+	/**
+	 * A stable identifier that distinguishes the account within the namespace.
+	 */
+	identifier: string;
+	/**
+	 * A namespace that distinguishes identical identifiers from different sources.
+	 */
+	namespace: string;
+}
+
+/**
+ * Creates a stable, non-routable email address for an account without an email.
+ *
+ * @throws TypeError if the generated email is invalid.
+ */
+export function createPlaceholderEmail({
+	identifier,
+	namespace,
+}: PlaceholderEmailOptions): string {
+	const result = z
+		.email()
+		.safeParse(`${identifier}@${namespace}.${PLACEHOLDER_EMAIL_DOMAIN}`);
+	if (!result.success) {
+		throw new TypeError("Invalid placeholder email");
+	}
+
+	return result.data;
+}