@depup/better-auth__core 1.6.23-depup.2

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.ts

@@ -0,0 +1,91 @@
+import type { AsyncLocalStorage } from "@better-auth/core/async_hooks";
+import { getAsyncLocalStorage } from "@better-auth/core/async_hooks";
+import { __getBetterAuthGlobal } from "./global";
+
+export type RequestStateWeakMap = WeakMap<object, any>;
+
+const ensureAsyncStorage = async () => {
+	const betterAuthGlobal = __getBetterAuthGlobal();
+	if (!betterAuthGlobal.context.requestStateAsyncStorage) {
+		const AsyncLocalStorage = await getAsyncLocalStorage();
+		betterAuthGlobal.context.requestStateAsyncStorage =
+			new AsyncLocalStorage<RequestStateWeakMap>();
+	}
+	return betterAuthGlobal.context
+		.requestStateAsyncStorage as AsyncLocalStorage<RequestStateWeakMap>;
+};
+
+export async function getRequestStateAsyncLocalStorage() {
+	return ensureAsyncStorage();
+}
+
+export async function hasRequestState() {
+	const als = await ensureAsyncStorage();
+	return als.getStore() !== undefined;
+}
+
+export async function getCurrentRequestState(): Promise<RequestStateWeakMap> {
+	const als = await ensureAsyncStorage();
+	const store = als.getStore();
+	if (!store) {
+		throw new Error(
+			"No request state found. Please make sure you are calling this function within a `runWithRequestState` callback.",
+		);
+	}
+	return store;
+}
+
+export async function runWithRequestState<T>(
+	store: RequestStateWeakMap,
+	fn: () => T,
+): Promise<T> {
+	const als = await ensureAsyncStorage();
+	return als.run(store, fn);
+}
+
+export interface RequestState<T> {
+	get(): Promise<T>;
+	set(value: T): Promise<void>;
+
+	// A unique reference used as a key to identify this state within the request's WeakMap. Useful for debugging purposes.
+	readonly ref: Readonly<object>;
+}
+
+/**
+ * Defines a request-scoped state with lazy initialization.
+ *
+ * @param initFn - A function that initializes the state. It is called the first time `get()` is invoked within each request context, and only once per context.
+ * @returns A RequestState object with `get` and `set` methods, and a unique `ref` for debugging.
+ *
+ * @example
+ * const userState = defineRequestState(() => ({ id: '', name: '' }));
+ * // Later, within a request context:
+ * const user = await userState.get();
+ */
+export function defineRequestState<T>(
+	initFn: () => T | Promise<T>,
+): RequestState<T>;
+export function defineRequestState(
+	initFn: () => any | Promise<any>,
+): RequestState<any> {
+	const ref = Object.freeze({});
+	return {
+		get ref(): Readonly<object> {
+			return ref;
+		},
+		async get() {
+			const store = await getCurrentRequestState();
+			if (!store.has(ref)) {
+				const initialValue = await initFn();
+				store.set(ref, initialValue);
+				return initialValue;
+			}
+			return store.get(ref);
+		},
+
+		async set(value) {
+			const store = await getCurrentRequestState();
+			store.set(ref, value);
+		},
+	};
+}

package/src/context/transaction.ts

