faire-auth 1.0.0

package/dist/auth-Ds4AG4h4.mjs

@@ -0,0 +1,709 @@
+import { n as crypto_exports, t as checkPassword } from "./crypto-CyQRFtkq.mjs";
+import { i as createCookieCreator, l as getCookies } from "./cookies-Ch1JfQIz.mjs";
+import { a as getTrustedOrigins, t as getBaseURL } from "./url-BoUuoIwZ.mjs";
+import { t as social_providers_exports } from "./social-providers-DoYJhBe3.mjs";
+import { t as router } from "./api-_B7qO28y.mjs";
+import { r as generateId } from "./utils-D4vZd1-9.mjs";
+import { r as getKyselyDatabaseType } from "./kysely-adapter-DRuoT_X8.mjs";
+import { n as getAuthTables } from "./adapter-factory-BXei1QRX.mjs";
+import { a as createInternalAdapter, r as getAdapter, s as getMigrations } from "./db-xiJtoDgz.mjs";
+import { t as defu } from "./defu-SZkpHhbR.mjs";
+import { ENV, createLogger, env, getBooleanEnvVar, getEnvVar, isDevelopment, isProduction, isTest, logger } from "@faire-auth/core/env";
+import { BASE_ERROR_CODES, FaireAuthError } from "@faire-auth/core/error";
+import { DEFAULT_SECRET } from "@faire-auth/core/static";
+import { hashToBase64 } from "@faire-auth/core/datatypes";
+import { betterFetch } from "@better-fetch/fetch";
+
+//#region src/context/cloudflare.ts
+/**
+* Symbol used as an index in the global scope to set and retrieve the Cloudflare context
+*
+* This is used both in production (in the actual built worker) and in development (`next dev`)
+*
+* Note: this symbol needs to be kept in sync with the one used in `src/cli/templates/worker.ts`
+*/
+const cloudflareContextSymbol = Symbol.for("__cloudflare-context__");
+/**
+* Get the cloudflare context from the current global scope
+*/
+function getCloudflareContext() {
+	return globalThis[cloudflareContextSymbol];
+}
+
+//#endregion
+//#region src/telemetry/detectors/detect-auth-config.ts
+function getTelemetryAuthConfig(options, context) {
+	return {
+		database: context?.database,
+		adapter: context?.adapter,
+		emailVerification: {
+			sendVerificationEmail: !!options.emailVerification?.sendVerificationEmail,
+			sendOnSignUp: !!options.emailVerification?.sendOnSignUp,
+			sendOnSignIn: !!options.emailVerification?.sendOnSignIn,
+			autoSignInAfterVerification: !!options.emailVerification?.autoSignInAfterVerification,
+			expiresIn: options.emailVerification?.expiresIn,
+			onEmailVerification: !!options.emailVerification?.onEmailVerification,
+			afterEmailVerification: !!options.emailVerification?.afterEmailVerification
+		},
+		emailAndPassword: {
+			enabled: !!options.emailAndPassword?.enabled,
+			disableSignUp: !!options.emailAndPassword?.disableSignUp,
+			requireEmailVerification: !!options.emailAndPassword?.requireEmailVerification,
+			maxPasswordLength: options.emailAndPassword?.maxPasswordLength,
+			minPasswordLength: options.emailAndPassword?.minPasswordLength,
+			sendResetPassword: !!options.emailAndPassword?.sendResetPassword,
+			resetPasswordTokenExpiresIn: options.emailAndPassword?.resetPasswordTokenExpiresIn,
+			onPasswordReset: !!options.emailAndPassword?.onPasswordReset,
+			password: {
+				hash: !!options.emailAndPassword?.password?.hash,
+				verify: !!options.emailAndPassword?.password?.verify
+			},
+			autoSignIn: !!options.emailAndPassword?.autoSignIn,
+			revokeSessionsOnPasswordReset: !!options.emailAndPassword?.revokeSessionsOnPasswordReset
+		},
+		socialProviders: Object.keys(options.socialProviders || {}).map((p) => {
+			const provider = options.socialProviders?.[p];
+			if (!provider) return {};
+			return {
+				id: p,
+				mapProfileToUser: !!provider.mapProfileToUser,
+				disableDefaultScope: !!provider.disableDefaultScope,
+				disableIdTokenSignIn: !!provider.disableIdTokenSignIn,
+				disableImplicitSignUp: provider.disableImplicitSignUp,
+				disableSignUp: provider.disableSignUp,
+				getUserInfo: !!provider.getUserInfo,
+				overrideUserInfoOnSignIn: !!provider.overrideUserInfoOnSignIn,
+				prompt: provider.prompt,
+				verifyIdToken: !!provider.verifyIdToken,
+				scope: provider.scope,
+				refreshAccessToken: !!provider.refreshAccessToken
+			};
+		}),
+		plugins: options.plugins?.map((p) => p.id.toString()),
+		user: {
+			modelName: options.user?.modelName,
+			fields: options.user?.fields,
+			additionalFields: options.user?.additionalFields,
+			changeEmail: {
+				enabled: options.user?.changeEmail?.enabled,
+				sendChangeEmailVerification: !!options.user?.changeEmail?.sendChangeEmailVerification
+			}
+		},
+		verification: {
+			modelName: options.verification?.modelName,
+			disableCleanup: options.verification?.disableCleanup,
+			fields: options.verification?.fields
+		},
+		session: {
+			modelName: options.session?.modelName,
+			additionalFields: options.session?.additionalFields,
+			cookieCache: {
+				enabled: options.session?.cookieCache?.enabled,
+				maxAge: options.session?.cookieCache?.maxAge
+			},
+			disableSessionRefresh: options.session?.disableSessionRefresh,
+			expiresIn: options.session?.expiresIn,
+			fields: options.session?.fields,
+			freshAge: options.session?.freshAge,
+			preserveSessionInDatabase: options.session?.preserveSessionInDatabase,
+			storeSessionInDatabase: options.session?.storeSessionInDatabase,
+			updateAge: options.session?.updateAge
+		},
+		account: {
+			modelName: options.account?.modelName,
+			fields: options.account?.fields,
+			encryptOAuthTokens: options.account?.encryptOAuthTokens,
+			updateAccountOnSignIn: options.account?.updateAccountOnSignIn,
+			accountLinking: {
+				enabled: options.account?.accountLinking?.enabled,
+				trustedProviders: options.account?.accountLinking?.trustedProviders,
+				updateUserInfoOnLink: options.account?.accountLinking?.updateUserInfoOnLink,
+				allowUnlinkingAll: options.account?.accountLinking?.allowUnlinkingAll
+			}
+		},
+		hooks: {
+			after: !!options.hooks?.after,
+			before: !!options.hooks?.before
+		},
+		secondaryStorage: !!options.secondaryStorage,
+		advanced: {
+			cookiePrefix: !!options.advanced?.cookiePrefix,
+			cookies: !!options.advanced?.cookies,
+			crossSubDomainCookies: {
+				domain: !!options.advanced?.crossSubDomainCookies?.domain,
+				enabled: options.advanced?.crossSubDomainCookies?.enabled,
+				additionalCookies: options.advanced?.crossSubDomainCookies?.additionalCookies
+			},
+			database: {
+				useNumberId: !!options.advanced?.database?.useNumberId,
+				generateId: options.advanced?.database?.generateId,
+				defaultFindManyLimit: options.advanced?.database?.defaultFindManyLimit
+			},
+			useSecureCookies: options.advanced?.useSecureCookies,
+			ipAddress: {
+				disableIpTracking: options.advanced?.ipAddress?.disableIpTracking,
+				ipAddressHeaders: options.advanced?.ipAddress?.ipAddressHeaders
+			},
+			disableCSRFCheck: options.advanced?.disableCSRFCheck,
+			cookieAttributes: {
+				expires: options.advanced?.defaultCookieAttributes?.expires,
+				secure: options.advanced?.defaultCookieAttributes?.secure,
+				sameSite: options.advanced?.defaultCookieAttributes?.sameSite,
+				domain: !!options.advanced?.defaultCookieAttributes?.domain,
+				path: options.advanced?.defaultCookieAttributes?.path,
+				httpOnly: options.advanced?.defaultCookieAttributes?.httpOnly
+			}
+		},
+		trustedOrigins: options.trustedOrigins?.length,
+		rateLimit: {
+			storage: options.rateLimit?.storage,
+			modelName: options.rateLimit?.modelName,
+			window: options.rateLimit?.window,
+			customStorage: !!options.rateLimit?.customStorage,
+			enabled: options.rateLimit?.enabled,
+			max: options.rateLimit?.max
+		},
+		onAPIError: {
+			errorURL: options.onAPIError?.errorURL,
+			onError: !!options.onAPIError?.onError,
+			throw: options.onAPIError?.throw
+		},
+		logger: {
+			disabled: options.logger?.disabled,
+			level: options.logger?.level,
+			log: !!options.logger?.log
+		},
+		databaseHooks: {
+			user: {
+				create: {
+					after: !!options.databaseHooks?.user?.create?.after,
+					before: !!options.databaseHooks?.user?.create?.before
+				},
+				update: {
+					after: !!options.databaseHooks?.user?.update?.after,
+					before: !!options.databaseHooks?.user?.update?.before
+				}
+			},
+			session: {
+				create: {
+					after: !!options.databaseHooks?.session?.create?.after,
+					before: !!options.databaseHooks?.session?.create?.before
+				},
+				update: {
+					after: !!options.databaseHooks?.session?.update?.after,
+					before: !!options.databaseHooks?.session?.update?.before
+				}
+			},
+			account: {
+				create: {
+					after: !!options.databaseHooks?.account?.create?.after,
+					before: !!options.databaseHooks?.account?.create?.before
+				},
+				update: {
+					after: !!options.databaseHooks?.account?.update?.after,
+					before: !!options.databaseHooks?.account?.update?.before
+				}
+			},
+			verification: {
+				create: {
+					after: !!options.databaseHooks?.verification?.create?.after,
+					before: !!options.databaseHooks?.verification?.create?.before
+				},
+				update: {
+					after: !!options.databaseHooks?.verification?.update?.after,
+					before: !!options.databaseHooks?.verification?.update?.before
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/package-json.ts
+let packageJSONCache;
+async function readRootPackageJson() {
+	if (packageJSONCache) return packageJSONCache;
+	try {
+		const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : "";
+		if (!cwd) return void 0;
+		const importRuntime = (m) => Function("mm", "return import(mm)")(m);
+		const [{ default: fs }, { default: path }] = await Promise.all([importRuntime("fs/promises"), importRuntime("path")]);
+		const raw = await fs.readFile(path.join(cwd, "package.json"), "utf-8");
+		packageJSONCache = JSON.parse(raw);
+		return packageJSONCache;
+	} catch {}
+}
+async function getPackageVersion(pkg) {
+	if (packageJSONCache) return packageJSONCache.dependencies?.[pkg] || packageJSONCache.devDependencies?.[pkg] || packageJSONCache.peerDependencies?.[pkg];
+	try {
+		const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : "";
+		if (!cwd) throw new Error("no-cwd");
+		const importRuntime = (m) => Function("mm", "return import(mm)")(m);
+		const [{ default: fs }, { default: path }] = await Promise.all([importRuntime("fs/promises"), importRuntime("path")]);
+		const pkgJsonPath = path.join(cwd, "node_modules", pkg, "package.json");
+		const raw = await fs.readFile(pkgJsonPath, "utf-8");
+		return JSON.parse(raw).version || await getVersionFromLocalPackageJson(pkg) || void 0;
+	} catch {}
+	return await getVersionFromLocalPackageJson(pkg);
+}
+async function getVersionFromLocalPackageJson(pkg) {
+	const json = await readRootPackageJson();
+	if (!json) return void 0;
+	return {
+		...json.dependencies,
+		...json.devDependencies,
+		...json.peerDependencies
+	}[pkg];
+}
+async function getNameFromLocalPackageJson() {
+	return (await readRootPackageJson())?.name;
+}
+
+//#endregion
+//#region src/telemetry/detectors/detect-database.ts
+const DATABASES = {
+	pg: "postgresql",
+	mysql: "mysql",
+	mariadb: "mariadb",
+	sqlite3: "sqlite",
+	"better-sqlite3": "sqlite",
+	"@prisma/client": "prisma",
+	mongoose: "mongodb",
+	mongodb: "mongodb",
+	"drizzle-orm": "drizzle"
+};
+async function detectDatabase() {
+	for (const [pkg, name] of Object.entries(DATABASES)) {
+		const version = await getPackageVersion(pkg);
+		if (version) return {
+			name,
+			version
+		};
+	}
+}
+
+//#endregion
+//#region src/telemetry/detectors/detect-framework.ts
+const FRAMEWORKS = {
+	next: "next",
+	nuxt: "nuxt",
+	"@remix-run/server-runtime": "remix",
+	astro: "astro",
+	"@sveltejs/kit": "sveltekit",
+	"solid-start": "solid-start",
+	"tanstack-start": "tanstack-start",
+	hono: "hono",
+	express: "express",
+	elysia: "elysia",
+	expo: "expo"
+};
+async function detectFramework() {
+	for (const [pkg, name] of Object.entries(FRAMEWORKS)) {
+		const version = await getPackageVersion(pkg);
+		if (version) return {
+			name,
+			version
+		};
+	}
+}
+
+//#endregion
+//#region src/telemetry/detectors/detect-project-info.ts
+function detectPackageManager() {
+	const userAgent = process.env.npm_config_user_agent;
+	if (!userAgent) return;
+	const pmSpec = userAgent.split(" ")[0];
+	const separatorPos = pmSpec.lastIndexOf("/");
+	const name = pmSpec.substring(0, separatorPos);
+	return {
+		name: name === "npminstall" ? "cnpm" : name,
+		version: pmSpec.substring(separatorPos + 1)
+	};
+}
+
+//#endregion
+//#region src/telemetry/detectors/detect-system-info.ts
+function getVendor() {
+	const hasAny = (...keys) => keys.some((k) => Boolean(env[k]));
+	if (hasAny("CF_PAGES", "CF_PAGES_URL", "CF_ACCOUNT_ID") || typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers") return "cloudflare";
+	if (hasAny("VERCEL", "VERCEL_URL", "VERCEL_ENV")) return "vercel";
+	if (hasAny("NETLIFY", "NETLIFY_URL")) return "netlify";
+	if (hasAny("RENDER", "RENDER_URL", "RENDER_INTERNAL_HOSTNAME", "RENDER_SERVICE_ID")) return "render";
+	if (hasAny("AWS_LAMBDA_FUNCTION_NAME", "AWS_EXECUTION_ENV", "LAMBDA_TASK_ROOT")) return "aws";
+	if (hasAny("GOOGLE_CLOUD_FUNCTION_NAME", "GOOGLE_CLOUD_PROJECT", "GCP_PROJECT", "K_SERVICE")) return "gcp";
+	if (hasAny("AZURE_FUNCTION_NAME", "FUNCTIONS_WORKER_RUNTIME", "WEBSITE_INSTANCE_ID", "WEBSITE_SITE_NAME")) return "azure";
+	if (hasAny("DENO_DEPLOYMENT_ID", "DENO_REGION")) return "deno-deploy";
+	if (hasAny("FLY_APP_NAME", "FLY_REGION", "FLY_ALLOC_ID")) return "fly-io";
+	if (hasAny("RAILWAY_STATIC_URL", "RAILWAY_ENVIRONMENT_NAME")) return "railway";
+	if (hasAny("DYNO", "HEROKU_APP_NAME")) return "heroku";
+	if (hasAny("DO_DEPLOYMENT_ID", "DO_APP_NAME", "DIGITALOCEAN")) return "digitalocean";
+	if (hasAny("KOYEB", "KOYEB_DEPLOYMENT_ID", "KOYEB_APP_NAME")) return "koyeb";
+	return null;
+}
+async function detectSystemInfo() {
+	try {
+		if (getVendor() === "cloudflare") return "cloudflare";
+		const importRuntime = (m) => Function("mm", "return import(mm)")(m);
+		const { default: os } = await importRuntime("os");
+		const cpus = os.cpus();
+		return {
+			deploymentVendor: getVendor(),
+			systemPlatform: os.platform(),
+			systemRelease: os.release(),
+			systemArchitecture: os.arch(),
+			cpuCount: cpus.length,
+			cpuModel: cpus.length ? cpus[0].model : null,
+			cpuSpeed: cpus.length ? cpus[0].speed : null,
+			memory: os.totalmem(),
+			isWSL: await isWsl(),
+			isDocker: await isDocker(),
+			isTTY: process.stdout.isTTY
+		};
+	} catch (e) {
+		return {
+			systemPlatform: null,
+			systemRelease: null,
+			systemArchitecture: null,
+			cpuCount: null,
+			cpuModel: null,
+			cpuSpeed: null,
+			memory: null,
+			isWSL: null,
+			isDocker: null,
+			isTTY: null
+		};
+	}
+}
+let isDockerCached;
+async function hasDockerEnv() {
+	if (getVendor() === "cloudflare") return false;
+	try {
+		const importRuntime = (m) => Function("mm", "return import(mm)")(m);
+		const { default: fs } = await importRuntime("fs");
+		fs.statSync("/.dockerenv");
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function hasDockerCGroup() {
+	if (getVendor() === "cloudflare") return false;
+	try {
+		const importRuntime = (m) => Function("mm", "return import(mm)")(m);
+		const { default: fs } = await importRuntime("fs");
+		return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+	} catch {
+		return false;
+	}
+}
+async function isDocker() {
+	if (getVendor() === "cloudflare") return false;
+	if (isDockerCached === void 0) isDockerCached = await hasDockerEnv() || await hasDockerCGroup();
+	return isDockerCached;
+}
+async function isWsl() {
+	try {
+		if (getVendor() === "cloudflare") return false;
+		if (process.platform !== "linux") return false;
+		const importRuntime = (m) => Function("mm", "return import(mm)")(m);
+		const { default: fs } = await importRuntime("fs");
+		const { default: os } = await importRuntime("os");
+		if (os.release().toLowerCase().includes("microsoft")) {
+			if (await isInsideContainer()) return false;
+			return true;
+		}
+		return fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !await isInsideContainer() : false;
+	} catch {
+		return false;
+	}
+}
+let isInsideContainerCached;
+const hasContainerEnv = async () => {
+	if (getVendor() === "cloudflare") return false;
+	try {
+		const importRuntime = (m) => Function("mm", "return import(mm)")(m);
+		const { default: fs } = await importRuntime("fs");
+		fs.statSync("/run/.containerenv");
+		return true;
+	} catch {
+		return false;
+	}
+};
+async function isInsideContainer() {
+	if (isInsideContainerCached === void 0) isInsideContainerCached = await hasContainerEnv() || await isDocker();
+	return isInsideContainerCached;
+}
+function isCI$1() {
+	return env.CI !== "false" && ("BUILD_ID" in env || "BUILD_NUMBER" in env || "CI" in env || "CI_APP_ID" in env || "CI_BUILD_ID" in env || "CI_BUILD_NUMBER" in env || "CI_NAME" in env || "CONTINUOUS_INTEGRATION" in env || "RUN_ID" in env);
+}
+
+//#endregion
+//#region src/telemetry/detectors/detect-runtime.ts
+function detectRuntime() {
+	if (typeof Deno !== "undefined") return {
+		name: "deno",
+		version: Deno?.version?.deno ?? null
+	};
+	if (typeof Bun !== "undefined") return {
+		name: "bun",
+		version: Bun?.version ?? null
+	};
+	if (typeof process !== "undefined" && process?.versions?.node) return {
+		name: "node",
+		version: process.versions.node ?? null
+	};
+	return {
+		name: "edge",
+		version: null
+	};
+}
+function detectEnvironment() {
+	return getEnvVar("NODE_ENV") === "production" ? "production" : isCI$1() ? "ci" : isTest() ? "test" : "development";
+}
+
+//#endregion
+//#region src/telemetry/project-id.ts
+let projectIdCached = null;
+async function getProjectId(baseUrl) {
+	if (projectIdCached) return projectIdCached;
+	const projectName = await getNameFromLocalPackageJson();
+	if (projectName) {
+		projectIdCached = await hashToBase64(baseUrl ? baseUrl + projectName : projectName);
+		return projectIdCached;
+	}
+	if (baseUrl) {
+		projectIdCached = await hashToBase64(baseUrl);
+		return projectIdCached;
+	}
+	projectIdCached = generateId(32);
+	return projectIdCached;
+}
+
+//#endregion
+//#region src/telemetry/index.ts
+function createTelemetry(options, context) {
+	const debugEnabled = options.telemetry?.debug || getBooleanEnvVar("FAIRE_AUTH_TELEMETRY_DEBUG", false);
+	const TELEMETRY_ENDPOINT = ENV.FAIRE_AUTH_TELEMETRY_ENDPOINT;
+	const track = async (event) => {
+		try {
+			if (context?.customTrack) await context.customTrack(event);
+			else if (debugEnabled) await Promise.resolve(logger.info("telemetry event", JSON.stringify(event, null, 2)));
+			else await betterFetch(TELEMETRY_ENDPOINT, {
+				method: "POST",
+				body: event
+			});
+		} catch {}
+	};
+	const isEnabled = () => {
+		const telemetryEnabled = options.telemetry?.enabled !== void 0 ? options.telemetry.enabled : false;
+		return (getBooleanEnvVar("FAIRE_AUTH_TELEMETRY", false) || telemetryEnabled) && (context?.skipTestCheck || !isTest());
+	};
+	let initDone;
+	let anonymousId;
+	let payload;
+	const enabled = isEnabled();
+	async function ensureInitialized() {
+		if (initDone) return initDone;
+		initDone = (async () => {
+			anonymousId = await getProjectId(options.baseURL);
+			payload = {
+				config: getTelemetryAuthConfig(options),
+				runtime: detectRuntime(),
+				database: await detectDatabase(),
+				framework: await detectFramework(),
+				environment: detectEnvironment(),
+				systemInfo: await detectSystemInfo(),
+				packageManager: detectPackageManager()
+			};
+			if (enabled) await track({
+				type: "init",
+				payload,
+				anonymousId
+			});
+		})();
+		return initDone;
+	}
+	return {
+		initPromise: ensureInitialized(),
+		async publish(event) {
+			if (!enabled) return;
+			await track({
+				type: event.type,
+				payload: event.payload,
+				anonymousId
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/init.ts
+const getInternalPlugins = (options) => {
+	const plugins = [];
+	if (options.advanced?.crossSubDomainCookies?.enabled === true) {}
+	return plugins;
+};
+const loadSecret = (options, logger$1) => {
+	const secret = options.secret ?? env["FAIRE_AUTH_SECRET"] ?? env["AUTH_SECRET"] ?? DEFAULT_SECRET;
+	if (secret === DEFAULT_SECRET) {
+		if (isProduction()) logger$1.error("You are using the default secret. Please set `FAIRE_AUTH_SECRET` in your environment variables or pass `secret` in your auth config.");
+	}
+	return secret;
+};
+const runPluginInit = (ctx, options) => {
+	let context = ctx;
+	const dbHooks = [];
+	for (const plugin of options.plugins ?? []) if (plugin.init) {
+		const result = plugin.init(context);
+		if (typeof result === "object") {
+			if (result.options) {
+				const { databaseHooks,...restOpts } = result.options;
+				if (result.options.databaseHooks) dbHooks.push(result.options.databaseHooks);
+				options = defu(options, restOpts);
+			}
+			if (result.context) context = {
+				...context,
+				...result.context
+			};
+		}
+	}
+	if (options.databaseHooks) dbHooks.push(options.databaseHooks);
+	context.internalAdapter = createInternalAdapter(ctx.adapter, options, context, dbHooks);
+	return [context, options];
+};
+const initGenerateId = (options) => {
+	const advDbGenId = options.advanced?.database?.generateId;
+	return ({ model, size }) => {
+		if (typeof advDbGenId === "function") return advDbGenId({
+			model,
+			...size != null ? { size } : {}
+		});
+		return generateId(size);
+	};
+};
+const init = (options) => {
+	const baseURL = getBaseURL(options.baseURL, options.basePath);
+	if (baseURL == null && !isDevelopment() && !isTest()) throw new Error("baseURL is required for auth context");
+	const adapter = getAdapter(options);
+	const internalPlugins = getInternalPlugins(options);
+	const logger$1 = createLogger(options.logger);
+	const secret = loadSecret(options, logger$1);
+	const generateId$1 = initGenerateId(options);
+	const secondaryStorage = options.secondaryStorage;
+	const sessionConfig = {
+		updateAge: options.session?.updateAge ?? 1440 * 60,
+		expiresIn: options.session?.expiresIn ?? 3600 * 24 * 7,
+		freshAge: options.session?.freshAge ?? 3600 * 24,
+		cookieRefreshCache: (() => {
+			const refreshCache = options.session?.cookieCache?.refreshCache;
+			const maxAge = options.session?.cookieCache?.maxAge ?? 300;
+			if (refreshCache === false || refreshCache === void 0) return false;
+			if (refreshCache === true) return {
+				enabled: true,
+				updateAge: Math.floor(maxAge * .2)
+			};
+			return {
+				enabled: true,
+				updateAge: refreshCache.updateAge !== void 0 ? refreshCache.updateAge : Math.floor(maxAge * .2)
+			};
+		})()
+	};
+	const rateLimit = {
+		...options.rateLimit,
+		enabled: options.rateLimit?.enabled ?? isProduction(),
+		window: options.rateLimit?.window ?? 10,
+		max: options.rateLimit?.max ?? 100,
+		storage: options.rateLimit?.storage ?? (options.secondaryStorage ? "secondary-storage" : "memory")
+	};
+	options.secret = secret;
+	options.baseURL = baseURL ? new URL(baseURL).origin : "";
+	options.basePath ??= "/api/auth";
+	options.plugins ??= [];
+	options.plugins.push(...internalPlugins);
+	return runPluginInit({
+		appName: options.appName ?? "Faire Auth",
+		socialProviders: Object.entries(options.socialProviders ?? {}).map(([key, value]) => {
+			if (value == null) return null;
+			if (value.enabled === false) return null;
+			if (!value.clientId) logger$1.warn(`Social provider ${key} is missing clientId or clientSecret`);
+			if (!(key in social_providers_exports.socialProviders)) throw new Error(`${key} does not exist in known social providers`);
+			const provider = social_providers_exports.socialProviders[key](value);
+			if (value.disableImplicitSignUp) provider.disableImplicitSignUp = value.disableImplicitSignUp;
+			return provider;
+		}).filter((x) => x !== null),
+		tables: getAuthTables(options),
+		trustedOrigins: getTrustedOrigins(options, { baseURL }).trustedOrigins,
+		baseURL,
+		sessionConfig,
+		secret,
+		authCookies: getCookies(options),
+		logger: logger$1,
+		rateLimit,
+		generateId: generateId$1,
+		password: {
+			hash: options.emailAndPassword?.password?.hash ?? crypto_exports.hashPassword,
+			verify: options.emailAndPassword?.password?.verify ?? crypto_exports.verifyPassword,
+			config: {
+				minPasswordLength: options.emailAndPassword?.minPasswordLength ?? 8,
+				maxPasswordLength: options.emailAndPassword?.maxPasswordLength ?? 128
+			},
+			checkPassword
+		},
+		newSession: null,
+		adapter,
+		internalAdapter: createInternalAdapter(adapter, options, {
+			logger: logger$1,
+			generateId: generateId$1,
+			sessionConfig,
+			...secondaryStorage && { secondaryStorage }
+		}, options.databaseHooks ? [options.databaseHooks] : []),
+		createAuthCookie: createCookieCreator(options),
+		runMigrations: async () => {
+			if (!options.database || "updateMany" in options.database) throw new FaireAuthError("Database is not provided or it's an adapter. Migrations are only supported with a database instance.");
+			const { runMigrations } = await getMigrations(options);
+			await runMigrations();
+		},
+		publishTelemetry: createTelemetry(options, {
+			adapter: adapter.id,
+			database: typeof options.database === "function" ? "adapter" : getKyselyDatabaseType(options.database) || "unknown"
+		}).publish,
+		...secondaryStorage && { secondaryStorage }
+	}, options);
+};
+
+//#endregion
+//#region src/auth.ts
+function defineOptions(config) {
+	return config;
+}
+const faireAuth = (options) => {
+	const [authContext, authOptions] = init(options);
+	const { api, app } = router(authContext, authOptions);
+	return {
+		handler: (request, Env, executionCtx) => {
+			const cfCtx = getCloudflareContext();
+			return app.fetch(request, Object.assign(ENV, cfCtx?.env, Env), executionCtx ?? cfCtx?.ctx);
+		},
+		app,
+		api,
+		options: authOptions,
+		$context: authContext,
+		$Infer: {
+			App: (_o) => app,
+			Api: (_a) => api
+		},
+		$ERROR_CODES: {
+			...authOptions.plugins?.reduce((acc, plugin) => {
+				if (plugin.$ERROR_CODES) return {
+					...acc,
+					...plugin.$ERROR_CODES
+				};
+				return acc;
+			}, {}),
+			...BASE_ERROR_CODES
+		}
+	};
+};
+
+//#endregion
+export { getTelemetryAuthConfig as a, createTelemetry as i, faireAuth as n, init as r, defineOptions as t };