@hammadj/better-auth-core 1.5.0-beta.9

package/dist/utils/url.mjs

@@ -0,0 +1,33 @@
+//#region src/utils/url.ts
+/**
+* Normalizes a request pathname by removing the basePath prefix and trailing slashes.
+* This is useful for matching paths against configured path lists.
+*
+* @param requestUrl - The full request URL
+* @param basePath - The base path of the auth API (e.g., "/api/auth")
+* @returns The normalized path without basePath prefix or trailing slashes,
+*          or "/" if URL parsing fails
+*
+* @example
+* normalizePathname("http://localhost:3000/api/auth/sso/saml2/callback/provider1", "/api/auth")
+* // Returns: "/sso/saml2/callback/provider1"
+*
+* normalizePathname("http://localhost:3000/sso/saml2/callback/provider1/", "/")
+* // Returns: "/sso/saml2/callback/provider1"
+*/
+function normalizePathname(requestUrl, basePath) {
+	let pathname;
+	try {
+		pathname = new URL(requestUrl).pathname.replace(/\/+$/, "") || "/";
+	} catch {
+		return "/";
+	}
+	if (basePath === "/" || basePath === "") return pathname;
+	if (pathname === basePath) return "/";
+	if (pathname.startsWith(basePath + "/")) return pathname.slice(basePath.length).replace(/\/+$/, "") || "/";
+	return pathname;
+}
+
+//#endregion
+export { normalizePathname };
+//# sourceMappingURL=url.mjs.map