@@ -0,0 +1,169 @@
+import type { AsyncLocalStorage } from "node:async_hooks";
+import { getAsyncLocalStorage } from "@better-auth/core/async_hooks";
+import type { DBAdapter, DBTransactionAdapter } from "../db/adapter";
+import type { BetterAuthOptions } from "../types";
+import { __getBetterAuthGlobal } from "./global";
+
+type StoredAdapter = DBTransactionAdapter<BetterAuthOptions>;
+
+type HookContext = {
+	adapter: StoredAdapter;
+	pendingHooks: Array<() => Promise<void>>;
+	isTransactionActive: boolean;
+};
+
+const ensureAsyncStorage = async () => {
+	const betterAuthGlobal = __getBetterAuthGlobal();
+	if (!betterAuthGlobal.context.adapterAsyncStorage) {
+		const AsyncLocalStorage = await getAsyncLocalStorage();
+		betterAuthGlobal.context.adapterAsyncStorage = new AsyncLocalStorage();
+	}
+	return betterAuthGlobal.context
+		.adapterAsyncStorage as AsyncLocalStorage<HookContext>;
+};
+
+/**
+ * This is for internal use only. Most users should use `getCurrentAdapter` instead.
+ *
+ * It is exposed for advanced use cases where you need direct access to the AsyncLocalStorage instance.
+ */
+export const getCurrentDBAdapterAsyncLocalStorage = async () => {
+	return ensureAsyncStorage();
+};
+
+export const getCurrentAdapter = async <
+	Options extends BetterAuthOptions = BetterAuthOptions,
+>(
+	fallback: DBTransactionAdapter<Options>,
+): Promise<DBTransactionAdapter<Options>> => {
+	return ensureAsyncStorage()
+		.then((als) => {
+			const store = als.getStore();
+			return (
+				(store?.adapter as DBTransactionAdapter<Options> | undefined) ||
+				fallback
+			);
+		})
+		.catch(() => {
+			return fallback;
+		});
+};
+
+export const runWithAdapter = async <
+	R,
+	Options extends BetterAuthOptions = BetterAuthOptions,
+>(
+	adapter: DBAdapter<Options>,
+	fn: () => R,
+): Promise<R> => {
+	let called = false;
+	return ensureAsyncStorage()
+		.then(async (als) => {
+			called = true;
+			const pendingHooks: Array<() => Promise<void>> = [];
+			let result: Awaited<R>;
+			let error: unknown;
+			let hasError = false;
+			try {
+				result = await als.run(
+					{
+						adapter: adapter as unknown as StoredAdapter,
+						pendingHooks,
+						isTransactionActive: false,
+					},
+					fn,
+				);
+			} catch (err) {
+				error = err;
+				hasError = true;
+			}
+			// Execute pending hooks after the function completes (even if it threw)
+			for (const hook of pendingHooks) {
+				await hook();
+			}
+			if (hasError) {
+				throw error;
+			}
+			return result!;
+		})
+		.catch((err) => {
+			if (!called) {
+				return fn();
+			}
+			throw err;
+		});
+};
+
+export const runWithTransaction = async <
+	R,
+	Options extends BetterAuthOptions = BetterAuthOptions,
+>(
+	adapter: DBAdapter<Options>,
+	fn: () => R,
+): Promise<R> => {
+	let called = false;
+	return ensureAsyncStorage()
+		.then(async (als) => {
+			called = true;
+			const store = als.getStore();
+			if (store?.isTransactionActive) {
+				return fn();
+			}
+			const pendingHooks: Array<() => Promise<void>> = [];
+			let result: Awaited<R>;
+			let error: unknown;
+			let hasError = false;
+			try {
+				result = await adapter.transaction(async (trx) => {
+					return als.run(
+						{
+							adapter: trx as unknown as StoredAdapter,
+							pendingHooks,
+							isTransactionActive: true,
+						},
+						fn,
+					);
+				});
+			} catch (e) {
+				hasError = true;
+				error = e;
+			}
+			for (const hook of pendingHooks) {
+				await hook();
+			}
+			if (hasError) {
+				throw error;
+			}
+			return result!;
+		})
+		.catch((err) => {
+			if (!called) {
+				return fn();
+			}
+			throw err;
+		});
+};
+
+/**
+ * Queue a hook to be executed after the current transaction commits.
+ * If not in a transaction, the hook will execute immediately.
+ */
+export const queueAfterTransactionHook = async (
+	hook: () => Promise<void>,
+): Promise<void> => {
+	return ensureAsyncStorage()
+		.then((als) => {
+			const store = als.getStore();
+			if (store) {
+				// We're in a transaction context, queue the hook
+				store.pendingHooks.push(hook);
+			} else {
+				// Not in a transaction, execute immediately
+				return hook();
+			}
+		})
+		.catch(() => {
+			// No async storage available, execute immediately
+			return hook();
+		});
+};