faire-auth 1.0.0 → 1.0.2

package/dist/auth-Bo9PDt5j.cjs

@@ -1,739 +0,0 @@
-const require_chunk = require('./chunk-oakRccI5.cjs');
-const require_crypto = require('./crypto-CcTxYH82.cjs');
-const require_cookies = require('./cookies-B5xeA6i8.cjs');
-const require_url = require('./url-D2yvKaM7.cjs');
-const require_social_providers = require('./social-providers-DcFNUT0S.cjs');
-const require_api = require('./api-Bm89BLgN.cjs');
-const require_kysely_adapter = require('./kysely-adapter-Bxi7sPdG.cjs');
-const require_adapter_factory = require('./adapter-factory-DT-_2aHJ.cjs');
-const require_db = require('./db-BTKyYu-_.cjs');
-const require_defu = require('./defu-B0Svx_x4.cjs');
-let __faire_auth_core_env = require("@faire-auth/core/env");
-let __faire_auth_core_error = require("@faire-auth/core/error");
-let __faire_auth_core_static = require("@faire-auth/core/static");
-let __faire_auth_core_datatypes = require("@faire-auth/core/datatypes");
-let __better_fetch_fetch = require("@better-fetch/fetch");
-let __faire_auth_core_crypto = require("@faire-auth/core/crypto");
-
-//#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(__faire_auth_core_env.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() {
-	return __faire_auth_core_env.env.CI !== "false" && ("BUILD_ID" in __faire_auth_core_env.env || "BUILD_NUMBER" in __faire_auth_core_env.env || "CI" in __faire_auth_core_env.env || "CI_APP_ID" in __faire_auth_core_env.env || "CI_BUILD_ID" in __faire_auth_core_env.env || "CI_BUILD_NUMBER" in __faire_auth_core_env.env || "CI_NAME" in __faire_auth_core_env.env || "CONTINUOUS_INTEGRATION" in __faire_auth_core_env.env || "RUN_ID" in __faire_auth_core_env.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 (0, __faire_auth_core_env.getEnvVar)("NODE_ENV") === "production" ? "production" : isCI() ? "ci" : (0, __faire_auth_core_env.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 (0, __faire_auth_core_datatypes.hashToBase64)(baseUrl ? baseUrl + projectName : projectName);
-		return projectIdCached;
-	}
-	if (baseUrl) {
-		projectIdCached = await (0, __faire_auth_core_datatypes.hashToBase64)(baseUrl);
-		return projectIdCached;
-	}
-	projectIdCached = (0, __faire_auth_core_crypto.generateId)(32);
-	return projectIdCached;
-}
-
-//#endregion
-//#region src/telemetry/index.ts
-function createTelemetry(options, context) {
-	const debugEnabled = options.telemetry?.debug || (0, __faire_auth_core_env.getBooleanEnvVar)("FAIRE_AUTH_TELEMETRY_DEBUG", false);
-	const TELEMETRY_ENDPOINT = __faire_auth_core_env.ENV.FAIRE_AUTH_TELEMETRY_ENDPOINT;
-	const track = async (event) => {
-		try {
-			if (context?.customTrack) await context.customTrack(event);
-			else if (debugEnabled) await Promise.resolve(__faire_auth_core_env.logger.info("telemetry event", JSON.stringify(event, null, 2)));
-			else await (0, __better_fetch_fetch.betterFetch)(TELEMETRY_ENDPOINT, {
-				method: "POST",
-				body: event
-			});
-		} catch {}
-	};
-	const isEnabled = () => {
-		const telemetryEnabled = options.telemetry?.enabled !== void 0 ? options.telemetry.enabled : false;
-		return ((0, __faire_auth_core_env.getBooleanEnvVar)("FAIRE_AUTH_TELEMETRY", false) || telemetryEnabled) && (context?.skipTestCheck || !(0, __faire_auth_core_env.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 ?? __faire_auth_core_env.env["FAIRE_AUTH_SECRET"] ?? __faire_auth_core_env.env["AUTH_SECRET"] ?? __faire_auth_core_static.DEFAULT_SECRET;
-	if (secret === __faire_auth_core_static.DEFAULT_SECRET) {
-		if ((0, __faire_auth_core_env.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 = require_defu.defu(options, restOpts);
-			}
-			if (result.context) context = {
-				...context,
-				...result.context
-			};
-		}
-	}
-	if (options.databaseHooks) dbHooks.push(options.databaseHooks);
-	context.internalAdapter = require_db.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 (0, __faire_auth_core_crypto.generateId)(size);
-	};
-};
-const init = (options) => {
-	const baseURL = require_url.getBaseURL(options.baseURL, options.basePath);
-	if (baseURL == null && !(0, __faire_auth_core_env.isDevelopment)() && !(0, __faire_auth_core_env.isTest)()) throw new Error("baseURL is required for auth context");
-	const adapter = require_db.getAdapter(options);
-	const internalPlugins = getInternalPlugins(options);
-	const logger$1 = (0, __faire_auth_core_env.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 ?? (0, __faire_auth_core_env.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 require_social_providers.social_providers_exports.socialProviders)) throw new Error(`${key} does not exist in known social providers`);
-			const provider = require_social_providers.social_providers_exports.socialProviders[key](value);
-			if (value.disableImplicitSignUp) provider.disableImplicitSignUp = value.disableImplicitSignUp;
-			return provider;
-		}).filter((x) => x !== null),
-		tables: require_adapter_factory.getAuthTables(options),
-		trustedOrigins: require_url.getTrustedOrigins(options, { baseURL }).trustedOrigins,
-		baseURL,
-		sessionConfig,
-		secret,
-		authCookies: require_cookies.getCookies(options),
-		logger: logger$1,
-		rateLimit,
-		generateId: generateId$1,
-		password: {
-			hash: options.emailAndPassword?.password?.hash ?? require_crypto.crypto_exports.hashPassword,
-			verify: options.emailAndPassword?.password?.verify ?? require_crypto.crypto_exports.verifyPassword,
-			config: {
-				minPasswordLength: options.emailAndPassword?.minPasswordLength ?? 8,
-				maxPasswordLength: options.emailAndPassword?.maxPasswordLength ?? 128
-			},
-			checkPassword: require_crypto.checkPassword
-		},
-		newSession: null,
-		adapter,
-		internalAdapter: require_db.createInternalAdapter(adapter, options, {
-			logger: logger$1,
-			generateId: generateId$1,
-			sessionConfig,
-			...secondaryStorage && { secondaryStorage }
-		}, options.databaseHooks ? [options.databaseHooks] : []),
-		createAuthCookie: require_cookies.createCookieCreator(options),
-		runMigrations: async () => {
-			if (!options.database || "updateMany" in options.database) throw new __faire_auth_core_error.FaireAuthError("Database is not provided or it's an adapter. Migrations are only supported with a database instance.");
-			const { runMigrations } = await require_db.getMigrations(options);
-			await runMigrations();
-		},
-		publishTelemetry: createTelemetry(options, {
-			adapter: adapter.id,
-			database: typeof options.database === "function" ? "adapter" : require_kysely_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 } = require_api.router(authContext, authOptions);
-	return {
-		handler: (request, Env, executionCtx) => {
-			const cfCtx = getCloudflareContext();
-			return app.fetch(request, Object.assign(__faire_auth_core_env.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;
-			}, {}),
-			...__faire_auth_core_error.BASE_ERROR_CODES
-		}
-	};
-};
-
-//#endregion
-Object.defineProperty(exports, 'createTelemetry', {
-  enumerable: true,
-  get: function () {
-    return createTelemetry;
-  }
-});
-Object.defineProperty(exports, 'defineOptions', {
-  enumerable: true,
-  get: function () {
-    return defineOptions;
-  }
-});
-Object.defineProperty(exports, 'faireAuth', {
-  enumerable: true,
-  get: function () {
-    return faireAuth;
-  }
-});
-Object.defineProperty(exports, 'getTelemetryAuthConfig', {
-  enumerable: true,
-  get: function () {
-    return getTelemetryAuthConfig;
-  }
-});
-Object.defineProperty(exports, 'init', {
-  enumerable: true,
-  get: function () {
-    return init;
-  }
-});