package/dist/utils/url.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.mjs","names":[],"sources":["../../src/utils/url.ts"],"sourcesContent":["/**\n * Normalizes a request pathname by removing the basePath prefix and trailing slashes.\n * This is useful for matching paths against configured path lists.\n *\n * @param requestUrl - The full request URL\n * @param basePath - The base path of the auth API (e.g., \"/api/auth\")\n * @returns The normalized path without basePath prefix or trailing slashes,\n *          or \"/\" if URL parsing fails\n *\n * @example\n * normalizePathname(\"http://localhost:3000/api/auth/sso/saml2/callback/provider1\", \"/api/auth\")\n * // Returns: \"/sso/saml2/callback/provider1\"\n *\n * normalizePathname(\"http://localhost:3000/sso/saml2/callback/provider1/\", \"/\")\n * // Returns: \"/sso/saml2/callback/provider1\"\n */\nexport function normalizePathname(\n\trequestUrl: string,\n\tbasePath: string,\n): string {\n\tlet pathname: string;\n\ttry {\n\t\tpathname = new URL(requestUrl).pathname.replace(/\\/+$/, \"\") || \"/\";\n\t} catch {\n\t\treturn \"/\";\n\t}\n\n\tif (basePath === \"/\" || basePath === \"\") {\n\t\treturn pathname;\n\t}\n\n\t// Check for exact match or proper path boundary (basePath followed by \"/\" or end)\n\t// This prevents \"/api/auth\" from matching \"/api/authevil/...\"\n\tif (pathname === basePath) {\n\t\treturn \"/\";\n\t}\n\n\tif (pathname.startsWith(basePath + \"/\")) {\n\t\treturn pathname.slice(basePath.length).replace(/\\/+$/, \"\") || \"/\";\n\t}\n\n\treturn pathname;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,SAAgB,kBACf,YACA,UACS;CACT,IAAI;AACJ,KAAI;AACH,aAAW,IAAI,IAAI,WAAW,CAAC,SAAS,QAAQ,QAAQ,GAAG,IAAI;SACxD;AACP,SAAO;;AAGR,KAAI,aAAa,OAAO,aAAa,GACpC,QAAO;AAKR,KAAI,aAAa,SAChB,QAAO;AAGR,KAAI,SAAS,WAAW,WAAW,IAAI,CACtC,QAAO,SAAS,MAAM,SAAS,OAAO,CAAC,QAAQ,QAAQ,GAAG,IAAI;AAG/D,QAAO"}

package/package.json

@@ -0,0 +1,147 @@
+{
+  "name": "@hammadj/better-auth-core",
+  "version": "1.5.0-beta.9",
+  "description": "The most comprehensive authentication framework for TypeScript.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/META-DREAMER/better-auth.git",
+    "directory": "packages/core"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "dev-source": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./api": {
+      "dev-source": "./src/api/index.ts",
+      "types": "./dist/api/index.d.mts",
+      "default": "./dist/api/index.mjs"
+    },
+    "./async_hooks": {
+      "dev-source": "./src/async_hooks/index.ts",
+      "types": "./dist/async_hooks/index.d.mts",
+      "node": "./dist/async_hooks/index.mjs",
+      "deno": "./dist/async_hooks/index.mjs",
+      "bun": "./dist/async_hooks/index.mjs",
+      "edge": "./dist/async_hooks/pure.index.mjs",
+      "workerd": "./dist/async_hooks/index.mjs",
+      "browser": "./dist/async_hooks/pure.index.mjs",
+      "default": "./dist/async_hooks/index.mjs"
+    },
+    "./context": {
+      "dev-source": "./src/context/index.ts",
+      "types": "./dist/context/index.d.mts",
+      "default": "./dist/context/index.mjs"
+    },
+    "./env": {
+      "dev-source": "./src/env/index.ts",
+      "types": "./dist/env/index.d.mts",
+      "default": "./dist/env/index.mjs"
+    },
+    "./error": {
+      "dev-source": "./src/error/index.ts",
+      "types": "./dist/error/index.d.mts",
+      "default": "./dist/error/index.mjs"
+    },
+    "./utils/*": {
+      "dev-source": "./src/utils/*.ts",
+      "types": "./dist/utils/*.d.mts",
+      "default": "./dist/utils/*.mjs"
+    },
+    "./social-providers": {
+      "dev-source": "./src/social-providers/index.ts",
+      "types": "./dist/social-providers/index.d.mts",
+      "default": "./dist/social-providers/index.mjs"
+    },
+    "./db": {
+      "dev-source": "./src/db/index.ts",
+      "types": "./dist/db/index.d.mts",
+      "default": "./dist/db/index.mjs"
+    },
+    "./db/adapter": {
+      "dev-source": "./src/db/adapter/index.ts",
+      "types": "./dist/db/adapter/index.d.mts",
+      "default": "./dist/db/adapter/index.mjs"
+    },
+    "./oauth2": {
+      "dev-source": "./src/oauth2/index.ts",
+      "types": "./dist/oauth2/index.d.mts",
+      "default": "./dist/oauth2/index.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "dist/index.d.mts"
+      ],
+      "api": [
+        "dist/api/index.d.mts"
+      ],
+      "async_hooks": [
+        "dist/async_hooks/index.d.mts"
+      ],
+      "context": [
+        "dist/context/index.d.mts"
+      ],
+      "env": [
+        "dist/env/index.d.mts"
+      ],
+      "error": [
+        "dist/error/index.d.mts"
+      ],
+      "utils": [
+        "dist/utils/index.d.mts"
+      ],
+      "utils/*": [
+        "dist/utils/*.d.mts"
+      ],
+      "social-providers": [
+        "dist/social-providers/index.d.mts"
+      ],
+      "db": [
+        "dist/db/index.d.mts"
+      ],
+      "db/adapter": [
+        "dist/db/adapter/index.d.mts"
+      ],
+      "oauth2": [
+        "dist/oauth2/index.d.mts"
+      ]
+    }
+  },
+  "devDependencies": {
+    "@better-auth/utils": "0.3.1",
+    "@better-fetch/fetch": "1.1.21",
+    "better-call": "1.2.0",
+    "jose": "^6.1.0",
+    "kysely": "^0.28.10",
+    "nanostores": "^1.1.0",
+    "tsdown": "^0.20.1"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "@better-auth/utils": "0.3.1",
+    "@better-fetch/fetch": "1.1.21",
+    "better-call": "1.2.0",
+    "jose": "^6.1.0",
+    "kysely": "^0.28.5",
+    "nanostores": "^1.0.1"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint:package": "publint run --strict",
+    "lint:types": "attw --profile esm-only --pack .",
+    "typecheck": "tsc --project tsconfig.json",
+    "test": "vitest",
+    "coverage": "vitest run --coverage --coverage.provider=istanbul"
+  }
+}

package/src/api/index.ts

