@masheev/better-auth 0.0.0-stage → 1.7.5

package/dist/test-utils/http-test-instance.mjs

@@ -0,0 +1,107 @@
+import { toNodeHandler } from "../integrations/node.mjs";
+import { getTestInstance } from "./test-instance.mjs";
+import { createServer } from "node:http";
+//#region src/test-utils/http-test-instance.ts
+const closeHttpServer = (server) => new Promise((resolve, reject) => {
+	server.close((error) => {
+		if (error) {
+			reject(error);
+			return;
+		}
+		resolve();
+	});
+});
+const endUnhandledErrorResponse = (res, error) => {
+	if (res.writableEnded || res.destroyed) return;
+	if (res.headersSent) {
+		res.end();
+		return;
+	}
+	res.statusCode = 500;
+	res.end(error instanceof Error ? error.message : "Internal Server Error");
+};
+/**
+* Binds an HTTP listener to an OS-assigned port before the final request
+* handler exists. This lets tests construct URL-sensitive applications only
+* after the listener owns its port, then install the application handler.
+*/
+async function createHttpTestServer() {
+	let activeHandler = (_req, res) => {
+		res.statusCode = 503;
+		res.end("Test HTTP listener has no handler bound yet");
+	};
+	const nodeServer = createServer((req, res) => {
+		Promise.resolve(activeHandler(req, res)).catch((error) => {
+			endUnhandledErrorResponse(res, error);
+		});
+	});
+	await new Promise((resolve, reject) => {
+		const onError = (error) => {
+			nodeServer.off("listening", onListening);
+			reject(error);
+		};
+		const onListening = () => {
+			nodeServer.off("error", onError);
+			resolve();
+		};
+		nodeServer.once("error", onError);
+		nodeServer.once("listening", onListening);
+		nodeServer.listen(0, "127.0.0.1");
+	});
+	const address = nodeServer.address();
+	if (!address || typeof address === "string") {
+		await closeHttpServer(nodeServer);
+		throw new Error("HTTP test listener did not report a bound port for the test listener");
+	}
+	return {
+		url: `http://127.0.0.1:${address.port}`,
+		address,
+		server: nodeServer,
+		setRequestHandler(handler) {
+			activeHandler = handler;
+		},
+		close: () => closeHttpServer(nodeServer)
+	};
+}
+/**
+* Like `getTestInstance`, but bound to an actual HTTP listener on an
+* OS-assigned port (`port: 0`). The discovered URL is fed back into the auth
+* instance so its `baseURL` matches the listener.
+*
+* This removes the race window that the temp-server-then-rebind pattern
+* introduces. The listener is bound once, holds the port for its lifetime,
+* and only swaps in the real request handler after the auth instance is
+* fully constructed.
+*
+* The caller is responsible for calling `server.close()` in `afterAll`. Any
+* `baseURL` passed in `options` is ignored — the URL must match the
+* listener.
+*/
+async function getHttpTestInstance(options, config) {
+	const server = await createHttpTestServer();
+	const baseURL = server.url;
+	try {
+		const instance = await getTestInstance({
+			...options,
+			baseURL
+		}, {
+			clientOptions: config?.clientOptions,
+			disableTestUser: config?.disableTestUser,
+			testUser: config?.testUser,
+			testWith: config?.testWith,
+			transaction: config?.transaction
+		});
+		server.setRequestHandler(config?.handler ? config.handler(instance.auth) : toNodeHandler(instance.auth.handler));
+		return {
+			...instance,
+			server,
+			baseURL,
+			port: server.address.port
+		};
+	} catch (error) {
+		await server.close();
+		throw error;
+	}
+}
+//#endregion
+export { createHttpTestServer, getHttpTestInstance };

package/dist/test-utils/index.d.mts

@@ -0,0 +1,4 @@
+import { convertSetCookieToCookie } from "./headers.mjs";
+import { getTestInstance } from "./test-instance.mjs";
+import { HttpTestInstanceConfig, HttpTestRequestHandler, HttpTestServer, createHttpTestServer, getHttpTestInstance } from "./http-test-instance.mjs";
+export { type HttpTestInstanceConfig, type HttpTestRequestHandler, type HttpTestServer, convertSetCookieToCookie, createHttpTestServer, getHttpTestInstance, getTestInstance };

