create-croissant 0.1.0 → 0.1.1

package/template/apps/web/node_modules/@better-auth/core/dist/context/endpoint-context.mjs

@@ -0,0 +1,29 @@
+import { __getBetterAuthGlobal } from "./global.mjs";
+import { getAsyncLocalStorage } from "@better-auth/core/async_hooks";
+//#region src/context/endpoint-context.ts
+const ensureAsyncStorage = async () => {
+	const betterAuthGlobal = __getBetterAuthGlobal();
+	if (!betterAuthGlobal.context.endpointContextAsyncStorage) {
+		const AsyncLocalStorage = await getAsyncLocalStorage();
+		betterAuthGlobal.context.endpointContextAsyncStorage = new AsyncLocalStorage();
+	}
+	return betterAuthGlobal.context.endpointContextAsyncStorage;
+};
+/**
+* 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.
+*/
+async function getCurrentAuthContextAsyncLocalStorage() {
+	return ensureAsyncStorage();
+}
+async function getCurrentAuthContext() {
+	const context = (await ensureAsyncStorage()).getStore();
+	if (!context) throw new Error("No auth context found. Please make sure you are calling this function within a `runWithEndpointContext` callback.");
+	return context;
+}
+async function runWithEndpointContext(context, fn) {
+	return (await ensureAsyncStorage()).run(context, fn);
+}
+//#endregion
+export { getCurrentAuthContext, getCurrentAuthContextAsyncLocalStorage, runWithEndpointContext };

package/template/apps/web/node_modules/@better-auth/core/dist/context/global.d.mts

@@ -0,0 +1,6 @@
+import { AsyncLocalStorage } from "@better-auth/core/async_hooks";
+
+//#region src/context/global.d.ts
+declare function getBetterAuthVersion(): string;
+//#endregion
+export { getBetterAuthVersion };

package/template/apps/web/node_modules/@better-auth/core/dist/context/global.mjs

@@ -0,0 +1,36 @@
+//#region src/context/global.ts
+const symbol = Symbol.for("better-auth:global");
+let bind = null;
+const __context = {};
+const __betterAuthVersion = "1.6.6";
+/**
+* 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
+*/
+function __getBetterAuthGlobal() {
+	if (!globalThis[symbol]) {
+		globalThis[symbol] = {
+			version: __betterAuthVersion,
+			epoch: 1,
+			context: __context
+		};
+		bind = globalThis[symbol];
+	}
+	bind = globalThis[symbol];
+	if (bind.version !== __betterAuthVersion) {
+		bind.version = __betterAuthVersion;
+		bind.epoch++;
+	}
+	return globalThis[symbol];
+}
+function getBetterAuthVersion() {
+	return __getBetterAuthGlobal().version;
+}
+//#endregion
+export { __getBetterAuthGlobal, getBetterAuthVersion };

package/template/apps/web/node_modules/@better-auth/core/dist/context/index.d.mts

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

package/template/apps/web/node_modules/@better-auth/core/dist/context/index.mjs

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

package/template/apps/web/node_modules/@better-auth/core/dist/context/request-state.d.mts

@@ -0,0 +1,27 @@
+import { AsyncLocalStorage } from "@better-auth/core/async_hooks";
+
+//#region src/context/request-state.d.ts
+type RequestStateWeakMap = WeakMap<object, any>;
+declare function getRequestStateAsyncLocalStorage(): Promise<AsyncLocalStorage<RequestStateWeakMap>>;
+declare function hasRequestState(): Promise<boolean>;
+declare function getCurrentRequestState(): Promise<RequestStateWeakMap>;
+declare function runWithRequestState<T>(store: RequestStateWeakMap, fn: () => T): Promise<T>;
+interface RequestState<T> {
+  get(): Promise<T>;
+  set(value: T): Promise<void>;
+  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();
+ */
+declare function defineRequestState<T>(initFn: () => T | Promise<T>): RequestState<T>;
+//#endregion
+export { RequestState, RequestStateWeakMap, defineRequestState, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, runWithRequestState };

package/template/apps/web/node_modules/@better-auth/core/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/template/apps/web/node_modules/@better-auth/core/dist/context/transaction.d.mts

@@ -0,0 +1,24 @@
+import { DBAdapter, DBTransactionAdapter } from "../db/adapter/index.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/context/transaction.d.ts
+type HookContext = {
+  adapter: DBTransactionAdapter;
+  pendingHooks: Array<() => Promise<void>>;
+};
+/**
+ * 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: (fallback: DBTransactionAdapter) => Promise<DBTransactionAdapter>;
+declare const runWithAdapter: <R>(adapter: DBAdapter, fn: () => R) => Promise<R>;
+declare const runWithTransaction: <R>(adapter: DBAdapter, 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/template/apps/web/node_modules/@better-auth/core/dist/context/transaction.mjs

@@ -0,0 +1,93 @@
+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
+			}, 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 = true;
+	return ensureAsyncStorage().then(async (als) => {
+		called = true;
+		const pendingHooks = [];
+		let result;
+		let error;
+		let hasError = false;
+		try {
+			result = await adapter.transaction(async (trx) => {
+				return als.run({
+					adapter: trx,
+					pendingHooks
+				}, 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/template/apps/web/node_modules/@better-auth/core/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 };