@@ -0,0 +1,106 @@
+import type {
+	EndpointContext,
+	EndpointOptions,
+	StrictEndpoint,
+} from "better-call";
+import { createEndpoint, createMiddleware } from "better-call";
+import { runWithEndpointContext } from "../context";
+import type { AuthContext } from "../types";
+
+export const optionsMiddleware = createMiddleware(async () => {
+	/**
+	 * This will be passed on the instance of
+	 * the context. Used to infer the type
+	 * here.
+	 */
+	return {} as AuthContext;
+});
+
+export const createAuthMiddleware = createMiddleware.create({
+	use: [
+		optionsMiddleware,
+		/**
+		 * Only use for post hooks
+		 */
+		createMiddleware(async () => {
+			return {} as {
+				returned?: unknown | undefined;
+				responseHeaders?: Headers | undefined;
+			};
+		}),
+	],
+});
+
+const use = [optionsMiddleware];
+
+type EndpointHandler<
+	Path extends string,
+	Options extends EndpointOptions,
+	R,
+> = (context: EndpointContext<Path, Options, AuthContext>) => Promise<R>;
+
+export function createAuthEndpoint<
+	Path extends string,
+	Options extends EndpointOptions,
+	R,
+>(
+	path: Path,
+	options: Options,
+	handler: EndpointHandler<Path, Options, R>,
+): StrictEndpoint<Path, Options, R>;
+
+export function createAuthEndpoint<
+	Path extends string,
+	Options extends EndpointOptions,
+	R,
+>(
+	options: Options,
+	handler: EndpointHandler<Path, Options, R>,
+): StrictEndpoint<Path, Options, R>;
+
+export function createAuthEndpoint<
+	Path extends string,
+	Opts extends EndpointOptions,
+	R,
+>(
+	pathOrOptions: Path | Opts,
+	handlerOrOptions: EndpointHandler<Path, Opts, R> | Opts,
+	handlerOrNever?: any,
+) {
+	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;
+
+	if (path) {
+		return createEndpoint(
+			path,
+			{
+				...options,
+				use: [...(options?.use || []), ...use],
+			},
+			// todo: prettify the code, we want to call `runWithEndpointContext` to top level
+			async (ctx) => runWithEndpointContext(ctx as any, () => handler(ctx)),
+		);
+	}
+
+	return createEndpoint(
+		{
+			...options,
+			use: [...(options?.use || []), ...use],
+		},
+		// todo: prettify the code, we want to call `runWithEndpointContext` to top level
+		async (ctx) => runWithEndpointContext(ctx as any, () => handler(ctx)),
+	);
+}
+
+export type AuthEndpoint<
+	Path extends string,
+	Opts extends EndpointOptions,
+	R,
+> = ReturnType<typeof createAuthEndpoint<Path, Opts, R>>;
+export type AuthMiddleware = ReturnType<typeof createAuthMiddleware>;

package/src/async_hooks/index.ts

@@ -0,0 +1,40 @@
+import type { AsyncLocalStorage } from "node:async_hooks";
+
+export type { AsyncLocalStorage };
+
+const AsyncLocalStoragePromise: Promise<typeof AsyncLocalStorage | null> =
+	import(
+		/* @vite-ignore */
+		/* webpackIgnore: true */
+		"node:async_hooks"
+	)
+		.then((mod) => mod.AsyncLocalStorage)
+		.catch((err) => {
+			if ("AsyncLocalStorage" in globalThis) {
+				return (globalThis as any).AsyncLocalStorage;
+			}
+			if (typeof window !== "undefined") {
+				return null;
+			}
+			console.warn(
+				"[better-auth] Warning: AsyncLocalStorage is not available in this environment. Some features may not work as expected.",
+			);
+			console.warn(
+				"[better-auth] Please read more about this warning at https://better-auth.com/docs/installation#mount-handler",
+			);
+			console.warn(
+				"[better-auth] If you are using Cloudflare Workers, please see: https://developers.cloudflare.com/workers/configuration/compatibility-flags/#nodejs-compatibility-flag",
+			);
+			throw err;
+		});
+
+export async function getAsyncLocalStorage(): Promise<
+	typeof AsyncLocalStorage
+> {
+	const mod = await AsyncLocalStoragePromise;
+	if (mod === null) {
+		throw new Error("getAsyncLocalStorage is only available in server code");
+	} else {
+		return mod;
+	}
+}

package/src/async_hooks/pure.index.ts