package/dist/test-utils/index.mjs

@@ -0,0 +1,4 @@
+import { convertSetCookieToCookie } from "./headers.mjs";
+import { getTestInstance } from "./test-instance.mjs";
+import { createHttpTestServer, getHttpTestInstance } from "./http-test-instance.mjs";
+export { convertSetCookieToCookie, createHttpTestServer, getHttpTestInstance, getTestInstance };

package/dist/test-utils/test-instance.d.mts

@@ -0,0 +1,56 @@
+import { Session, User } from "../types/models.mjs";
+import { Auth } from "../types/auth.mjs";
+import { AuthClient } from "../client/vanilla.mjs";
+import { setCookieToHeader } from "../cookies/cookie-utils.mjs";
+import { Awaitable, BetterAuthClientOptions, BetterAuthOptions } from "@better-auth/core";
+import * as _$_better_auth_core_db_adapter0 from "@better-auth/core/db/adapter";
+import { SuccessContext } from "@better-fetch/fetch";
+
+//#region src/test-utils/test-instance.d.ts
+declare function getTestInstance<O extends Partial<BetterAuthOptions>, C extends BetterAuthClientOptions>(options?: O | undefined, config?: {
+  clientOptions?: C;
+  port?: number;
+  disableTestUser?: boolean;
+  testUser?: Partial<User>;
+  testWith?: "sqlite" | "postgres" | "mongodb" | "mysql";
+  transaction?: boolean;
+} | undefined): Promise<{
+  auth: Auth<O>;
+  client: AuthClient<(C extends undefined ? {} : C) & {
+    baseURL: string | undefined;
+    fetchOptions: {
+      customFetchImpl: (url: string | URL | Request, init?: RequestInit | undefined) => Promise<Response>;
+    };
+  }>;
+  testUser: {
+    id?: string | undefined;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
+    email: string;
+    emailVerified?: boolean | undefined;
+    name: string;
+    image?: string | null | undefined;
+    password: string;
+  };
+  signInWithTestUser: () => Promise<{
+    session: Session;
+    user: User;
+    headers: Headers;
+    setCookie: (name: string, value: string) => void;
+    runWithUser: (fn: (headers: Headers) => Promise<void>) => Promise<void>;
+  }>;
+  signInWithUser: (email: string, password: string) => Promise<{
+    res: {
+      user: User;
+      session: Session;
+    };
+    headers: Headers;
+  }>;
+  cookieSetter: typeof setCookieToHeader;
+  customFetchImpl: (url: string | URL | Request, init?: RequestInit | undefined) => Promise<Response>;
+  sessionSetter: (headers: Headers) => (context: SuccessContext) => void;
+  db: _$_better_auth_core_db_adapter0.DBAdapter<BetterAuthOptions>;
+  runWithUser: (email: string, password: string, fn: (headers: Headers) => Awaitable<void>) => Promise<void>;
+}>;
+//#endregion
+export { getTestInstance };

package/dist/test-utils/test-instance.mjs

