faire-auth 1.0.0

package/dist/db-BTKyYu-_.cjs

@@ -0,0 +1,1180 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+const require_hono = require('./hono-Cdukwu5K.cjs');
+const require_ip = require('./ip-B5SwXaMB.cjs');
+const require_json = require('./json-CcJ2HjGo.cjs');
+const require_schema = require('./schema-D-qjygfE.cjs');
+const require_kysely_adapter = require('./kysely-adapter-Bxi7sPdG.cjs');
+const require_adapter_factory = require('./adapter-factory-DT-_2aHJ.cjs');
+const require_memory_adapter = require('./memory-adapter-BlnDIAAX.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_utils = require("@faire-auth/core/utils");
+let zod = require("zod");
+zod = require_chunk.__toESM(zod);
+let kysely = require("kysely");
+let __faire_auth_core_crypto = require("@faire-auth/core/crypto");
+
+//#region src/db/field.ts
+const createFieldAttribute = (type, config) => {
+	return {
+		type,
+		...config
+	};
+};
+
+//#endregion
+//#region src/db/get-schema.ts
+function getSchema(config) {
+	const tables = require_adapter_factory.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 kysely.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 = (0, __faire_auth_core_env.createLogger)(config.logger);
+	const adapter = require_kysely_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 kysely.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 kysely.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: kysely.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(kysely.sql`CURRENT_TIMESTAMP(3)`);
+			else col = col.defaultTo(kysely.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(kysely.sql`CURRENT_TIMESTAMP(3)`);
+				else col = col.defaultTo(kysely.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 = require_hono.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 require_ip.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 = require_hono.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 require_ip.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 = require_hono.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 require_ip.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 = require_hono.getContext();
+		let entityToDelete = null;
+		try {
+			entityToDelete = (await require_ip.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 require_ip.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 = require_hono.getContext();
+		let entitiesToDelete = [];
+		try {
+			entitiesToDelete = await require_ip.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 require_ip.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 = (require_json.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 = require_json.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 require_ip.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 = require_json.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 = require_json.safeJSONParse(sessionStringified);
+						if (!s) return [];
+						const parsedSession = require_schema.parseSessionOutput(options, {
+							...s.session,
+							expiresAt: new Date(s.session.expiresAt)
+						});
+						sessions.push(parsedSession);
+					}
+				}
+				return sessions;
+			}
+			return await require_ip.getCurrentAdapter(adapter).findMany({
+				model: "session",
+				where: [{
+					field: "userId",
+					value: userId
+				}]
+			});
+		},
+		listUsers: async (limit, offset, sortBy, where) => {
+			return await require_ip.getCurrentAdapter(adapter).findMany({
+				model: "user",
+				...limit && { limit },
+				...offset && { offset },
+				...sortBy && { sortBy },
+				...where && { where }
+			});
+		},
+		countTotalUsers: async (where) => {
+			const total = await require_ip.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 = require_hono.getContext();
+			const ip = require_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 ? (0, __faire_auth_core_utils.getDate)(3600 * 24, "sec") : (0, __faire_auth_core_utils.getDate)(sessionExpiration, "sec"),
+				userId,
+				token: (0, __faire_auth_core_crypto.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 = require_json.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 = require_json.safeJSONParse(sessionStringified);
+					if (!s) return null;
+					return {
+						session: require_schema.parseSessionOutput(options, {
+							...s.session,
+							expiresAt: new Date(s.session.expiresAt),
+							createdAt: new Date(s.session.createdAt),
+							updatedAt: new Date(s.session.updatedAt)
+						}),
+						user: require_schema.parseUserOutput(options, {
+							...s.user,
+							createdAt: new Date(s.user.createdAt),
+							updatedAt: new Date(s.user.updatedAt)
+						})
+					};
+				}
+			}
+			const session = await require_ip.getCurrentAdapter(adapter).findOne({
+				model: "session",
+				where: [{
+					value: token,
+					field: "token"
+				}]
+			});
+			if (!session) return null;
+			const user = await require_ip.getCurrentAdapter(adapter).findOne({
+				model: "user",
+				where: [{
+					value: session.userId,
+					field: "id"
+				}]
+			});
+			if (!user) return null;
+			return {
+				session: require_schema.parseSessionOutput(options, session),
+				user: require_schema.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 = require_json.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 require_ip.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 require_ip.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 = require_json.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 } = require_json.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 = require_json.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 require_ip.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 ? require_json.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 require_ip.getCurrentAdapter(adapter).findMany({
+				model: "account",
+				where: [{
+					value: accountId,
+					field: "accountId"
+				}]
+			}).then((accounts) => {
+				return accounts.find((a) => a.providerId === providerId);
+			});
+			if (account) {
+				const user = await require_ip.getCurrentAdapter(adapter).findOne({
+					model: "user",
+					where: [{
+						value: account.userId,
+						field: "id"
+					}]
+				});
+				if (user) return {
+					user,
+					accounts: [account]
+				};
+				else {
+					const user$1 = await require_ip.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 require_ip.getCurrentAdapter(adapter).findOne({
+					model: "user",
+					where: [{
+						value: email.toLowerCase(),
+						field: "email"
+					}]
+				});
+				if (user) return {
+					user,
+					accounts: await require_ip.getCurrentAdapter(adapter).findMany({
+						model: "account",
+						where: [{
+							value: user.id,
+							field: "userId"
+						}]
+					}) || []
+				};
+				else return null;
+			}
+		},
+		findUserByEmail: async (email, options$1) => {
+			const user = await require_ip.getCurrentAdapter(adapter).findOne({
+				model: "user",
+				where: [{
+					value: email.toLowerCase(),
+					field: "email"
+				}]
+			});
+			if (!user) return null;
+			if (options$1?.includeAccounts) return {
+				user,
+				accounts: await require_ip.getCurrentAdapter(adapter).findMany({
+					model: "account",
+					where: [{
+						value: user.id,
+						field: "userId"
+					}]
+				})
+			};
+			return {
+				user,
+				accounts: []
+			};
+		},
+		findUserById: async (userId) => {
+			return await require_ip.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 require_ip.getCurrentAdapter(adapter).findMany({
+				model: "account",
+				where: [{
+					field: "userId",
+					value: userId
+				}]
+			});
+		},
+		findAccount: async (accountId) => {
+			return await require_ip.getCurrentAdapter(adapter).findOne({
+				model: "account",
+				where: [{
+					field: "accountId",
+					value: accountId
+				}]
+			});
+		},
+		findAccountByProviderId: async (accountId, providerId) => {
+			return await require_ip.getCurrentAdapter(adapter).findOne({
+				model: "account",
+				where: [{
+					field: "accountId",
+					value: accountId
+				}, {
+					field: "providerId",
+					value: providerId
+				}]
+			});
+		},
+		findAccountByUserId: async (userId) => {
+			return await require_ip.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 require_ip.getCurrentAdapter(adapter).findMany({
+				model: "verification",
+				where: [{
+					field: "identifier",
+					value: identifier
+				}],
+				sortBy: {
+					field: "createdAt",
+					direction: "desc"
+				},
+				limit: 1
+			});
+			if (!options.verification?.disableCleanup) await require_ip.getCurrentAdapter(adapter).deleteMany({
+				model: "verification",
+				where: [{
+					field: "expiresAt",
+					value: /* @__PURE__ */ new Date(),
+					operator: "lt"
+				}]
+			});
+			return verification[0] ?? null;
+		},
+		deleteVerificationValue: async (id) => {
+			await require_ip.getCurrentAdapter(adapter).delete({
+				model: "verification",
+				where: [{
+					field: "id",
+					value: id
+				}]
+			});
+		},
+		deleteVerificationByIdentifier: async (identifier) => {
+			await require_ip.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 = zod.json ? zod.json() : zod.any();
+		else if (field.type === "string[]" || field.type === "number[]") schema = zod.array(field.type === "string[]" ? zod.string() : zod.number());
+		else if (Array.isArray(field.type)) schema = zod.any();
+		else schema = zod[field.type]();
+		if (field?.required === false) schema = schema.optional();
+		if (field?.returned === false) return acc;
+		return {
+			...acc,
+			[key]: schema
+		};
+	}, {});
+	return zod.object(zodFields);
+}
+
+//#endregion
+//#region src/db/utils.ts
+function patchAdapterTransaction(adapter) {
+	if (!adapter.transaction) {
+		__faire_auth_core_env.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 (0, __faire_auth_core_static.isPromise)(res) ? res : Promise.resolve(res);
+		};
+	}
+	return adapter;
+}
+function getAdapter(options) {
+	if (!options.database) {
+		const tables = require_adapter_factory.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 __faire_auth_core_env.logger.debug("No database configuration provided. Using memory adapter in development");
+		return patchAdapterTransaction(require_memory_adapter.memoryAdapter(memoryDB)(options));
+	}
+	if (typeof options.database === "function") return patchAdapterTransaction(options.database(options));
+	const adapter = require_kysely_adapter.createKyselyAdapter(options);
+	const checkKysely = () => {
+		if (!adapter.kysely) throw new __faire_auth_core_error.FaireAuthError("Failed to initialize database adapter");
+		return adapter.kysely;
+	};
+	return patchAdapterTransaction(require_kysely_adapter.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
+Object.defineProperty(exports, 'convertFromDB', {
+  enumerable: true,
+  get: function () {
+    return convertFromDB;
+  }
+});
+Object.defineProperty(exports, 'convertToDB', {
+  enumerable: true,
+  get: function () {
+    return convertToDB;
+  }
+});
+Object.defineProperty(exports, 'createFieldAttribute', {
+  enumerable: true,
+  get: function () {
+    return createFieldAttribute;
+  }
+});
+Object.defineProperty(exports, 'createInternalAdapter', {
+  enumerable: true,
+  get: function () {
+    return createInternalAdapter;
+  }
+});
+Object.defineProperty(exports, 'getAdapter', {
+  enumerable: true,
+  get: function () {
+    return getAdapter;
+  }
+});
+Object.defineProperty(exports, 'getMigrations', {
+  enumerable: true,
+  get: function () {
+    return getMigrations;
+  }
+});
+Object.defineProperty(exports, 'getSchema', {
+  enumerable: true,
+  get: function () {
+    return getSchema;
+  }
+});
+Object.defineProperty(exports, 'getWithHooks', {
+  enumerable: true,
+  get: function () {
+    return getWithHooks;
+  }
+});
+Object.defineProperty(exports, 'matchType', {
+  enumerable: true,
+  get: function () {
+    return matchType;
+  }
+});
+Object.defineProperty(exports, 'toZodSchema', {
+  enumerable: true,
+  get: function () {
+    return toZodSchema;
+  }
+});