@@ -0,0 +1,46 @@
+import type { AsyncLocalStorage } from "node:async_hooks";
+
+/**
+ * Due to the lack of AsyncLocalStorage in some environments (like Convex),
+ *
+ * We assume serverless functions are short-lived and single-threaded, so we can use a simple polyfill.
+ */
+class AsyncLocalStoragePolyfill<T> {
+	#current: T | undefined = undefined;
+
+	run(store: T, fn: () => unknown): unknown {
+		const prev = this.#current;
+		this.#current = store;
+		const result = fn();
+		if (result instanceof Promise) {
+			return result.finally(() => {
+				this.#current = prev;
+			});
+		}
+		this.#current = prev;
+		return result;
+	}
+
+	getStore(): T | undefined {
+		return this.#current;
+	}
+}
+
+const AsyncLocalStoragePromise: Promise<typeof AsyncLocalStorage | null> =
+	Promise.resolve().then(() => {
+		if ("AsyncLocalStorage" in globalThis) {
+			return (globalThis as any).AsyncLocalStorage;
+		}
+		return AsyncLocalStoragePolyfill;
+	});
+
+export async function getAsyncLocalStorage(): Promise<
+	typeof AsyncLocalStorage
+> {
+	const mod = await AsyncLocalStoragePromise;
+	if (mod === null) {
+		throw new Error("getAsyncLocalStorage is only available in server code");
+	} else {
+		return mod;
+	}
+}

package/src/context/endpoint-context.ts

@@ -0,0 +1,50 @@
+import type { AsyncLocalStorage } from "@better-auth/core/async_hooks";
+import { getAsyncLocalStorage } from "@better-auth/core/async_hooks";
+import type { EndpointContext, InputContext } from "better-call";
+import type { AuthContext } from "../types";
+import { __getBetterAuthGlobal } from "./global";
+
+export type AuthEndpointContext = Partial<
+	InputContext<string, any> & EndpointContext<string, any>
+> & {
+	context: AuthContext;
+};
+
+const ensureAsyncStorage = async () => {
+	const betterAuthGlobal = __getBetterAuthGlobal();
+	if (!betterAuthGlobal.context.endpointContextAsyncStorage) {
+		const AsyncLocalStorage = await getAsyncLocalStorage();
+		betterAuthGlobal.context.endpointContextAsyncStorage =
+			new AsyncLocalStorage<AuthEndpointContext>();
+	}
+	return betterAuthGlobal.context
+		.endpointContextAsyncStorage as AsyncLocalStorage<AuthEndpointContext>;
+};
+
+/**
+ * This is for internal use only. Most users should use `getCurrentAuthContext` instead.
+ *
+ * It is exposed for advanced use cases where you need direct access to the AsyncLocalStorage instance.
+ */
+export async function getCurrentAuthContextAsyncLocalStorage() {
+	return ensureAsyncStorage();
+}
+
+export async function getCurrentAuthContext(): Promise<AuthEndpointContext> {
+	const als = await ensureAsyncStorage();
+	const context = als.getStore();
+	if (!context) {
+		throw new Error(
+			"No auth context found. Please make sure you are calling this function within a `runWithEndpointContext` callback.",
+		);
+	}
+	return context;
+}
+
+export async function runWithEndpointContext<T>(
+	context: AuthEndpointContext,
+	fn: () => T,
+): Promise<T> {
+	const als = await ensureAsyncStorage();
+	return als.run(context, fn);
+}

package/src/context/global.ts

@@ -0,0 +1,57 @@
+import type { AsyncLocalStorage } from "@better-auth/core/async_hooks";
+
+interface BetterAuthGlobal {
+	/**
+	 * The version of BetterAuth.
+	 */
+	version: string;
+	/**
+	 * Used to track the number of BetterAuth instances in the same process.
+	 *
+	 * Debugging purposes only.
+	 */
+	epoch: number;
+	/**
+	 * Stores the AsyncLocalStorage instances for each context.
+	 */
+	context: Record<string, AsyncLocalStorage<unknown>>;
+}
+
+const symbol = Symbol.for("better-auth:global");
+let bind: BetterAuthGlobal | null = null;
+
+const __context: Record<string, AsyncLocalStorage<unknown>> = {};
+const __betterAuthVersion: string = import.meta.env
+	.BETTER_AUTH_VERSION as string;
+
+/**
+ * We store context instance in the globalThis.
+ *
+ * The reason we do this is that some bundlers, web framework, or package managers might
+ * create multiple copies of BetterAuth in the same process intentionally or unintentionally.
+ *
+ * For example, yarn v1, Next.js, SSR, Vite...
+ *
+ * @internal
+ */
+export function __getBetterAuthGlobal(): BetterAuthGlobal {
+	if (!(globalThis as any)[symbol]) {
+		(globalThis as any)[symbol] = {
+			version: __betterAuthVersion,
+			epoch: 1,
+			context: __context,
+		};
+		bind = (globalThis as any)[symbol] as BetterAuthGlobal;
+	}
+	bind = (globalThis as any)[symbol] as BetterAuthGlobal;
+	if (bind.version !== __betterAuthVersion) {
+		bind.version = __betterAuthVersion;
+		// Different versions of BetterAuth are loaded in the same process.
+		bind.epoch++;
+	}
+	return (globalThis as any)[symbol] as BetterAuthGlobal;
+}
+
+export function getBetterAuthVersion(): string {
+	return __getBetterAuthGlobal().version;
+}