@@ -0,0 +1,242 @@
+import { getAdapter } from "../db/adapter-kysely.mjs";
+import { getMigrations } from "../db/get-migration.mjs";
+import { getBaseURL, isDynamicBaseURLConfig } from "../utils/url.mjs";
+import { parseSetCookieHeader, setCookieToHeader } from "../cookies/cookie-utils.mjs";
+import { betterAuth } from "../auth/full.mjs";
+import { createAuthClient } from "../client/vanilla.mjs";
+import { bearer } from "../plugins/bearer/index.mjs";
+import { sql } from "kysely";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash, randomUUID } from "node:crypto";
+import { afterAll } from "vitest";
+//#region src/test-utils/test-instance.ts
+const cleanupSet = /* @__PURE__ */ new Set();
+const currentUserContextStorage = new AsyncLocalStorage();
+afterAll(async () => {
+	for (const cleanup of cleanupSet) {
+		await cleanup();
+		cleanupSet.delete(cleanup);
+	}
+});
+const TEST_PASSWORD_HASH_PREFIX = "$test$sha256$";
+/**
+* Intentionally fast for tests
+*/
+function createTestPasswordHash(password) {
+	return `${TEST_PASSWORD_HASH_PREFIX}${createHash("sha256").update(password.normalize("NFKC")).digest("hex")}`;
+}
+const testPassword = {
+	hash: async (password) => createTestPasswordHash(password),
+	verify: async ({ hash, password }) => hash === createTestPasswordHash(password)
+};
+async function getTestInstance(options, config) {
+	const testWith = config?.testWith || "sqlite";
+	const postgresSchema = testWith === "postgres" ? `ba_test_${randomUUID().replaceAll("-", "_")}` : void 0;
+	const quotePostgresIdentifier = (identifier) => `"${identifier.replaceAll("\"", "\"\"")}"`;
+	async function getPostgres() {
+		const { Kysely, PostgresDialect } = await import("kysely");
+		const { Pool } = await import("pg");
+		const pool = new Pool({
+			connectionString: "postgres://user:password@localhost:5432/better_auth",
+			options: postgresSchema ? `-c search_path=${postgresSchema},public` : void 0
+		});
+		if (postgresSchema) await pool.query(`CREATE SCHEMA IF NOT EXISTS ${quotePostgresIdentifier(postgresSchema)}`);
+		return new Kysely({ dialect: new PostgresDialect({ pool }) });
+	}
+	async function getSqlite() {
+		const { DatabaseSync } = await import("node:sqlite");
+		return new DatabaseSync(":memory:");
+	}
+	async function getMysql() {
+		const { Kysely, MysqlDialect } = await import("kysely");
+		const { createPool } = await import("mysql2/promise");
+		return new Kysely({ dialect: new MysqlDialect({ pool: createPool("mysql://user:password@localhost:3306/better_auth") }) });
+	}
+	async function mongodbClient() {
+		const { MongoClient } = await import("mongodb");
+		const dbClient = async (connectionString, dbName) => {
+			const client = new MongoClient(connectionString, {
+				serverSelectionTimeoutMS: 2e3,
+				connectTimeoutMS: 2e3
+			});
+			await client.connect();
+			return client.db(dbName);
+		};
+		return await dbClient("mongodb://127.0.0.1:27017", "better-auth");
+	}
+	const opts = {
+		socialProviders: {
+			github: {
+				clientId: "test",
+				clientSecret: "test"
+			},
+			google: {
+				clientId: "test",
+				clientSecret: "test"
+			}
+		},
+		secret: "better-auth-secret-that-is-long-enough-for-validation-test",
+		database: testWith === "postgres" ? {
+			db: await getPostgres(),
+			type: "postgres",
+			transaction: config?.transaction
+		} : testWith === "mongodb" ? await Promise.all([mongodbClient(), await import("../adapters/mongodb-adapter/index.mjs")]).then(([db, { mongodbAdapter }]) => mongodbAdapter(db)) : testWith === "mysql" ? {
+			db: await getMysql(),
+			type: "mysql",
+			transaction: config?.transaction
+		} : await getSqlite(),
+		emailAndPassword: { enabled: true },
+		rateLimit: { enabled: false },
+		advanced: { cookies: {} },
+		logger: { level: "debug" }
+	};
+	const authOptions = {
+		baseURL: "http://localhost:" + (config?.port || 3e3),
+		...opts,
+		...options,
+		emailAndPassword: {
+			...opts.emailAndPassword,
+			...options?.emailAndPassword,
+			password: options?.emailAndPassword?.password ?? testPassword
+		},
+		plugins: [bearer(), ...options?.plugins || []]
+	};
+	if (testWith !== "mongodb") {
+		const { runMigrations } = await getMigrations({
+			...authOptions,
+			database: opts.database
+		});
+		await runMigrations();
+	}
+	const auth = betterAuth(authOptions);
+	const testUser = {
+		email: "test@test.com",
+		password: "test123456",
+		name: "test user",
+		...config?.testUser
+	};
+	async function createTestUser() {
+		if (config?.disableTestUser) return;
+		const dynamicBaseURL = isDynamicBaseURLConfig(auth.options.baseURL) ? auth.options.baseURL : void 0;
+		const host = (dynamicBaseURL?.allowedHosts.find((h) => !h.includes("*") && !h.includes("?")) ?? dynamicBaseURL?.allowedHosts[0])?.replace(/^https?:\/\//, "").split(/[/#]/)[0]?.replace(/\*/g, "test").replace(/\?/g, "x");
+		const headers = host ? new Headers({ host }) : void 0;
+		await auth.api.signUpEmail({
+			body: testUser,
+			headers
+		});
+	}
+	await createTestUser();
+	const cleanup = async () => {
+		if (testWith === "mongodb") {
+			await (await mongodbClient()).dropDatabase();
+			return;
+		}
+		if (testWith === "postgres") {
+			const postgres = await getPostgres();
+			if (postgresSchema) await sql.raw(`DROP SCHEMA IF EXISTS ${quotePostgresIdentifier(postgresSchema)} CASCADE`).execute(postgres);
+			else await sql`DROP SCHEMA public CASCADE; CREATE SCHEMA public;`.execute(postgres);
+			await postgres.destroy();
+			return;
+		}
+		if (testWith === "mysql") {
+			const mysql = await getMysql();
+			await sql`SET FOREIGN_KEY_CHECKS = 0;`.execute(mysql);
+			const tables = await mysql.introspection.getTables();
+			for (const table of tables) await mysql.deleteFrom(table.name).execute();
+			await sql`SET FOREIGN_KEY_CHECKS = 1;`.execute(mysql);
+			return;
+		}
+		if (testWith === "sqlite") {
+			(await getSqlite()).close();
+			return;
+		}
+	};
+	cleanupSet.add(cleanup);
+	const customFetchImpl = async (url, init) => {
+		const headers = init?.headers || {};
+		const storageHeaders = currentUserContextStorage.getStore()?.headers;
+		return auth.handler(new Request(url, init ? {
+			...init,
+			headers: new Headers({
+				...storageHeaders ? Object.fromEntries(storageHeaders.entries()) : {},
+				...headers instanceof Headers ? Object.fromEntries(headers.entries()) : typeof headers === "object" ? headers : {}
+			})
+		} : { headers }));
+	};
+	const clientBaseURL = isDynamicBaseURLConfig(options?.baseURL) ? getBaseURL("http://localhost:" + (config?.port || 3e3), options?.basePath || "/api/auth") : getBaseURL(typeof options?.baseURL === "string" ? options.baseURL : "http://localhost:" + (config?.port || 3e3), options?.basePath || "/api/auth");
+	const client = createAuthClient({
+		...config?.clientOptions,
+		baseURL: clientBaseURL,
+		fetchOptions: { customFetchImpl }
+	});
+	async function signInWithTestUser() {
+		if (config?.disableTestUser) throw new Error("Test user is disabled");
+		const headers = new Headers();
+		const setCookie = (name, value) => {
+			const current = headers.get("cookie");
+			headers.set("cookie", `${current || ""}; ${name}=${value}`);
+		};
+		const { data } = await client.signIn.email({
+			email: testUser.email,
+			password: testUser.password,
+			fetchOptions: { onSuccess(context) {
+				const signedCookie = parseSetCookieHeader(context.response.headers.get("set-cookie") || "").get("better-auth.session_token")?.value;
+				headers.set("cookie", `better-auth.session_token=${signedCookie}`);
+			} }
+		});
+		return {
+			session: data.session,
+			user: data.user,
+			headers,
+			setCookie,
+			runWithUser: async (fn) => {
+				return currentUserContextStorage.run({ headers }, async () => {
+					await fn(headers);
+				});
+			}
+		};
+	}
+	async function signInWithUser(email, password) {
+		const headers = new Headers();
+		const { data } = await client.signIn.email({
+			email,
+			password,
+			fetchOptions: { onSuccess(context) {
+				const signedCookie = parseSetCookieHeader(context.response.headers.get("set-cookie") || "").get("better-auth.session_token")?.value;
+				headers.set("cookie", `better-auth.session_token=${signedCookie}`);
+			} }
+		});
+		return {
+			res: data,
+			headers
+		};
+	}
+	function sessionSetter(headers) {
+		return (context) => {
+			const header = context.response.headers.get("set-cookie");
+			if (header) {
+				const signedCookie = parseSetCookieHeader(header || "").get("better-auth.session_token")?.value;
+				headers.set("cookie", `better-auth.session_token=${signedCookie}`);
+			}
+		};
+	}
+	return {
+		auth,
+		client,
+		testUser,
+		signInWithTestUser,
+		signInWithUser,
+		cookieSetter: setCookieToHeader,
+		customFetchImpl,
+		sessionSetter,
+		db: await getAdapter(auth.options),
+		runWithUser: async (email, password, fn) => {
+			const { headers } = await signInWithUser(email, password);
+			return currentUserContextStorage.run({ headers }, async () => {
+				await fn(headers);
+			});
+		}
+	};
+}
+//#endregion
+export { getTestInstance };

package/dist/types/adapter.d.mts

@@ -0,0 +1,2 @@
+import { DBAdapter as DBAdapter$1, DBAdapterInstance, DBAdapterSchemaCreation, DBTransactionAdapter, JoinConfig, JoinOption, Where as Where$1 } from "@better-auth/core/db/adapter";
+export { type DBAdapter$1 as DBAdapter, type DBAdapterInstance, type DBAdapterSchemaCreation, type DBTransactionAdapter, type JoinConfig, type JoinOption, type Where$1 as Where };

package/dist/types/api.d.mts

@@ -0,0 +1,28 @@
+import { PrettifyDeep, UnionToIntersection } from "./helper.mjs";
+import { Endpoint } from "better-call";
+
+//#region src/types/api.d.ts
+type FilteredAPI<API> = Omit<API, API extends { [key in infer K]: Endpoint } ? K extends string ? K extends "getSession" ? never : API[K]["options"]["metadata"] extends {
+  isAction: false;
+} | {
+  scope: "http";
+} ? K : never : never : never>;
+type InferSessionAPI<API> = API extends {
+  [key: string]: infer E;
+} ? UnionToIntersection<E extends Endpoint ? E["path"] extends "/get-session" ? {
+  getSession: <R extends boolean, H extends boolean = false>(context: {
+    headers: Headers;
+    query?: {
+      disableCookieCache?: boolean;
+      disableRefresh?: boolean;
+    } | undefined;
+    asResponse?: R | undefined;
+    returnHeaders?: H | undefined;
+  }) => false extends R ? H extends true ? Promise<{
+    headers: Headers;
+    response: PrettifyDeep<Awaited<ReturnType<E>>> | null;
+  }> : Promise<PrettifyDeep<Awaited<ReturnType<E>>> | null> : Promise<Response>;
+} : never : never> : never;
+type InferAPI<API> = InferSessionAPI<API> & FilteredAPI<API>;
+//#endregion
+export { FilteredAPI, InferAPI, InferSessionAPI };

package/dist/types/auth.d.mts

@@ -0,0 +1,32 @@
+import { InferAPI } from "./api.mjs";
+import { InferPluginTypes, Session, User } from "./models.mjs";
+import { InferPluginContext, InferPluginErrorCodes } from "./plugins.mjs";
+import { router } from "../api/index.mjs";
+import { AuthContext, BetterAuthOptions } from "@better-auth/core";
+import { BASE_ERROR_CODES } from "@better-auth/core/error";
+
+//#region src/types/auth.d.ts
+type Auth<Options extends BetterAuthOptions = BetterAuthOptions> = {
+  handler: (request: Request) => Promise<Response>;
+  /**
+   * Alias for {@link Auth.handler}.
+   */
+  fetch: (request: Request) => Promise<Response>;
+  api: InferAPI<ReturnType<typeof router<Options>>["endpoints"]>;
+  options: Options;
+  $ERROR_CODES: InferPluginErrorCodes<Options> & typeof BASE_ERROR_CODES;
+  $context: Promise<AuthContext<Options> & InferPluginContext<Options>>;
+  /**
+   * Share types
+   */
+  $Infer: InferPluginTypes<Options> extends {
+    Session: any;
+  } ? InferPluginTypes<Options> : {
+    Session: {
+      session: Session<Options["session"], Options["plugins"]>;
+      user: User<Options["user"], Options["plugins"]>;
+    };
+  } & InferPluginTypes<Options>;
+};
+//#endregion
+export { Auth };

package/dist/types/helper.d.mts

@@ -0,0 +1,26 @@
+//#region src/types/helper.d.ts
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Prettify<T> = Omit<T, never>;
+type PrettifyDeep<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? T[K] : T[K] extends object ? T[K] extends Array<any> ? T[K] : T[K] extends Date ? T[K] : PrettifyDeep<T[K]> : T[K] } & {};
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type RequiredKeysOf<BaseType extends object> = Exclude<{ [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never }[keyof BaseType], undefined>;
+type HasRequiredKeys<BaseType> = IsAny<BaseType> extends true ? false : [BaseType] extends [object] ? RequiredKeysOf<BaseType & object> extends never ? false : true : false;
+type StripEmptyObjects<T extends object> = { [K in keyof T]: T[K] };
+/**
+ * Object merge replacing `Base`'s keys with `Override`'s.
+ * The naive `Omit<Base, keyof Override> & Override` form breaks under generics.
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/57466#issuecomment-1957988380
+ */
+type OverrideMerge<Base, Override> = Base extends unknown ? Override extends unknown ? Prettify<{ [K in keyof Base as K extends keyof Override ? never : K]: Base[K] } & Override> : never : never;
+/**
+ * Extracts a Record-typed field from a plugin, guarding against `any`.
+ */
+type ExtractPluginField<T, Field extends string> = IsAny<T> extends true ? {} : T extends { [K in Field]?: Record<string, any> } ? T[Field] extends Record<string, any> ? T[Field] : {} : {};
+/**
+ * Walks a plugin tuple with tail-recursive accumulator (TS 4.5+),
+ * extracting and intersecting the given field from each element.
+ */
+type InferPluginFieldFromTuple<T extends readonly unknown[], Field extends string, Acc = {}> = T extends readonly [infer Head, ...infer Tail] ? InferPluginFieldFromTuple<Tail, Field, Acc & ExtractPluginField<Head, Field>> : Acc;
+//#endregion
+export { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, RequiredKeysOf, StripEmptyObjects, UnionToIntersection };

package/dist/types/index.d.mts

@@ -0,0 +1,10 @@
+import { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, RequiredKeysOf, StripEmptyObjects, UnionToIntersection } from "./helper.mjs";
+import { BetterAuthClientOptions, BetterAuthClientPlugin, ClientAtomListener, ClientStore, InferActions, InferAdditionalFromClient, InferClientAPI, InferErrorCodes, InferSessionFromClient, InferUserFromClient, IsSignal, SessionQueryParams } from "../client/types.mjs";
+import { DBAdapter, DBAdapterInstance, DBAdapterSchemaCreation, DBTransactionAdapter, JoinConfig, JoinOption, Where } from "./adapter.mjs";
+import { FilteredAPI, InferAPI, InferSessionAPI } from "./api.mjs";
+import { Account, AdditionalSessionFieldsInput, AdditionalUserFieldsInput, InferPluginTypes, RateLimit, Session, User, Verification } from "./models.mjs";
+import { InferOptionSchema, InferPluginContext, InferPluginErrorCodes, InferPluginIDs } from "./plugins.mjs";
+import { Auth } from "./auth.mjs";
+import { BetterAuthAdvancedOptions, BetterAuthCookies, BetterAuthOptions, BetterAuthPlugin, BetterAuthRateLimitOptions, StoreIdentifierOption, UserProvisioningSource, ValidateUserInfoAction, ValidateUserInfoMethod, ValidateUserInfoOAuthInfo, ValidateUserInfoResult, ValidateUserInfoSSOInfo, ValidateUserInfoSource } from "@better-auth/core";
+export * from "@better-auth/core/social-providers";
+export { Account, AdditionalSessionFieldsInput, AdditionalUserFieldsInput, Auth, type BetterAuthAdvancedOptions, BetterAuthClientOptions, BetterAuthClientPlugin, type BetterAuthCookies, type BetterAuthOptions, type BetterAuthPlugin, type BetterAuthRateLimitOptions, ClientAtomListener, ClientStore, DBAdapter, DBAdapterInstance, DBAdapterSchemaCreation, DBTransactionAdapter, ExtractPluginField, FilteredAPI, HasRequiredKeys, InferAPI, InferActions, InferAdditionalFromClient, InferClientAPI, InferErrorCodes, InferOptionSchema, InferPluginContext, InferPluginErrorCodes, InferPluginFieldFromTuple, InferPluginIDs, InferPluginTypes, InferSessionAPI, InferSessionFromClient, InferUserFromClient, IsAny, IsSignal, JoinConfig, JoinOption, OverrideMerge, Prettify, PrettifyDeep, RateLimit, RequiredKeysOf, Session, SessionQueryParams, type StoreIdentifierOption, StripEmptyObjects, UnionToIntersection, User, type UserProvisioningSource, type ValidateUserInfoAction, type ValidateUserInfoMethod, type ValidateUserInfoOAuthInfo, type ValidateUserInfoResult, type ValidateUserInfoSSOInfo, type ValidateUserInfoSource, Verification, Where };

package/dist/types/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/types/models.d.mts

@@ -0,0 +1,10 @@
+import { ExtractPluginField, InferPluginFieldFromTuple, UnionToIntersection } from "./helper.mjs";
+import { BetterAuthOptions } from "@better-auth/core";
+import { Account, InferDBFieldsFromOptionsInput, InferDBFieldsFromPluginsInput, RateLimit, Session as Session$1, User as User$1, Verification } from "@better-auth/core/db";
+
+//#region src/types/models.d.ts
+type AdditionalUserFieldsInput<Options extends BetterAuthOptions> = InferDBFieldsFromPluginsInput<"user", Options["plugins"]> & InferDBFieldsFromOptionsInput<Options["user"]>;
+type AdditionalSessionFieldsInput<Options extends BetterAuthOptions> = InferDBFieldsFromPluginsInput<"session", Options["plugins"]> & InferDBFieldsFromOptionsInput<Options["session"]>;
+type InferPluginTypes<O extends BetterAuthOptions> = O["plugins"] extends readonly [unknown, ...unknown[]] ? InferPluginFieldFromTuple<O["plugins"], "$Infer"> : O["plugins"] extends Array<infer P> ? UnionToIntersection<ExtractPluginField<P, "$Infer">> : {};
+//#endregion
+export { type Account, AdditionalSessionFieldsInput, AdditionalUserFieldsInput, InferPluginTypes, type RateLimit, type Session$1 as Session, type User$1 as User, type Verification };

package/dist/types/plugins.d.mts

@@ -0,0 +1,19 @@
+import { ExtractPluginField, InferPluginFieldFromTuple, UnionToIntersection } from "./helper.mjs";
+import { AuthContext, BetterAuthOptions, BetterAuthPlugin } from "@better-auth/core";
+import { BetterAuthPluginDBSchema } from "@better-auth/core/db";
+
+//#region src/types/plugins.d.ts
+type InferOptionSchema<S extends BetterAuthPluginDBSchema> = S extends Record<string, {
+  fields: infer Fields;
+}> ? { [K in keyof S]?: {
+  modelName?: string | undefined;
+  fields?: { [P in keyof Fields]?: string } | undefined;
+} } : never;
+type InferPluginErrorCodes<O extends BetterAuthOptions> = O["plugins"] extends readonly [unknown, ...unknown[]] ? InferPluginFieldFromTuple<O["plugins"], "$ERROR_CODES"> : O["plugins"] extends Array<infer P> ? UnionToIntersection<ExtractPluginField<P, "$ERROR_CODES">> : {};
+type InferPluginIDs<O extends BetterAuthOptions> = O["plugins"] extends Array<infer P> ? UnionToIntersection<P extends BetterAuthPlugin ? P["id"] : never> : never;
+type ExtractInitContext<P extends BetterAuthPlugin> = P["init"] extends ((...args: any[]) => infer R) ? Awaited<R> extends {
+  context?: infer C;
+} ? C extends Record<string, any> ? Omit<C, keyof AuthContext> : {} : {} : {};
+type InferPluginContext<O extends BetterAuthOptions> = O["plugins"] extends Array<infer P> ? UnionToIntersection<P extends BetterAuthPlugin ? ExtractInitContext<P> : {}> : {};
+//#endregion
+export { InferOptionSchema, InferPluginContext, InferPluginErrorCodes, InferPluginIDs };

package/dist/utils/boolean.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/boolean.ts
+function toBoolean(value) {
+	return value === "true" || value === true;
+}
+//#endregion
+export { toBoolean };

package/dist/utils/constants.mjs

@@ -0,0 +1,4 @@
+//#region src/utils/constants.ts
+const DEFAULT_SECRET = "better-auth-secret-12345678901234567890";
+//#endregion
+export { DEFAULT_SECRET };

package/dist/utils/date.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/date.ts
+const getDate = (span, unit = "ms") => {
+	return new Date(Date.now() + (unit === "sec" ? span * 1e3 : span));
+};
+//#endregion
+export { getDate };

package/dist/utils/hashing.mjs

@@ -0,0 +1,18 @@
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { utf8ToBytes } from "@noble/hashes/utils.js";
+//#region src/utils/hashing.ts
+/**
+* TS implementation of ERC-55 ("Mixed-case checksum address encoding") using @noble/hashes
+* @param address - The address to convert to a checksum address
+* @returns The checksummed address
+*/
+function toChecksumAddress(address) {
+	address = address.toLowerCase().replace("0x", "");
+	const hash = [...keccak_256(utf8ToBytes(address))].map((v) => v.toString(16).padStart(2, "0")).join("");
+	let ret = "0x";
+	for (let i = 0; i < 40; i++) if (parseInt(hash[i], 16) >= 8) ret += address[i].toUpperCase();
+	else ret += address[i];
+	return ret;
+}
+//#endregion
+export { toChecksumAddress };

package/dist/utils/hide-metadata.d.mts

@@ -0,0 +1,6 @@
+//#region src/utils/hide-metadata.d.ts
+declare const HIDE_METADATA: {
+  readonly scope: "server";
+};
+//#endregion
+export { HIDE_METADATA };

package/dist/utils/hide-metadata.mjs

@@ -0,0 +1,4 @@
+//#region src/utils/hide-metadata.ts
+const HIDE_METADATA = { scope: "server" };
+//#endregion
+export { HIDE_METADATA };

package/dist/utils/index.d.mts

@@ -0,0 +1,4 @@
+import { GenerateStateOptions, generateIdTokenNonce, generateState, parseState } from "../oauth2/state.mjs";
+import { StateData, generateGenericState, parseGenericState } from "../state.mjs";
+import { HIDE_METADATA } from "./hide-metadata.mjs";
+import { getBaseURL, getHost, getHostFromSource, getOrigin, getProtocol, getProtocolFromSource, isDynamicBaseURLConfig, isRequestLike, matchesHostPattern, resolveBaseURL, resolveDynamicBaseURL, trimTrailingSlashes } from "./url.mjs";

package/dist/utils/is-api-error.d.mts

@@ -0,0 +1,2 @@
+import { isAPIError } from "@better-auth/core/utils/is-api-error";
+export { isAPIError };

package/dist/utils/is-api-error.mjs

@@ -0,0 +1,2 @@
+import { isAPIError } from "@better-auth/core/utils/is-api-error";
+export { isAPIError };

package/dist/utils/is-atom.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/is-atom.ts
+function isAtom(value) {
+	return typeof value === "object" && value !== null && "get" in value && typeof value.get === "function" && "lc" in value && typeof value.lc === "number";
+}
+//#endregion
+export { isAtom };

package/dist/utils/is-promise.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/is-promise.ts
+function isPromise(obj) {
+	return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+}
+//#endregion
+export { isPromise };

package/dist/utils/middleware-response.mjs

@@ -0,0 +1,7 @@
+//#region src/utils/middleware-response.ts
+const middlewareResponse = ({ message, status, code }) => ({ response: new Response(JSON.stringify({
+	message,
+	code
+}), { status }) });
+//#endregion
+export { middlewareResponse };