@depup/better-auth__core 1.6.23-depup.2

package/dist/context/request-state.mjs

@@ -0,0 +1,47 @@
+import { __getBetterAuthGlobal } from "./global.mjs";
+import { getAsyncLocalStorage } from "@better-auth/core/async_hooks";
+//#region src/context/request-state.ts
+const ensureAsyncStorage = async () => {
+	const betterAuthGlobal = __getBetterAuthGlobal();
+	if (!betterAuthGlobal.context.requestStateAsyncStorage) {
+		const AsyncLocalStorage = await getAsyncLocalStorage();
+		betterAuthGlobal.context.requestStateAsyncStorage = new AsyncLocalStorage();
+	}
+	return betterAuthGlobal.context.requestStateAsyncStorage;
+};
+async function getRequestStateAsyncLocalStorage() {
+	return ensureAsyncStorage();
+}
+async function hasRequestState() {
+	return (await ensureAsyncStorage()).getStore() !== void 0;
+}
+async function getCurrentRequestState() {
+	const store = (await ensureAsyncStorage()).getStore();
+	if (!store) throw new Error("No request state found. Please make sure you are calling this function within a `runWithRequestState` callback.");
+	return store;
+}
+async function runWithRequestState(store, fn) {
+	return (await ensureAsyncStorage()).run(store, fn);
+}
+function defineRequestState(initFn) {
+	const ref = Object.freeze({});
+	return {
+		get ref() {
+			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) {
+			(await getCurrentRequestState()).set(ref, value);
+		}
+	};
+}
+//#endregion
+export { defineRequestState, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, runWithRequestState };

package/dist/context/transaction.d.mts

@@ -0,0 +1,27 @@
+import { DBAdapter, DBTransactionAdapter } from "../db/adapter/index.mjs";
+import { BetterAuthOptions } from "../types/init-options.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/context/transaction.d.ts
+type StoredAdapter = DBTransactionAdapter<BetterAuthOptions>;
+type HookContext = {
+  adapter: StoredAdapter;
+  pendingHooks: Array<() => Promise<void>>;
+  isTransactionActive: boolean;
+};
+/**
+ * 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.
+ */
+declare const getCurrentDBAdapterAsyncLocalStorage: () => Promise<AsyncLocalStorage<HookContext>>;
+declare const getCurrentAdapter: <Options extends BetterAuthOptions = BetterAuthOptions>(fallback: DBTransactionAdapter<Options>) => Promise<DBTransactionAdapter<Options>>;
+declare const runWithAdapter: <R, Options extends BetterAuthOptions = BetterAuthOptions>(adapter: DBAdapter<Options>, fn: () => R) => Promise<R>;
+declare const runWithTransaction: <R, Options extends BetterAuthOptions = BetterAuthOptions>(adapter: DBAdapter<Options>, fn: () => R) => Promise<R>;
+/**
+ * Queue a hook to be executed after the current transaction commits.
+ * If not in a transaction, the hook will execute immediately.
+ */
+declare const queueAfterTransactionHook: (hook: () => Promise<void>) => Promise<void>;
+//#endregion
+export { getCurrentAdapter, getCurrentDBAdapterAsyncLocalStorage, queueAfterTransactionHook, runWithAdapter, runWithTransaction };

package/dist/context/transaction.mjs

@@ -0,0 +1,96 @@
+import { __getBetterAuthGlobal } from "./global.mjs";
+import { getAsyncLocalStorage } from "@better-auth/core/async_hooks";
+//#region src/context/transaction.ts
+const ensureAsyncStorage = async () => {
+	const betterAuthGlobal = __getBetterAuthGlobal();
+	if (!betterAuthGlobal.context.adapterAsyncStorage) {
+		const AsyncLocalStorage = await getAsyncLocalStorage();
+		betterAuthGlobal.context.adapterAsyncStorage = new AsyncLocalStorage();
+	}
+	return betterAuthGlobal.context.adapterAsyncStorage;
+};
+/**
+* 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.
+*/
+const getCurrentDBAdapterAsyncLocalStorage = async () => {
+	return ensureAsyncStorage();
+};
+const getCurrentAdapter = async (fallback) => {
+	return ensureAsyncStorage().then((als) => {
+		return als.getStore()?.adapter || fallback;
+	}).catch(() => {
+		return fallback;
+	});
+};
+const runWithAdapter = async (adapter, fn) => {
+	let called = false;
+	return ensureAsyncStorage().then(async (als) => {
+		called = true;
+		const pendingHooks = [];
+		let result;
+		let error;
+		let hasError = false;
+		try {
+			result = await als.run({
+				adapter,
+				pendingHooks,
+				isTransactionActive: false
+			}, fn);
+		} catch (err) {
+			error = err;
+			hasError = true;
+		}
+		for (const hook of pendingHooks) await hook();
+		if (hasError) throw error;
+		return result;
+	}).catch((err) => {
+		if (!called) return fn();
+		throw err;
+	});
+};
+const runWithTransaction = async (adapter, fn) => {
+	let called = false;
+	return ensureAsyncStorage().then(async (als) => {
+		called = true;
+		if (als.getStore()?.isTransactionActive) return fn();
+		const pendingHooks = [];
+		let result;
+		let error;
+		let hasError = false;
+		try {
+			result = await adapter.transaction(async (trx) => {
+				return als.run({
+					adapter: trx,
+					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.
+*/
+const queueAfterTransactionHook = async (hook) => {
+	return ensureAsyncStorage().then((als) => {
+		const store = als.getStore();
+		if (store) store.pendingHooks.push(hook);
+		else return hook();
+	}).catch(() => {
+		return hook();
+	});
+};
+//#endregion
+export { getCurrentAdapter, getCurrentDBAdapterAsyncLocalStorage, queueAfterTransactionHook, runWithAdapter, runWithTransaction };

package/dist/db/adapter/factory.d.mts

@@ -0,0 +1,17 @@
+import { initGetDefaultFieldName } from "./get-default-field-name.mjs";
+import { initGetDefaultModelName } from "./get-default-model-name.mjs";
+import { initGetFieldAttributes } from "./get-field-attributes.mjs";
+import { initGetFieldName } from "./get-field-name.mjs";
+import { initGetIdField } from "./get-id-field.mjs";
+import { initGetModelName } from "./get-model-name.mjs";
+import { AdapterFactoryConfig, AdapterFactoryCustomizeAdapterCreator, AdapterFactoryOptions, AdapterTestDebugLogs } from "./types.mjs";
+import { DBAdapter } from "./index.mjs";
+import { BetterAuthOptions } from "../../types/init-options.mjs";
+//#region src/db/adapter/factory.d.ts
+type AdapterFactory<Options extends BetterAuthOptions> = (options: Options) => DBAdapter<Options>;
+declare const createAdapterFactory: <Options extends BetterAuthOptions>({
+  adapter: customAdapter,
+  config: cfg
+}: AdapterFactoryOptions) => AdapterFactory<Options>;
+//#endregion
+export { AdapterFactory, createAdapterFactory };