package/src/context/index.ts

@@ -0,0 +1,23 @@
+export {
+	type AuthEndpointContext,
+	getCurrentAuthContext,
+	getCurrentAuthContextAsyncLocalStorage,
+	runWithEndpointContext,
+} from "./endpoint-context";
+export { getBetterAuthVersion } from "./global";
+export {
+	defineRequestState,
+	getCurrentRequestState,
+	getRequestStateAsyncLocalStorage,
+	hasRequestState,
+	type RequestState,
+	type RequestStateWeakMap,
+	runWithRequestState,
+} from "./request-state";
+export {
+	getCurrentAdapter,
+	getCurrentDBAdapterAsyncLocalStorage,
+	queueAfterTransactionHook,
+	runWithAdapter,
+	runWithTransaction,
+} from "./transaction";

package/src/context/request-state.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "vitest";
+import type { RequestStateWeakMap } from "./request-state";
+import {
+	defineRequestState,
+	getCurrentRequestState,
+	hasRequestState,
+	runWithRequestState,
+} from "./request-state";
+
+describe("request-state", () => {
+	describe("runWithRequestState", () => {
+		it("should execute function within request state context", async () => {
+			const store: RequestStateWeakMap = new WeakMap();
+			const result = await runWithRequestState(store, async () => {
+				const hasStore = await hasRequestState();
+				expect(hasStore).toBe(true);
+				return "success";
+			});
+			expect(result).toBe("success");
+		});
+
+		it("should isolate request states between concurrent requests", async () => {
+			const store1: RequestStateWeakMap = new WeakMap();
+			const store2: RequestStateWeakMap = new WeakMap();
+
+			const { get, set } = defineRequestState(() => ({}) as { id: string });
+
+			const [result1, result2] = await Promise.all([
+				runWithRequestState(store1, async () => {
+					await set({ id: "store1" });
+					// Simulate some async work
+					await new Promise((resolve) => setTimeout(resolve, 10));
+					return await get();
+				}),
+				runWithRequestState(store2, async () => {
+					await set({ id: "store2" });
+					// Simulate some async work
+					await new Promise((resolve) => setTimeout(resolve, 5));
+					return await get();
+				}),
+			]);
+
+			expect(result1).toEqual({ id: "store1" });
+			expect(result2).toEqual({ id: "store2" });
+		});
+
+		it("should support nested async operations", async () => {
+			const store: RequestStateWeakMap = new WeakMap();
+			const { get, set } = defineRequestState(() => ({ value: 1 }));
+
+			await runWithRequestState(store, async () => {
+				const nestedResult = await (async () => {
+					const current = await get();
+					await set({ value: (current?.value || 0) + 1 });
+					return await get();
+				})();
+
+				expect(nestedResult).toEqual({ value: 2 });
+				expect(await get()).toEqual({ value: 2 });
+			});
+		});
+	});
+
+	describe("hasRequestState", () => {
+		it("should return false when not in request state context", async () => {
+			const hasStore = await hasRequestState();
+			expect(hasStore).toBe(false);
+		});
+
+		it("should return true when in request state context", async () => {
+			const store: RequestStateWeakMap = new WeakMap();
+			await runWithRequestState(store, async () => {
+				const hasStore = await hasRequestState();
+				expect(hasStore).toBe(true);
+			});
+		});
+	});
+
+	describe("getCurrentRequestState", () => {
+		it("should throw error when not in request state context", async () => {
+			await expect(getCurrentRequestState()).rejects.toThrow(
+				"No request state found",
+			);
+		});
+
+		it("should return the current store when in context", async () => {
+			const store: RequestStateWeakMap = new WeakMap();
+			await runWithRequestState(store, async () => {
+				const currentStore = await getCurrentRequestState();
+				expect(currentStore).toBe(store);
+			});
+		});
+	});
+});