faire-auth 1.0.3 → 1.1.0

package/dist/db-4tUsQJXd.mjs

@@ -1,1119 +0,0 @@
-import { n as getContext } from "./hono-CoKYWnXA.mjs";
-import { n as getCurrentAdapter, r as runWithTransaction, t as getIp } from "./ip-BjNYspCH.mjs";
-import { t as safeJSONParse } from "./json-B1v2qRTQ.mjs";
-import { r as generateId } from "./utils-D4vZd1-9.mjs";
-import { l as parseUserOutput, s as parseSessionOutput } from "./schema-DTIwLLmf.mjs";
-import { n as createKyselyAdapter, t as kyselyAdapter } from "./kysely-adapter-CtIdoHa8.mjs";
-import { n as getAuthTables } from "./adapter-factory-lKIOf2OR.mjs";
-import { t as memoryAdapter } from "./memory-adapter-Dp4XdCZK.mjs";
-import { createLogger, logger } from "@faire-auth/core/env";
-import { FaireAuthError } from "@faire-auth/core/error";
-import { isPromise } from "@faire-auth/core/static";
-import { getDate } from "@faire-auth/core/utils";
-import * as z$1 from "zod";
-import { sql } from "kysely";
-
-//#region src/db/field.ts
-const createFieldAttribute = (type, config) => {
-	return {
-		type,
-		...config
-	};
-};
-
-//#endregion
-//#region src/db/get-schema.ts
-function getSchema(config) {
-	const tables = getAuthTables(config);
-	let schema = {};
-	for (const key in tables) {
-		const table = tables[key];
-		const fields = table.fields;
-		let actualFields = {};
-		Object.entries(fields).forEach(([key$1, field]) => {
-			actualFields[field.fieldName || key$1] = field;
-			if (field.references) {
-				const refTable = tables[field.references.model];
-				if (refTable) actualFields[field.fieldName || key$1].references = {
-					...field.references,
-					model: refTable.modelName,
-					field: field.references.field
-				};
-			}
-		});
-		if (schema[table.modelName]) {
-			schema[table.modelName].fields = {
-				...schema[table.modelName].fields,
-				...actualFields
-			};
-			continue;
-		}
-		schema[table.modelName] = {
-			fields: actualFields,
-			order: table.order || Infinity
-		};
-	}
-	return schema;
-}
-
-//#endregion
-//#region src/db/get-migration.ts
-const map = {
-	postgres: {
-		string: [
-			"character varying",
-			"varchar",
-			"text"
-		],
-		number: [
-			"int4",
-			"integer",
-			"bigint",
-			"smallint",
-			"numeric",
-			"real",
-			"double precision"
-		],
-		boolean: ["bool", "boolean"],
-		date: [
-			"timestamptz",
-			"timestamp",
-			"date"
-		],
-		json: ["json", "jsonb"]
-	},
-	mysql: {
-		string: ["varchar", "text"],
-		number: [
-			"integer",
-			"int",
-			"bigint",
-			"smallint",
-			"decimal",
-			"float",
-			"double"
-		],
-		boolean: ["boolean", "tinyint"],
-		date: [
-			"timestamp",
-			"datetime",
-			"date"
-		],
-		json: ["json"]
-	},
-	sqlite: {
-		string: ["TEXT"],
-		number: ["INTEGER", "REAL"],
-		boolean: ["INTEGER", "BOOLEAN"],
-		date: ["DATE", "INTEGER"],
-		json: ["TEXT"]
-	},
-	mssql: {
-		string: ["varchar", "nvarchar"],
-		number: [
-			"int",
-			"bigint",
-			"smallint",
-			"decimal",
-			"float",
-			"double"
-		],
-		boolean: ["bit", "smallint"],
-		date: [
-			"datetime2",
-			"date",
-			"datetime"
-		],
-		json: ["varchar", "nvarchar"]
-	}
-};
-function matchType(columnDataType, fieldType, dbType) {
-	function normalize(type) {
-		return type.toLowerCase().split("(")[0].trim();
-	}
-	if (fieldType === "string[]" || fieldType === "number[]") return columnDataType.toLowerCase().includes("json");
-	const types = map[dbType];
-	return (Array.isArray(fieldType) ? types["string"].map((t) => t.toLowerCase()) : types[fieldType].map((t) => t.toLowerCase())).includes(normalize(columnDataType));
-}
-/**
-* Get the current PostgreSQL schema (search_path) for the database connection
-* Returns the first schema in the search_path, defaulting to 'public' if not found
-*/
-async function getPostgresSchema(db) {
-	try {
-		const result = await sql`SHOW search_path`.execute(db);
-		if (result.rows[0]?.search_path) return result.rows[0].search_path.split(",").map((s) => s.trim()).map((s) => s.replace(/^["']|["']$/g, "")).filter((s) => !s.startsWith("$"))[0] || "public";
-	} catch (error) {}
-	return "public";
-}
-async function getMigrations(config) {
-	const betterAuthSchema = getSchema(config);
-	const logger$1 = createLogger(config.logger);
-	const adapter = createKyselyAdapter(config);
-	if ("initialize" in adapter) await adapter.initialize();
-	let { kysely: db, databaseType: dbType } = adapter;
-	if (!dbType) {
-		logger$1.warn("Could not determine database type, defaulting to sqlite. Please provide a type in the database options to avoid this.");
-		dbType = "sqlite";
-	}
-	if (!db) {
-		logger$1.error("Only kysely adapter is supported for migrations. You can use `generate` command to generate the schema, if you're using a different adapter.");
-		process.exit(1);
-	}
-	let currentSchema = "public";
-	if (dbType === "postgres") {
-		currentSchema = await getPostgresSchema(db);
-		logger$1.debug(`PostgreSQL migration: Using schema '${currentSchema}' (from search_path)`);
-		try {
-			if (!(await sql`
-				SELECT schema_name
-				FROM information_schema.schemata
-				WHERE schema_name = ${currentSchema}
-			`.execute(db)).rows[0]) logger$1.warn(`Schema '${currentSchema}' does not exist. Tables will be inspected from available schemas. Consider creating the schema first or checking your database configuration.`);
-		} catch (error) {
-			logger$1.debug(`Could not verify schema existence: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	const allTableMetadata = await db.introspection.getTables();
-	let tableMetadata = allTableMetadata;
-	if (dbType === "postgres") try {
-		const tablesInSchema = await sql`
-				SELECT table_name
-				FROM information_schema.tables
-				WHERE table_schema = ${currentSchema}
-				AND table_type = 'BASE TABLE'
-			`.execute(db);
-		const tableNamesInSchema = new Set(tablesInSchema.rows.map((row) => row.table_name));
-		tableMetadata = allTableMetadata.filter((table) => table.schema === currentSchema && tableNamesInSchema.has(table.name));
-		logger$1.debug(`Found ${tableMetadata.length} table(s) in schema '${currentSchema}': ${tableMetadata.map((t) => t.name).join(", ") || "(none)"}`);
-	} catch (error) {
-		logger$1.warn(`Could not filter tables by schema. Using all discovered tables. Error: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	const toBeCreated = [];
-	const toBeAdded = [];
-	for (const [key, value] of Object.entries(betterAuthSchema)) {
-		const table = tableMetadata.find((t) => t.name === key);
-		if (!table) {
-			const tIndex = toBeCreated.findIndex((t) => t.table === key);
-			const tableData = {
-				table: key,
-				fields: value.fields,
-				order: value.order || Infinity
-			};
-			const insertIndex = toBeCreated.findIndex((t) => (t.order || Infinity) > tableData.order);
-			if (insertIndex === -1) if (tIndex === -1) toBeCreated.push(tableData);
-			else toBeCreated[tIndex].fields = {
-				...toBeCreated[tIndex].fields,
-				...value.fields
-			};
-			else toBeCreated.splice(insertIndex, 0, tableData);
-			continue;
-		}
-		let toBeAddedFields = {};
-		for (const [fieldName, field] of Object.entries(value.fields)) {
-			const column = table.columns.find((c) => c.name === fieldName);
-			if (!column) {
-				toBeAddedFields[fieldName] = field;
-				continue;
-			}
-			if (matchType(column.dataType, field.type, dbType)) continue;
-			else logger$1.warn(`Field ${fieldName} in table ${key} has a different type in the database. Expected ${field.type} but got ${column.dataType}.`);
-		}
-		if (Object.keys(toBeAddedFields).length > 0) toBeAdded.push({
-			table: key,
-			fields: toBeAddedFields,
-			order: value.order || Infinity
-		});
-	}
-	const migrations = [];
-	function getType(field, fieldName) {
-		const type = field.type;
-		const typeMap = {
-			string: {
-				sqlite: "text",
-				postgres: "text",
-				mysql: field.unique ? "varchar(255)" : field.references ? "varchar(36)" : "text",
-				mssql: field.unique || field.sortable ? "varchar(255)" : field.references ? "varchar(36)" : "varchar(8000)"
-			},
-			boolean: {
-				sqlite: "integer",
-				postgres: "boolean",
-				mysql: "boolean",
-				mssql: "smallint"
-			},
-			number: {
-				sqlite: field.bigint ? "bigint" : "integer",
-				postgres: field.bigint ? "bigint" : "integer",
-				mysql: field.bigint ? "bigint" : "integer",
-				mssql: field.bigint ? "bigint" : "integer"
-			},
-			date: {
-				sqlite: "date",
-				postgres: "timestamptz",
-				mysql: "timestamp(3)",
-				mssql: sql`datetime2(3)`
-			},
-			json: {
-				sqlite: "text",
-				postgres: "jsonb",
-				mysql: "json",
-				mssql: "varchar(8000)"
-			},
-			id: {
-				postgres: config.advanced?.database?.useNumberId ? "serial" : "text",
-				mysql: config.advanced?.database?.useNumberId ? "integer" : "varchar(36)",
-				mssql: config.advanced?.database?.useNumberId ? "integer" : "varchar(36)",
-				sqlite: config.advanced?.database?.useNumberId ? "integer" : "text"
-			},
-			foreignKeyId: {
-				postgres: config.advanced?.database?.useNumberId ? "integer" : "text",
-				mysql: config.advanced?.database?.useNumberId ? "integer" : "varchar(36)",
-				mssql: config.advanced?.database?.useNumberId ? "integer" : "varchar(36)",
-				sqlite: config.advanced?.database?.useNumberId ? "integer" : "text"
-			}
-		};
-		if (fieldName === "id" || field.references?.field === "id") {
-			if (fieldName === "id") return typeMap.id[dbType];
-			return typeMap.foreignKeyId[dbType];
-		}
-		if (dbType === "sqlite" && (type === "string[]" || type === "number[]")) return "text";
-		if (type === "string[]" || type === "number[]") return "jsonb";
-		if (Array.isArray(type)) return "text";
-		return typeMap[type][dbType || "sqlite"];
-	}
-	if (toBeAdded.length) for (const table of toBeAdded) for (const [fieldName, field] of Object.entries(table.fields)) {
-		const type = getType(field, fieldName);
-		const exec = db.schema.alterTable(table.table).addColumn(fieldName, type, (col) => {
-			col = field.required !== false ? col.notNull() : col;
-			if (field.references) col = col.references(`${field.references.model}.${field.references.field}`).onDelete(field.references.onDelete || "cascade");
-			if (field.unique) col = col.unique();
-			if (field.type === "date" && typeof field.defaultValue === "function" && (dbType === "postgres" || dbType === "mysql" || dbType === "mssql")) if (dbType === "mysql") col = col.defaultTo(sql`CURRENT_TIMESTAMP(3)`);
-			else col = col.defaultTo(sql`CURRENT_TIMESTAMP`);
-			return col;
-		});
-		migrations.push(exec);
-	}
-	if (toBeCreated.length) for (const table of toBeCreated) {
-		let dbT = db.schema.createTable(table.table).addColumn("id", config.advanced?.database?.useNumberId ? dbType === "postgres" ? "serial" : "integer" : dbType === "mysql" || dbType === "mssql" ? "varchar(36)" : "text", (col) => {
-			if (config.advanced?.database?.useNumberId) {
-				if (dbType === "postgres" || dbType === "sqlite") return col.primaryKey().notNull();
-				else if (dbType === "mssql") return col.identity().primaryKey().notNull();
-				return col.autoIncrement().primaryKey().notNull();
-			}
-			return col.primaryKey().notNull();
-		});
-		for (const [fieldName, field] of Object.entries(table.fields)) {
-			const type = getType(field, fieldName);
-			dbT = dbT.addColumn(fieldName, type, (col) => {
-				col = field.required !== false ? col.notNull() : col;
-				if (field.references) col = col.references(`${field.references.model}.${field.references.field}`).onDelete(field.references.onDelete || "cascade");
-				if (field.unique) col = col.unique();
-				if (field.type === "date" && typeof field.defaultValue === "function" && (dbType === "postgres" || dbType === "mysql" || dbType === "mssql")) if (dbType === "mysql") col = col.defaultTo(sql`CURRENT_TIMESTAMP(3)`);
-				else col = col.defaultTo(sql`CURRENT_TIMESTAMP`);
-				return col;
-			});
-		}
-		migrations.push(dbT);
-	}
-	async function runMigrations() {
-		for (const migration of migrations) await migration.execute();
-	}
-	async function compileMigrations() {
-		return migrations.map((m) => m.compile().sql).join(";\n\n") + ";";
-	}
-	return {
-		toBeCreated,
-		toBeAdded,
-		runMigrations,
-		compileMigrations
-	};
-}
-
-//#endregion
-//#region src/db/with-hooks.ts
-const getWithHooks = (adapter, hooks = []) => ({
-	async createWithHooks(data, model, customCreateFn) {
-		const ctx = getContext();
-		let actualData = data;
-		for (const hook of hooks) {
-			const toRun = hook[model]?.create?.before;
-			if (toRun) {
-				const result = await toRun(actualData, ctx);
-				if (result === false) return null;
-				if (typeof result === "object" && "data" in result) actualData = {
-					...actualData,
-					...result.data
-				};
-			}
-		}
-		const customCreated = customCreateFn ? await customCreateFn.fn(actualData) : null;
-		const created = !customCreateFn || customCreateFn.executeMainFn ? await getCurrentAdapter(adapter).create({
-			model,
-			data: actualData,
-			forceAllowId: true
-		}) : customCreated;
-		for (const hook of hooks) {
-			const toRun = hook[model]?.create?.after;
-			if (toRun) await toRun(created, ctx);
-		}
-		return created;
-	},
-	async updateWithHooks(data, where, model, customUpdateFn) {
-		const ctx = getContext();
-		let actualData = data;
-		for (const hook of hooks) {
-			const toRun = hook[model]?.update?.before;
-			if (toRun) {
-				const result = await toRun(data, ctx);
-				if (result === false) return null;
-				actualData = typeof result === "object" ? result.data : result;
-			}
-		}
-		const customUpdated = customUpdateFn ? await customUpdateFn.fn(actualData) : null;
-		const updated = !customUpdateFn || customUpdateFn.executeMainFn ? await getCurrentAdapter(adapter).update({
-			model,
-			update: actualData,
-			where
-		}) : customUpdated;
-		for (const hook of hooks) {
-			const toRun = hook[model]?.update?.after;
-			if (toRun) await toRun(updated, ctx);
-		}
-		return updated;
-	},
-	async updateManyWithHooks(data, where, model, customUpdateFn) {
-		const ctx = getContext();
-		let actualData = data;
-		for (const hook of hooks) {
-			const toRun = hook[model]?.update?.before;
-			if (toRun) {
-				const result = await toRun(data, ctx);
-				if (result === false) return null;
-				actualData = typeof result === "object" ? result.data : result;
-			}
-		}
-		const customUpdated = customUpdateFn ? await customUpdateFn.fn(actualData) : null;
-		const updated = !customUpdateFn || customUpdateFn.executeMainFn ? await getCurrentAdapter(adapter).updateMany({
-			model,
-			update: actualData,
-			where
-		}) : customUpdated;
-		for (const hook of hooks) {
-			const toRun = hook[model]?.update?.after;
-			if (toRun) await toRun(updated, ctx);
-		}
-		return updated;
-	},
-	async deleteWithHooks(where, model, customDeleteFn) {
-		const ctx = getContext();
-		let entityToDelete = null;
-		try {
-			entityToDelete = (await getCurrentAdapter(adapter).findMany({
-				model,
-				where,
-				limit: 1
-			}))[0] ?? null;
-		} catch (error) {}
-		if (entityToDelete) for (const hook of hooks) {
-			const toRun = hook[model]?.delete?.before;
-			if (toRun) {
-				if (await toRun(entityToDelete, ctx) === false) return null;
-			}
-		}
-		const customDeleted = customDeleteFn ? await customDeleteFn.fn(where) : null;
-		const deleted = !customDeleteFn || customDeleteFn.executeMainFn ? await getCurrentAdapter(adapter).delete({
-			model,
-			where
-		}) : customDeleted;
-		if (entityToDelete) for (const hook of hooks) {
-			const toRun = hook[model]?.delete?.after;
-			if (toRun) await toRun(entityToDelete, ctx);
-		}
-		return deleted;
-	},
-	async deleteManyWithHooks(where, model, customDeleteFn) {
-		const ctx = getContext();
-		let entitiesToDelete = [];
-		try {
-			entitiesToDelete = await getCurrentAdapter(adapter).findMany({
-				model,
-				where
-			});
-		} catch (error) {}
-		for (const entity of entitiesToDelete) for (const hook of hooks) {
-			const toRun = hook[model]?.delete?.before;
-			if (toRun) {
-				if (await toRun(entity, ctx) === false) return null;
-			}
-		}
-		const customDeleted = customDeleteFn ? await customDeleteFn.fn(where) : null;
-		const deleted = !customDeleteFn || customDeleteFn.executeMainFn ? await getCurrentAdapter(adapter).deleteMany({
-			model,
-			where
-		}) : customDeleted;
-		for (const entity of entitiesToDelete) for (const hook of hooks) {
-			const toRun = hook[model]?.delete?.after;
-			if (toRun) await toRun(entity, ctx);
-		}
-		return deleted;
-	}
-});
-
-//#endregion
-//#region src/db/internal-adapter.ts
-const createInternalAdapter = (adapter, options, context, hooks) => {
-	const secondaryStorage = context.secondaryStorage;
-	const sessionExpiration = context.sessionConfig.expiresIn;
-	const { createWithHooks, updateWithHooks, updateManyWithHooks, deleteWithHooks, deleteManyWithHooks } = getWithHooks(adapter, hooks);
-	async function refreshUserSessions(user) {
-		if (!secondaryStorage) return;
-		if (!user.id) return;
-		const listRaw = await secondaryStorage.get(`active-sessions-${user.id}`);
-		if (!listRaw) return;
-		const now = Date.now();
-		const validSessions = (safeJSONParse(listRaw) || []).filter((s) => s.expiresAt > now);
-		await Promise.all(validSessions.map(async ({ token }) => {
-			const cached = await secondaryStorage.get(token);
-			if (!cached) return;
-			const parsed = safeJSONParse(cached);
-			if (!parsed) return;
-			const sessionTTL = Math.max(Math.floor(new Date(parsed.session.expiresAt).getTime() - now) / 1e3, 0);
-			await secondaryStorage.set(token, JSON.stringify({
-				session: parsed.session,
-				user
-			}), Math.floor(sessionTTL));
-		}));
-	}
-	return {
-		createOAuthUser: async (user, account) => {
-			return runWithTransaction(adapter, async () => {
-				const createdUser = await createWithHooks({
-					...user,
-					createdAt: user.createdAt ? new Date(user.createdAt) : /* @__PURE__ */ new Date(),
-					updatedAt: user.updatedAt ? new Date(user.updatedAt) : /* @__PURE__ */ new Date()
-				}, "user");
-				return {
-					user: createdUser,
-					account: await createWithHooks({
-						...account,
-						userId: createdUser.id,
-						createdAt: account.createdAt ? new Date(account.createdAt) : /* @__PURE__ */ new Date(),
-						updatedAt: account.updatedAt ? new Date(account.updatedAt) : /* @__PURE__ */ new Date()
-					}, "account")
-				};
-			});
-		},
-		createUser: async (user) => {
-			return await createWithHooks({
-				...user,
-				createdAt: user.createdAt ? new Date(user.createdAt) : /* @__PURE__ */ new Date(),
-				updatedAt: user.updatedAt ? new Date(user.updatedAt) : /* @__PURE__ */ new Date(),
-				...user.email && { email: user.email.toLowerCase() }
-			}, "user");
-		},
-		createAccount: async (account) => {
-			return await createWithHooks({
-				...account,
-				createdAt: account.createdAt ? new Date(account.createdAt) : /* @__PURE__ */ new Date(),
-				updatedAt: account.updatedAt ? new Date(account.updatedAt) : /* @__PURE__ */ new Date()
-			}, "account");
-		},
-		listSessions: async (userId) => {
-			if (secondaryStorage) {
-				const currentList = await secondaryStorage.get(`active-sessions-${userId}`);
-				if (!currentList) return [];
-				const list = safeJSONParse(currentList) || [];
-				const now = Date.now();
-				const validSessions = list.filter((s) => s.expiresAt > now);
-				const sessions = [];
-				for (const session of validSessions) {
-					const sessionStringified = await secondaryStorage.get(session.token);
-					if (sessionStringified) {
-						const s = safeJSONParse(sessionStringified);
-						if (!s) return [];
-						const parsedSession = parseSessionOutput(options, {
-							...s.session,
-							expiresAt: new Date(s.session.expiresAt)
-						});
-						sessions.push(parsedSession);
-					}
-				}
-				return sessions;
-			}
-			return await getCurrentAdapter(adapter).findMany({
-				model: "session",
-				where: [{
-					field: "userId",
-					value: userId
-				}]
-			});
-		},
-		listUsers: async (limit, offset, sortBy, where) => {
-			return await getCurrentAdapter(adapter).findMany({
-				model: "user",
-				...limit && { limit },
-				...offset && { offset },
-				...sortBy && { sortBy },
-				...where && { where }
-			});
-		},
-		countTotalUsers: async (where) => {
-			const total = await getCurrentAdapter(adapter).count({
-				model: "user",
-				...where && { where }
-			});
-			if (typeof total === "string") return parseInt(total);
-			return total;
-		},
-		deleteUser: async (userId) => {
-			if (secondaryStorage) await secondaryStorage.delete(`active-sessions-${userId}`);
-			if (!secondaryStorage || options.session?.storeSessionInDatabase) await deleteManyWithHooks([{
-				field: "userId",
-				value: userId
-			}], "session");
-			await deleteManyWithHooks([{
-				field: "userId",
-				value: userId
-			}], "account");
-			await deleteWithHooks([{
-				field: "id",
-				value: userId
-			}], "user");
-		},
-		createSession: async (userId, dontRememberMe, override, overrideAll) => {
-			const ctx = getContext();
-			const ip = getIp(ctx.req, options);
-			const ua = ctx.req.header("user-agent");
-			const { id: _,...rest } = override || {};
-			const data = {
-				...ip && { ipAddress: ip },
-				...ua && { userAgent: ua },
-				...rest,
-				expiresAt: dontRememberMe ? getDate(3600 * 24, "sec") : getDate(sessionExpiration, "sec"),
-				userId,
-				token: generateId(32),
-				createdAt: /* @__PURE__ */ new Date(),
-				updatedAt: /* @__PURE__ */ new Date(),
-				...overrideAll ? rest : {}
-			};
-			return await createWithHooks(data, "session", secondaryStorage ? {
-				fn: async (sessionData) => {
-					/**
-					* store the session token for the user
-					* so we can retrieve it later for listing sessions
-					*/
-					const currentList = await secondaryStorage.get(`active-sessions-${userId}`);
-					let list = [];
-					const now = Date.now();
-					if (currentList) {
-						list = safeJSONParse(currentList) || [];
-						list = list.filter((session) => session.expiresAt > now);
-					}
-					const sorted = list.sort((a, b) => a.expiresAt - b.expiresAt);
-					let furthestSessionExp = sorted.at(-1)?.expiresAt;
-					sorted.push({
-						token: data.token,
-						expiresAt: data.expiresAt.getTime()
-					});
-					if (!furthestSessionExp || furthestSessionExp < data.expiresAt.getTime()) furthestSessionExp = data.expiresAt.getTime();
-					const furthestSessionTTL = Math.max(Math.floor((furthestSessionExp - now) / 1e3), 0);
-					if (furthestSessionTTL > 0) await secondaryStorage.set(`active-sessions-${userId}`, JSON.stringify(sorted), furthestSessionTTL);
-					const user = await adapter.findOne({
-						model: "user",
-						where: [{
-							field: "id",
-							value: userId
-						}]
-					});
-					const sessionTTL = Math.max(Math.floor((data.expiresAt.getTime() - now) / 1e3), 0);
-					if (sessionTTL > 0) await secondaryStorage.set(data.token, JSON.stringify({
-						session: sessionData,
-						user
-					}), sessionTTL);
-					return sessionData;
-				},
-				executeMainFn: options.session?.storeSessionInDatabase === true
-			} : void 0);
-		},
-		findSession: async (token) => {
-			if (secondaryStorage) {
-				const sessionStringified = await secondaryStorage.get(token);
-				if (!sessionStringified && !options.session?.storeSessionInDatabase) return null;
-				if (sessionStringified) {
-					const s = safeJSONParse(sessionStringified);
-					if (!s) return null;
-					return {
-						session: parseSessionOutput(options, {
-							...s.session,
-							expiresAt: new Date(s.session.expiresAt),
-							createdAt: new Date(s.session.createdAt),
-							updatedAt: new Date(s.session.updatedAt)
-						}),
-						user: parseUserOutput(options, {
-							...s.user,
-							createdAt: new Date(s.user.createdAt),
-							updatedAt: new Date(s.user.updatedAt)
-						})
-					};
-				}
-			}
-			const session = await getCurrentAdapter(adapter).findOne({
-				model: "session",
-				where: [{
-					value: token,
-					field: "token"
-				}]
-			});
-			if (!session) return null;
-			const user = await getCurrentAdapter(adapter).findOne({
-				model: "user",
-				where: [{
-					value: session.userId,
-					field: "id"
-				}]
-			});
-			if (!user) return null;
-			return {
-				session: parseSessionOutput(options, session),
-				user: parseUserOutput(options, user)
-			};
-		},
-		findSessions: async (sessionTokens) => {
-			if (secondaryStorage) {
-				const sessions$1 = [];
-				for (const sessionToken of sessionTokens) {
-					const sessionStringified = await secondaryStorage.get(sessionToken);
-					if (sessionStringified) {
-						const s = safeJSONParse(sessionStringified);
-						if (!s) return [];
-						const session = {
-							session: {
-								...s.session,
-								expiresAt: new Date(s.session.expiresAt)
-							},
-							user: {
-								...s.user,
-								createdAt: new Date(s.user.createdAt),
-								updatedAt: new Date(s.user.updatedAt)
-							}
-						};
-						sessions$1.push(session);
-					}
-				}
-				return sessions$1;
-			}
-			const sessions = await getCurrentAdapter(adapter).findMany({
-				model: "session",
-				where: [{
-					field: "token",
-					value: sessionTokens,
-					operator: "in"
-				}]
-			});
-			const userIds = sessions.map((session) => {
-				return session.userId;
-			});
-			if (!userIds.length) return [];
-			const users = await getCurrentAdapter(adapter).findMany({
-				model: "user",
-				where: [{
-					field: "id",
-					value: userIds,
-					operator: "in"
-				}]
-			});
-			return sessions.map((session) => {
-				const user = users.find((u) => u.id === session.userId);
-				if (!user) return null;
-				return {
-					session,
-					user
-				};
-			});
-		},
-		updateSession: async (sessionToken, session) => {
-			return await updateWithHooks(session, [{
-				field: "token",
-				value: sessionToken
-			}], "session", secondaryStorage ? {
-				fn: async (data) => {
-					const currentSession = await secondaryStorage.get(sessionToken);
-					let updatedSession;
-					if (currentSession) {
-						const parsedSession = safeJSONParse(currentSession);
-						if (!parsedSession) return;
-						updatedSession = {
-							...parsedSession.session,
-							...data
-						};
-						return updatedSession;
-					}
-				},
-				executeMainFn: options.session?.storeSessionInDatabase === true
-			} : void 0);
-		},
-		deleteSession: async (token) => {
-			if (secondaryStorage) {
-				const data = await secondaryStorage.get(token);
-				if (data) {
-					const { session } = safeJSONParse(data) ?? {};
-					if (!session) {
-						context.logger.error("Session not found in secondary storage");
-						return;
-					}
-					const userId = session.userId;
-					const currentList = await secondaryStorage.get(`active-sessions-${userId}`);
-					if (currentList) {
-						let list = safeJSONParse(currentList) || [];
-						const now = Date.now();
-						const filtered = list.filter((session$1) => session$1.expiresAt > now && session$1.token !== token);
-						const furthestSessionExp = filtered.sort((a, b) => a.expiresAt - b.expiresAt).at(-1)?.expiresAt;
-						if (filtered.length > 0 && furthestSessionExp && furthestSessionExp > Date.now()) await secondaryStorage.set(`active-sessions-${userId}`, JSON.stringify(filtered), Math.floor((furthestSessionExp - now) / 1e3));
-						else await secondaryStorage.delete(`active-sessions-${userId}`);
-					} else context.logger.error("Active sessions list not found in secondary storage");
-				}
-				await secondaryStorage.delete(token);
-				if (!options.session?.storeSessionInDatabase || options.session?.preserveSessionInDatabase) return;
-			}
-			await getCurrentAdapter(adapter).delete({
-				model: "session",
-				where: [{
-					field: "token",
-					value: token
-				}]
-			});
-		},
-		deleteAccounts: async (userId) => {
-			await deleteManyWithHooks([{
-				field: "userId",
-				value: userId
-			}], "account");
-		},
-		deleteAccount: async (accountId) => {
-			await deleteWithHooks([{
-				field: "id",
-				value: accountId
-			}], "account");
-		},
-		deleteSessions: async (userIdOrSessionTokens) => {
-			if (secondaryStorage) {
-				if (typeof userIdOrSessionTokens === "string") {
-					const activeSession = await secondaryStorage.get(`active-sessions-${userIdOrSessionTokens}`);
-					const sessions = activeSession ? safeJSONParse(activeSession) : [];
-					if (!sessions) return;
-					for (const session of sessions) await secondaryStorage.delete(session.token);
-				} else for (const sessionToken of userIdOrSessionTokens) if (await secondaryStorage.get(sessionToken)) await secondaryStorage.delete(sessionToken);
-				if (!options.session?.storeSessionInDatabase || options.session?.preserveSessionInDatabase) return;
-			}
-			await deleteManyWithHooks([{
-				field: Array.isArray(userIdOrSessionTokens) ? "token" : "userId",
-				value: userIdOrSessionTokens,
-				...Array.isArray(userIdOrSessionTokens) && { operator: "in" }
-			}], "session");
-		},
-		findOAuthUser: async (email, accountId, providerId) => {
-			const account = await getCurrentAdapter(adapter).findMany({
-				model: "account",
-				where: [{
-					value: accountId,
-					field: "accountId"
-				}]
-			}).then((accounts) => {
-				return accounts.find((a) => a.providerId === providerId);
-			});
-			if (account) {
-				const user = await getCurrentAdapter(adapter).findOne({
-					model: "user",
-					where: [{
-						value: account.userId,
-						field: "id"
-					}]
-				});
-				if (user) return {
-					user,
-					accounts: [account]
-				};
-				else {
-					const user$1 = await getCurrentAdapter(adapter).findOne({
-						model: "user",
-						where: [{
-							value: email.toLowerCase(),
-							field: "email"
-						}]
-					});
-					if (user$1) return {
-						user: user$1,
-						accounts: [account]
-					};
-					return null;
-				}
-			} else {
-				const user = await getCurrentAdapter(adapter).findOne({
-					model: "user",
-					where: [{
-						value: email.toLowerCase(),
-						field: "email"
-					}]
-				});
-				if (user) return {
-					user,
-					accounts: await getCurrentAdapter(adapter).findMany({
-						model: "account",
-						where: [{
-							value: user.id,
-							field: "userId"
-						}]
-					}) || []
-				};
-				else return null;
-			}
-		},
-		findUserByEmail: async (email, options$1) => {
-			const user = await getCurrentAdapter(adapter).findOne({
-				model: "user",
-				where: [{
-					value: email.toLowerCase(),
-					field: "email"
-				}]
-			});
-			if (!user) return null;
-			if (options$1?.includeAccounts) return {
-				user,
-				accounts: await getCurrentAdapter(adapter).findMany({
-					model: "account",
-					where: [{
-						value: user.id,
-						field: "userId"
-					}]
-				})
-			};
-			return {
-				user,
-				accounts: []
-			};
-		},
-		findUserById: async (userId) => {
-			return await getCurrentAdapter(adapter).findOne({
-				model: "user",
-				where: [{
-					field: "id",
-					value: userId
-				}]
-			});
-		},
-		linkAccount: async (account) => {
-			return await createWithHooks({
-				...account,
-				createdAt: account.createdAt ? new Date(account.createdAt) : /* @__PURE__ */ new Date(),
-				updatedAt: account.updatedAt ? new Date(account.updatedAt) : /* @__PURE__ */ new Date()
-			}, "account");
-		},
-		updateUser: async (userId, data) => {
-			const user = await updateWithHooks(data, [{
-				field: "id",
-				value: userId
-			}], "user");
-			if (user) {
-				await refreshUserSessions(user);
-				await refreshUserSessions(user);
-			}
-			return user;
-		},
-		updateUserByEmail: async (email, data) => {
-			const user = await updateWithHooks(data, [{
-				field: "email",
-				value: email.toLowerCase()
-			}], "user");
-			if (user) {
-				await refreshUserSessions(user);
-				await refreshUserSessions(user);
-			}
-			return user;
-		},
-		updatePassword: async (userId, password) => {
-			await updateManyWithHooks({ password }, [{
-				field: "userId",
-				value: userId
-			}, {
-				field: "providerId",
-				value: "credential"
-			}], "account");
-		},
-		findAccounts: async (userId) => {
-			return await getCurrentAdapter(adapter).findMany({
-				model: "account",
-				where: [{
-					field: "userId",
-					value: userId
-				}]
-			});
-		},
-		findAccount: async (accountId) => {
-			return await getCurrentAdapter(adapter).findOne({
-				model: "account",
-				where: [{
-					field: "accountId",
-					value: accountId
-				}]
-			});
-		},
-		findAccountByProviderId: async (accountId, providerId) => {
-			return await getCurrentAdapter(adapter).findOne({
-				model: "account",
-				where: [{
-					field: "accountId",
-					value: accountId
-				}, {
-					field: "providerId",
-					value: providerId
-				}]
-			});
-		},
-		findAccountByUserId: async (userId) => {
-			return await getCurrentAdapter(adapter).findMany({
-				model: "account",
-				where: [{
-					field: "userId",
-					value: userId
-				}]
-			});
-		},
-		updateAccount: async (id, data) => {
-			return await updateWithHooks(data, [{
-				field: "id",
-				value: id
-			}], "account");
-		},
-		createVerificationValue: async (data) => {
-			return await createWithHooks({
-				createdAt: /* @__PURE__ */ new Date(),
-				updatedAt: /* @__PURE__ */ new Date(),
-				...data
-			}, "verification");
-		},
-		findVerificationValue: async (identifier) => {
-			const verification = await getCurrentAdapter(adapter).findMany({
-				model: "verification",
-				where: [{
-					field: "identifier",
-					value: identifier
-				}],
-				sortBy: {
-					field: "createdAt",
-					direction: "desc"
-				},
-				limit: 1
-			});
-			if (!options.verification?.disableCleanup) await getCurrentAdapter(adapter).deleteMany({
-				model: "verification",
-				where: [{
-					field: "expiresAt",
-					value: /* @__PURE__ */ new Date(),
-					operator: "lt"
-				}]
-			});
-			return verification[0] ?? null;
-		},
-		deleteVerificationValue: async (id) => {
-			await getCurrentAdapter(adapter).delete({
-				model: "verification",
-				where: [{
-					field: "id",
-					value: id
-				}]
-			});
-		},
-		deleteVerificationByIdentifier: async (identifier) => {
-			await getCurrentAdapter(adapter).delete({
-				model: "verification",
-				where: [{
-					field: "identifier",
-					value: identifier
-				}]
-			});
-		},
-		updateVerificationValue: async (id, data) => {
-			return await updateWithHooks(data, [{
-				field: "id",
-				value: id
-			}], "verification");
-		}
-	};
-};
-
-//#endregion
-//#region src/db/to-zod.ts
-function toZodSchema({ fields, isClientSide }) {
-	const zodFields = Object.keys(fields).reduce((acc, key) => {
-		const field = fields[key];
-		if (!field) return acc;
-		if (isClientSide && field.input === false) return acc;
-		let schema;
-		if (field.type === "json") schema = z$1.json ? z$1.json() : z$1.any();
-		else if (field.type === "string[]" || field.type === "number[]") schema = z$1.array(field.type === "string[]" ? z$1.string() : z$1.number());
-		else if (Array.isArray(field.type)) schema = z$1.any();
-		else schema = z$1[field.type]();
-		if (field?.required === false) schema = schema.optional();
-		if (field?.returned === false) return acc;
-		return {
-			...acc,
-			[key]: schema
-		};
-	}, {});
-	return z$1.object(zodFields);
-}
-
-//#endregion
-//#region src/db/utils.ts
-function patchAdapterTransaction(adapter) {
-	if (!adapter.transaction) {
-		logger.warn("Adapter does not correctly implement transaction function, patching it automatically. Please update your adapter implementation.");
-		adapter.transaction = (cb) => {
-			const res = cb(adapter);
-			return isPromise(res) ? res : Promise.resolve(res);
-		};
-	}
-	return adapter;
-}
-function getAdapter(options) {
-	if (!options.database) {
-		const tables = getAuthTables(options);
-		const memoryDB = Object.keys(tables).reduce((acc, key) => {
-			acc[key] = [];
-			return acc;
-		}, {});
-		if (options.logger && options.logger.log) options.logger.log("debug", "No database configuration provided. Using memory adapter in development");
-		else logger.debug("No database configuration provided. Using memory adapter in development");
-		return patchAdapterTransaction(memoryAdapter(memoryDB)(options));
-	}
-	if (typeof options.database === "function") return patchAdapterTransaction(options.database(options));
-	const adapter = createKyselyAdapter(options);
-	const checkKysely = () => {
-		if (!adapter.kysely) throw new FaireAuthError("Failed to initialize database adapter");
-		return adapter.kysely;
-	};
-	return patchAdapterTransaction(kyselyAdapter("initialize" in adapter ? adapter.initialize().then(checkKysely) : checkKysely(), {
-		type: adapter.databaseType ?? "sqlite",
-		debugLogs: "debugLogs" in options.database ? options.database.debugLogs : false,
-		transaction: adapter.transaction
-	})(options));
-}
-function convertToDB(fields, values) {
-	let result = values.id ? { id: values.id } : {};
-	for (const key in fields) {
-		const field = fields[key];
-		const value = values[key];
-		if (value === void 0) continue;
-		result[field.fieldName || key] = value;
-	}
-	return result;
-}
-function convertFromDB(fields, values) {
-	if (!values) return null;
-	let result = { id: values.id };
-	for (const [key, value] of Object.entries(fields)) result[key] = values[value.fieldName || key];
-	return result;
-}
-
-//#endregion
-export { createInternalAdapter as a, matchType as c, toZodSchema as i, getSchema as l, convertToDB as n, getWithHooks as o, getAdapter as r, getMigrations as s, convertFromDB as t, createFieldAttribute as u };