create-croissant 0.1.0 → 0.1.2

package/template/apps/web/node_modules/@better-auth/core/package.json

@@ -0,0 +1,193 @@
+{
+  "name": "@better-auth/core",
+  "version": "1.6.7",
+  "description": "The most comprehensive authentication framework for TypeScript.",
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://www.better-auth.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/better-auth/better-auth.git",
+    "directory": "packages/core"
+  },
+  "keywords": [
+    "auth",
+    "core",
+    "typescript",
+    "better-auth"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts"
+  ],
+  "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"
+    },
+    "./instrumentation": {
+      "dev-source": "./src/instrumentation/index.ts",
+      "types": "./dist/instrumentation/index.d.mts",
+      "node": "./dist/instrumentation/index.mjs",
+      "deno": "./dist/instrumentation/index.mjs",
+      "bun": "./dist/instrumentation/index.mjs",
+      "edge": "./dist/instrumentation/pure.index.mjs",
+      "workerd": "./dist/instrumentation/index.mjs",
+      "browser": "./dist/instrumentation/pure.index.mjs",
+      "default": "./dist/instrumentation/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"
+      ],
+      "instrumentation": [
+        "dist/instrumentation/index.d.mts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@opentelemetry/semantic-conventions": "^1.39.0",
+    "@standard-schema/spec": "^1.1.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@better-auth/utils": "0.4.0",
+    "@better-fetch/fetch": "1.1.21",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/sdk-trace-base": "^1.30.0",
+    "@opentelemetry/sdk-trace-node": "^1.30.0",
+    "better-call": "1.3.5",
+    "@cloudflare/workers-types": "^4.20250121.0",
+    "jose": "^6.1.3",
+    "kysely": "^0.28.14",
+    "nanostores": "^1.1.1",
+    "tsdown": "0.21.1"
+  },
+  "peerDependencies": {
+    "@better-auth/utils": "0.4.0",
+    "@better-fetch/fetch": "1.1.21",
+    "@opentelemetry/api": "^1.9.0",
+    "better-call": "1.3.5",
+    "@cloudflare/workers-types": ">=4",
+    "jose": "^6.1.0",
+    "kysely": "^0.28.5",
+    "nanostores": "^1.0.1"
+  },
+  "peerDependenciesMeta": {
+    "@cloudflare/workers-types": {
+      "optional": true
+    },
+    "@opentelemetry/api": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint:package": "publint run --strict --pack false",
+    "lint:types": "attw --profile esm-only --pack .",
+    "typecheck": "tsc --project tsconfig.json",
+    "test": "vitest",
+    "coverage": "vitest run --coverage --coverage.provider=istanbul"
+  }
+}

package/template/apps/web/node_modules/@better-auth/core/src/api/index.ts

@@ -0,0 +1,140 @@
+import type {
+	EndpointContext,
+	EndpointOptions,
+	StrictEndpoint,
+} from "better-call";
+import {
+	createEndpoint,
+	createMiddleware,
+	kAPIErrorHeaderSymbol,
+} from "better-call";
+import { runWithEndpointContext } from "../context";
+import type { AuthContext } from "../types";
+import { isAPIError } from "../utils/is-api-error";
+
+/**
+ * Better-call's createEndpoint re-throws APIError without exposing the headers
+ * accumulated on ctx.responseHeaders (e.g. Set-Cookie from deleteSessionCookie
+ * before throw). Attach them to the error via kAPIErrorHeaderSymbol — matching
+ * better-call's createMiddleware contract so the outer pipeline can merge them
+ * into the response.
+ */
+function attachResponseHeadersToAPIError(
+	responseHeaders: Headers | undefined,
+	e: unknown,
+): void {
+	if (!isAPIError(e) || !responseHeaders) return;
+	Object.defineProperty(e, kAPIErrorHeaderSymbol, {
+		enumerable: false,
+		configurable: true,
+		value: responseHeaders,
+		writable: false,
+	});
+}
+
+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;
+
+	// 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(
+			path,
+			{
+				...options,
+				use: [...(options?.use || []), ...use],
+			},
+			wrapped,
+		);
+	}
+
+	return createEndpoint(
+		{
+			...options,
+			use: [...(options?.use || []), ...use],
+		},
+		wrapped,
+	);
+}
+
+export type AuthEndpoint<
+	Path extends string,
+	Opts extends EndpointOptions,
+	R,
+> = ReturnType<typeof createAuthEndpoint<Path, Opts, R>>;
+export type AuthMiddleware = ReturnType<typeof createAuthMiddleware>;

package/template/apps/web/node_modules/@better-auth/core/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/template/apps/web/node_modules/@better-auth/core/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/template/apps/web/node_modules/@better-auth/core/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/template/apps/web/node_modules/@better-auth/core/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/template/apps/web/node_modules/@better-auth/core/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/template/apps/web/node_modules/@better-auth/core/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);
+		},
+	};
+}