appos 0.3.5-0 → 0.3.6-0

package/dist/exports/api/adapter-C2mMJKvG.mjs

@@ -0,0 +1,1504 @@
+//#region ../../node_modules/.bun/@better-auth+core@1.4.7+96c18005d8555383/node_modules/@better-auth/core/dist/get-tables-DeuRhD_P.mjs
+const getAuthTables = (options) => {
+	const pluginSchema = (options.plugins ?? []).reduce((acc, plugin) => {
+		const schema = plugin.schema;
+		if (!schema) return acc;
+		for (const [key, value] of Object.entries(schema)) acc[key] = {
+			fields: {
+				...acc[key]?.fields,
+				...value.fields
+			},
+			modelName: value.modelName || key
+		};
+		return acc;
+	}, {});
+	const shouldAddRateLimitTable = options.rateLimit?.storage === "database";
+	const rateLimitTable = { rateLimit: {
+		modelName: options.rateLimit?.modelName || "rateLimit",
+		fields: {
+			key: {
+				type: "string",
+				fieldName: options.rateLimit?.fields?.key || "key"
+			},
+			count: {
+				type: "number",
+				fieldName: options.rateLimit?.fields?.count || "count"
+			},
+			lastRequest: {
+				type: "number",
+				bigint: true,
+				fieldName: options.rateLimit?.fields?.lastRequest || "lastRequest"
+			}
+		}
+	} };
+	const { user, session, account, ...pluginTables } = pluginSchema;
+	const sessionTable = { session: {
+		modelName: options.session?.modelName || "session",
+		fields: {
+			expiresAt: {
+				type: "date",
+				required: true,
+				fieldName: options.session?.fields?.expiresAt || "expiresAt"
+			},
+			token: {
+				type: "string",
+				required: true,
+				fieldName: options.session?.fields?.token || "token",
+				unique: true
+			},
+			createdAt: {
+				type: "date",
+				required: true,
+				fieldName: options.session?.fields?.createdAt || "createdAt",
+				defaultValue: () => /* @__PURE__ */ new Date()
+			},
+			updatedAt: {
+				type: "date",
+				required: true,
+				fieldName: options.session?.fields?.updatedAt || "updatedAt",
+				onUpdate: () => /* @__PURE__ */ new Date()
+			},
+			ipAddress: {
+				type: "string",
+				required: false,
+				fieldName: options.session?.fields?.ipAddress || "ipAddress"
+			},
+			userAgent: {
+				type: "string",
+				required: false,
+				fieldName: options.session?.fields?.userAgent || "userAgent"
+			},
+			userId: {
+				type: "string",
+				fieldName: options.session?.fields?.userId || "userId",
+				references: {
+					model: options.user?.modelName || "user",
+					field: "id",
+					onDelete: "cascade"
+				},
+				required: true,
+				index: true
+			},
+			...session?.fields,
+			...options.session?.additionalFields
+		},
+		order: 2
+	} };
+	return {
+		user: {
+			modelName: options.user?.modelName || "user",
+			fields: {
+				name: {
+					type: "string",
+					required: true,
+					fieldName: options.user?.fields?.name || "name",
+					sortable: true
+				},
+				email: {
+					type: "string",
+					unique: true,
+					required: true,
+					fieldName: options.user?.fields?.email || "email",
+					sortable: true
+				},
+				emailVerified: {
+					type: "boolean",
+					defaultValue: false,
+					required: true,
+					fieldName: options.user?.fields?.emailVerified || "emailVerified",
+					input: false
+				},
+				image: {
+					type: "string",
+					required: false,
+					fieldName: options.user?.fields?.image || "image"
+				},
+				createdAt: {
+					type: "date",
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					required: true,
+					fieldName: options.user?.fields?.createdAt || "createdAt"
+				},
+				updatedAt: {
+					type: "date",
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					required: true,
+					fieldName: options.user?.fields?.updatedAt || "updatedAt"
+				},
+				...user?.fields,
+				...options.user?.additionalFields
+			},
+			order: 1
+		},
+		...!options.secondaryStorage || options.session?.storeSessionInDatabase ? sessionTable : {},
+		account: {
+			modelName: options.account?.modelName || "account",
+			fields: {
+				accountId: {
+					type: "string",
+					required: true,
+					fieldName: options.account?.fields?.accountId || "accountId"
+				},
+				providerId: {
+					type: "string",
+					required: true,
+					fieldName: options.account?.fields?.providerId || "providerId"
+				},
+				userId: {
+					type: "string",
+					references: {
+						model: options.user?.modelName || "user",
+						field: "id",
+						onDelete: "cascade"
+					},
+					required: true,
+					fieldName: options.account?.fields?.userId || "userId",
+					index: true
+				},
+				accessToken: {
+					type: "string",
+					required: false,
+					fieldName: options.account?.fields?.accessToken || "accessToken"
+				},
+				refreshToken: {
+					type: "string",
+					required: false,
+					fieldName: options.account?.fields?.refreshToken || "refreshToken"
+				},
+				idToken: {
+					type: "string",
+					required: false,
+					fieldName: options.account?.fields?.idToken || "idToken"
+				},
+				accessTokenExpiresAt: {
+					type: "date",
+					required: false,
+					fieldName: options.account?.fields?.accessTokenExpiresAt || "accessTokenExpiresAt"
+				},
+				refreshTokenExpiresAt: {
+					type: "date",
+					required: false,
+					fieldName: options.account?.fields?.refreshTokenExpiresAt || "refreshTokenExpiresAt"
+				},
+				scope: {
+					type: "string",
+					required: false,
+					fieldName: options.account?.fields?.scope || "scope"
+				},
+				password: {
+					type: "string",
+					required: false,
+					fieldName: options.account?.fields?.password || "password"
+				},
+				createdAt: {
+					type: "date",
+					required: true,
+					fieldName: options.account?.fields?.createdAt || "createdAt",
+					defaultValue: () => /* @__PURE__ */ new Date()
+				},
+				updatedAt: {
+					type: "date",
+					required: true,
+					fieldName: options.account?.fields?.updatedAt || "updatedAt",
+					onUpdate: () => /* @__PURE__ */ new Date()
+				},
+				...account?.fields,
+				...options.account?.additionalFields
+			},
+			order: 3
+		},
+		verification: {
+			modelName: options.verification?.modelName || "verification",
+			fields: {
+				identifier: {
+					type: "string",
+					required: true,
+					fieldName: options.verification?.fields?.identifier || "identifier",
+					index: true
+				},
+				value: {
+					type: "string",
+					required: true,
+					fieldName: options.verification?.fields?.value || "value"
+				},
+				expiresAt: {
+					type: "date",
+					required: true,
+					fieldName: options.verification?.fields?.expiresAt || "expiresAt"
+				},
+				createdAt: {
+					type: "date",
+					required: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					fieldName: options.verification?.fields?.createdAt || "createdAt"
+				},
+				updatedAt: {
+					type: "date",
+					required: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					fieldName: options.verification?.fields?.updatedAt || "updatedAt"
+				}
+			},
+			order: 4
+		},
+		...pluginTables,
+		...shouldAddRateLimitTable ? rateLimitTable : {}
+	};
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@better-auth+core@1.4.7+96c18005d8555383/node_modules/@better-auth/core/dist/env-DbssmzoK.mjs
+const _envShim = Object.create(null);
+const _getEnv = (useShim) => globalThis.process?.env || globalThis.Deno?.env.toObject() || globalThis.__env__ || (useShim ? _envShim : globalThis);
+const env = new Proxy(_envShim, {
+	get(_, prop) {
+		return _getEnv()[prop] ?? _envShim[prop];
+	},
+	has(_, prop) {
+		return prop in _getEnv() || prop in _envShim;
+	},
+	set(_, prop, value) {
+		const env$1 = _getEnv(true);
+		env$1[prop] = value;
+		return true;
+	},
+	deleteProperty(_, prop) {
+		if (!prop) return false;
+		const env$1 = _getEnv(true);
+		delete env$1[prop];
+		return true;
+	},
+	ownKeys() {
+		const env$1 = _getEnv(true);
+		return Object.keys(env$1);
+	}
+});
+function toBoolean(val) {
+	return val ? val !== "false" : false;
+}
+const nodeENV = typeof process !== "undefined" && process.env && process.env.NODE_ENV || "";
+/** Detect if `NODE_ENV` environment variable is `production` */
+const isProduction = nodeENV === "production";
+/** Detect if `NODE_ENV` environment variable is `dev` or `development` */
+const isDevelopment = () => nodeENV === "dev" || nodeENV === "development";
+/** Detect if `NODE_ENV` environment variable is `test` */
+const isTest = () => nodeENV === "test" || toBoolean(env.TEST);
+/**
+* Get environment variable with fallback
+*/
+function getEnvVar(key, fallback) {
+	if (typeof process !== "undefined" && process.env) return process.env[key] ?? fallback;
+	if (typeof Deno !== "undefined") return Deno.env.get(key) ?? fallback;
+	if (typeof Bun !== "undefined") return Bun.env[key] ?? fallback;
+	return fallback;
+}
+/**
+* Get boolean environment variable
+*/
+function getBooleanEnvVar(key, fallback = true) {
+	const value = getEnvVar(key);
+	if (!value) return fallback;
+	return value !== "0" && value.toLowerCase() !== "false" && value !== "";
+}
+/**
+* Common environment variables used in Better Auth
+*/
+const ENV = Object.freeze({
+	get BETTER_AUTH_SECRET() {
+		return getEnvVar("BETTER_AUTH_SECRET");
+	},
+	get AUTH_SECRET() {
+		return getEnvVar("AUTH_SECRET");
+	},
+	get BETTER_AUTH_TELEMETRY() {
+		return getEnvVar("BETTER_AUTH_TELEMETRY");
+	},
+	get BETTER_AUTH_TELEMETRY_ID() {
+		return getEnvVar("BETTER_AUTH_TELEMETRY_ID");
+	},
+	get NODE_ENV() {
+		return getEnvVar("NODE_ENV", "development");
+	},
+	get PACKAGE_VERSION() {
+		return getEnvVar("PACKAGE_VERSION", "0.0.0");
+	},
+	get BETTER_AUTH_TELEMETRY_ENDPOINT() {
+		return getEnvVar("BETTER_AUTH_TELEMETRY_ENDPOINT", "https://telemetry.better-auth.com/v1/track");
+	}
+});
+const COLORS_2 = 1;
+const COLORS_16 = 4;
+const COLORS_256 = 8;
+const COLORS_16m = 24;
+const TERM_ENVS = {
+	eterm: COLORS_16,
+	cons25: COLORS_16,
+	console: COLORS_16,
+	cygwin: COLORS_16,
+	dtterm: COLORS_16,
+	gnome: COLORS_16,
+	hurd: COLORS_16,
+	jfbterm: COLORS_16,
+	konsole: COLORS_16,
+	kterm: COLORS_16,
+	mlterm: COLORS_16,
+	mosh: COLORS_16m,
+	putty: COLORS_16,
+	st: COLORS_16,
+	"rxvt-unicode-24bit": COLORS_16m,
+	terminator: COLORS_16m,
+	"xterm-kitty": COLORS_16m
+};
+const CI_ENVS_MAP = new Map(Object.entries({
+	APPVEYOR: COLORS_256,
+	BUILDKITE: COLORS_256,
+	CIRCLECI: COLORS_16m,
+	DRONE: COLORS_256,
+	GITEA_ACTIONS: COLORS_16m,
+	GITHUB_ACTIONS: COLORS_16m,
+	GITLAB_CI: COLORS_256,
+	TRAVIS: COLORS_256
+}));
+const TERM_ENVS_REG_EXP = [
+	/ansi/,
+	/color/,
+	/linux/,
+	/direct/,
+	/^con[0-9]*x[0-9]/,
+	/^rxvt/,
+	/^screen/,
+	/^xterm/,
+	/^vt100/,
+	/^vt220/
+];
+function getColorDepth() {
+	if (getEnvVar("FORCE_COLOR") !== void 0) switch (getEnvVar("FORCE_COLOR")) {
+		case "":
+		case "1":
+		case "true": return COLORS_16;
+		case "2": return COLORS_256;
+		case "3": return COLORS_16m;
+		default: return COLORS_2;
+	}
+	if (getEnvVar("NODE_DISABLE_COLORS") !== void 0 && getEnvVar("NODE_DISABLE_COLORS") !== "" || getEnvVar("NO_COLOR") !== void 0 && getEnvVar("NO_COLOR") !== "" || getEnvVar("TERM") === "dumb") return COLORS_2;
+	if (getEnvVar("TMUX")) return COLORS_16m;
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return COLORS_16;
+	if ("CI" in env) {
+		for (const { 0: envName, 1: colors } of CI_ENVS_MAP) if (envName in env) return colors;
+		if (getEnvVar("CI_NAME") === "codeship") return COLORS_256;
+		return COLORS_2;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.exec(getEnvVar("TEAMCITY_VERSION")) !== null ? COLORS_16 : COLORS_2;
+	switch (getEnvVar("TERM_PROGRAM")) {
+		case "iTerm.app":
+			if (!getEnvVar("TERM_PROGRAM_VERSION") || /^[0-2]\./.exec(getEnvVar("TERM_PROGRAM_VERSION")) !== null) return COLORS_256;
+			return COLORS_16m;
+		case "HyperTerm":
+		case "MacTerm": return COLORS_16m;
+		case "Apple_Terminal": return COLORS_256;
+	}
+	if (getEnvVar("COLORTERM") === "truecolor" || getEnvVar("COLORTERM") === "24bit") return COLORS_16m;
+	if (getEnvVar("TERM")) {
+		if (/truecolor/.exec(getEnvVar("TERM")) !== null) return COLORS_16m;
+		if (/^xterm-256/.exec(getEnvVar("TERM")) !== null) return COLORS_256;
+		const termEnv = getEnvVar("TERM").toLowerCase();
+		if (TERM_ENVS[termEnv]) return TERM_ENVS[termEnv];
+		if (TERM_ENVS_REG_EXP.some((term) => term.exec(termEnv) !== null)) return COLORS_16;
+	}
+	if (getEnvVar("COLORTERM")) return COLORS_16;
+	return COLORS_2;
+}
+const TTY_COLORS = {
+	reset: "\x1B[0m",
+	bright: "\x1B[1m",
+	dim: "\x1B[2m",
+	undim: "\x1B[22m",
+	underscore: "\x1B[4m",
+	blink: "\x1B[5m",
+	reverse: "\x1B[7m",
+	hidden: "\x1B[8m",
+	fg: {
+		black: "\x1B[30m",
+		red: "\x1B[31m",
+		green: "\x1B[32m",
+		yellow: "\x1B[33m",
+		blue: "\x1B[34m",
+		magenta: "\x1B[35m",
+		cyan: "\x1B[36m",
+		white: "\x1B[37m"
+	},
+	bg: {
+		black: "\x1B[40m",
+		red: "\x1B[41m",
+		green: "\x1B[42m",
+		yellow: "\x1B[43m",
+		blue: "\x1B[44m",
+		magenta: "\x1B[45m",
+		cyan: "\x1B[46m",
+		white: "\x1B[47m"
+	}
+};
+const levels = [
+	"debug",
+	"info",
+	"success",
+	"warn",
+	"error"
+];
+function shouldPublishLog(currentLogLevel, logLevel) {
+	return levels.indexOf(logLevel) >= levels.indexOf(currentLogLevel);
+}
+const levelColors = {
+	info: TTY_COLORS.fg.blue,
+	success: TTY_COLORS.fg.green,
+	warn: TTY_COLORS.fg.yellow,
+	error: TTY_COLORS.fg.red,
+	debug: TTY_COLORS.fg.magenta
+};
+const formatMessage = (level, message, colorsEnabled) => {
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	if (colorsEnabled) return `${TTY_COLORS.dim}${timestamp}${TTY_COLORS.reset} ${levelColors[level]}${level.toUpperCase()}${TTY_COLORS.reset} ${TTY_COLORS.bright}[Better Auth]:${TTY_COLORS.reset} ${message}`;
+	return `${timestamp} ${level.toUpperCase()} [Better Auth]: ${message}`;
+};
+const createLogger = (options) => {
+	const enabled = options?.disabled !== true;
+	const logLevel = options?.level ?? "error";
+	const colorsEnabled = options?.disableColors !== void 0 ? !options.disableColors : getColorDepth() !== 1;
+	const LogFunc = (level, message, args = []) => {
+		if (!enabled || !shouldPublishLog(logLevel, level)) return;
+		const formattedMessage = formatMessage(level, message, colorsEnabled);
+		if (!options || typeof options.log !== "function") {
+			if (level === "error") console.error(formattedMessage, ...args);
+			else if (level === "warn") console.warn(formattedMessage, ...args);
+			else console.log(formattedMessage, ...args);
+			return;
+		}
+		options.log(level === "success" ? "info" : level, message, ...args);
+	};
+	return {
+		...Object.fromEntries(levels.map((level) => [level, (...[message, ...args]) => LogFunc(level, message, args)])),
+		get level() {
+			return logLevel;
+		}
+	};
+};
+const logger = createLogger();
+
+//#endregion
+//#region ../../node_modules/.bun/@better-auth+utils@0.3.0/node_modules/@better-auth/utils/dist/random.mjs
+function expandAlphabet(alphabet) {
+	switch (alphabet) {
+		case "a-z": return "abcdefghijklmnopqrstuvwxyz";
+		case "A-Z": return "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+		case "0-9": return "0123456789";
+		case "-_": return "-_";
+		default: throw new Error(`Unsupported alphabet: ${alphabet}`);
+	}
+}
+function createRandomStringGenerator(...baseAlphabets) {
+	const baseCharSet = baseAlphabets.map(expandAlphabet).join("");
+	if (baseCharSet.length === 0) throw new Error("No valid characters provided for random string generation.");
+	const baseCharSetLength = baseCharSet.length;
+	return (length, ...alphabets) => {
+		if (length <= 0) throw new Error("Length must be a positive integer.");
+		let charSet = baseCharSet;
+		let charSetLength = baseCharSetLength;
+		if (alphabets.length > 0) {
+			charSet = alphabets.map(expandAlphabet).join("");
+			charSetLength = charSet.length;
+		}
+		const maxValid = Math.floor(256 / charSetLength) * charSetLength;
+		const buf = new Uint8Array(length * 2);
+		const bufLength = buf.length;
+		let result = "";
+		let bufIndex = bufLength;
+		let rand;
+		while (result.length < length) {
+			if (bufIndex >= bufLength) {
+				crypto.getRandomValues(buf);
+				bufIndex = 0;
+			}
+			rand = buf[bufIndex++];
+			if (rand < maxValid) result += charSet[rand % charSetLength];
+		}
+		return result;
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@better-auth+core@1.4.7+96c18005d8555383/node_modules/@better-auth/core/dist/utils-NloIXYE0.mjs
+function defineErrorCodes(codes) {
+	return codes;
+}
+const generateId = (size) => {
+	return createRandomStringGenerator("a-z", "A-Z", "0-9")(size || 32);
+};
+function safeJSONParse(data) {
+	function reviver(_, value) {
+		if (typeof value === "string") {
+			if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/.test(value)) {
+				const date = new Date(value);
+				if (!isNaN(date.getTime())) return date;
+			}
+		}
+		return value;
+	}
+	try {
+		if (typeof data !== "string") return data;
+		return JSON.parse(data, reviver);
+	} catch (e) {
+		logger.error("Error parsing JSON", { error: e });
+		return null;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@better-auth+core@1.4.7+96c18005d8555383/node_modules/@better-auth/core/dist/error-CzMAIrPb.mjs
+const BASE_ERROR_CODES = defineErrorCodes({
+	USER_NOT_FOUND: "User not found",
+	FAILED_TO_CREATE_USER: "Failed to create user",
+	FAILED_TO_CREATE_SESSION: "Failed to create session",
+	FAILED_TO_UPDATE_USER: "Failed to update user",
+	FAILED_TO_GET_SESSION: "Failed to get session",
+	INVALID_PASSWORD: "Invalid password",
+	INVALID_EMAIL: "Invalid email",
+	INVALID_EMAIL_OR_PASSWORD: "Invalid email or password",
+	SOCIAL_ACCOUNT_ALREADY_LINKED: "Social account already linked",
+	PROVIDER_NOT_FOUND: "Provider not found",
+	INVALID_TOKEN: "Invalid token",
+	ID_TOKEN_NOT_SUPPORTED: "id_token not supported",
+	FAILED_TO_GET_USER_INFO: "Failed to get user info",
+	USER_EMAIL_NOT_FOUND: "User email not found",
+	EMAIL_NOT_VERIFIED: "Email not verified",
+	PASSWORD_TOO_SHORT: "Password too short",
+	PASSWORD_TOO_LONG: "Password too long",
+	USER_ALREADY_EXISTS: "User already exists.",
+	USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.",
+	EMAIL_CAN_NOT_BE_UPDATED: "Email can not be updated",
+	CREDENTIAL_ACCOUNT_NOT_FOUND: "Credential account not found",
+	SESSION_EXPIRED: "Session expired. Re-authenticate to perform this action.",
+	FAILED_TO_UNLINK_LAST_ACCOUNT: "You can't unlink your last account",
+	ACCOUNT_NOT_FOUND: "Account not found",
+	USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account."
+});
+var BetterAuthError = class extends Error {
+	constructor(message, cause) {
+		super(message);
+		this.name = "BetterAuthError";
+		this.message = message;
+		this.cause = cause;
+		this.stack = "";
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@better-auth+core@1.4.7+96c18005d8555383/node_modules/@better-auth/core/dist/db/adapter/index.mjs
+const initGetDefaultModelName = ({ usePlural, schema }) => {
+	/**
+	* This function helps us get the default model name from the schema defined by devs.
+	* Often times, the user will be using the `modelName` which could had been customized by the users.
+	* This function helps us get the actual model name useful to match against the schema. (eg: schema[model])
+	*
+	* If it's still unclear what this does:
+	*
+	* 1. User can define a custom modelName.
+	* 2. When using a custom modelName, doing something like `schema[model]` will not work.
+	* 3. Using this function helps us get the actual model name based on the user's defined custom modelName.
+	*/
+	const getDefaultModelName = (model) => {
+		if (usePlural && model.charAt(model.length - 1) === "s") {
+			let pluralessModel = model.slice(0, -1);
+			let m$1 = schema[pluralessModel] ? pluralessModel : void 0;
+			if (!m$1) m$1 = Object.entries(schema).find(([_, f]) => f.modelName === pluralessModel)?.[0];
+			if (m$1) return m$1;
+		}
+		let m = schema[model] ? model : void 0;
+		if (!m) m = Object.entries(schema).find(([_, f]) => f.modelName === model)?.[0];
+		if (!m) throw new BetterAuthError(`Model "${model}" not found in schema`);
+		return m;
+	};
+	return getDefaultModelName;
+};
+const initGetDefaultFieldName = ({ schema, usePlural }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		schema,
+		usePlural
+	});
+	/**
+	* This function helps us get the default field name from the schema defined by devs.
+	* Often times, the user will be using the `fieldName` which could had been customized by the users.
+	* This function helps us get the actual field name useful to match against the schema. (eg: schema[model].fields[field])
+	*
+	* If it's still unclear what this does:
+	*
+	* 1. User can define a custom fieldName.
+	* 2. When using a custom fieldName, doing something like `schema[model].fields[field]` will not work.
+	*/
+	const getDefaultFieldName = ({ field, model: unsafeModel }) => {
+		if (field === "id" || field === "_id") return "id";
+		const model = getDefaultModelName(unsafeModel);
+		let f = schema[model]?.fields[field];
+		if (!f) {
+			const result = Object.entries(schema[model].fields).find(([_, f$1]) => f$1.fieldName === field);
+			if (result) {
+				f = result[1];
+				field = result[0];
+			}
+		}
+		if (!f) throw new BetterAuthError(`Field ${field} not found in model ${model}`);
+		return field;
+	};
+	return getDefaultFieldName;
+};
+const initGetIdField = ({ usePlural, schema, disableIdGeneration, options, customIdGenerator, supportsUUIDs }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		usePlural,
+		schema
+	});
+	const idField = ({ customModelName, forceAllowId }) => {
+		const useNumberId = options.advanced?.database?.useNumberId || options.advanced?.database?.generateId === "serial";
+		const useUUIDs = options.advanced?.database?.generateId === "uuid";
+		let shouldGenerateId = (() => {
+			if (disableIdGeneration) return false;
+			else if (useNumberId && !forceAllowId) return false;
+			else if (useUUIDs) return !supportsUUIDs;
+			else return true;
+		})();
+		const model = getDefaultModelName(customModelName ?? "id");
+		return {
+			type: useNumberId ? "number" : "string",
+			required: shouldGenerateId ? true : false,
+			...shouldGenerateId ? { defaultValue() {
+				if (disableIdGeneration) return void 0;
+				let generateId$1 = options.advanced?.database?.generateId;
+				if (generateId$1 === false || useNumberId) return void 0;
+				if (typeof generateId$1 === "function") return generateId$1({ model });
+				if (customIdGenerator) return customIdGenerator({ model });
+				if (generateId$1 === "uuid") return crypto.randomUUID();
+				return generateId();
+			} } : {},
+			transform: {
+				input: (value) => {
+					if (!value) return void 0;
+					if (useNumberId) {
+						const numberValue = Number(value);
+						if (isNaN(numberValue)) return;
+						return numberValue;
+					}
+					if (useUUIDs) {
+						if (shouldGenerateId && !forceAllowId) return value;
+						if (disableIdGeneration) return void 0;
+						if (supportsUUIDs) return void 0;
+						if (forceAllowId && typeof value === "string") if (/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) return value;
+						else {
+							const stack = (/* @__PURE__ */ new Error()).stack?.split("\n").filter((_, i) => i !== 1).join("\n").replace("Error:", "");
+							logger.warn("[Adapter Factory] - Invalid UUID value for field `id` provided when `forceAllowId` is true. Generating a new UUID.", stack);
+						}
+						if (typeof value !== "string" && !supportsUUIDs) return crypto.randomUUID();
+						return;
+					}
+					return value;
+				},
+				output: (value) => {
+					if (!value) return void 0;
+					return String(value);
+				}
+			}
+		};
+	};
+	return idField;
+};
+const initGetFieldAttributes = ({ usePlural, schema, options, customIdGenerator, disableIdGeneration }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		usePlural,
+		schema
+	});
+	const getDefaultFieldName = initGetDefaultFieldName({
+		usePlural,
+		schema
+	});
+	const idField = initGetIdField({
+		usePlural,
+		schema,
+		options,
+		customIdGenerator,
+		disableIdGeneration
+	});
+	const getFieldAttributes = ({ model, field }) => {
+		const defaultModelName = getDefaultModelName(model);
+		const defaultFieldName = getDefaultFieldName({
+			field,
+			model: defaultModelName
+		});
+		const fields = schema[defaultModelName].fields;
+		fields.id = idField({ customModelName: defaultModelName });
+		const fieldAttributes = fields[defaultFieldName];
+		if (!fieldAttributes) throw new BetterAuthError(`Field ${field} not found in model ${model}`);
+		return fieldAttributes;
+	};
+	return getFieldAttributes;
+};
+const initGetFieldName = ({ schema, usePlural }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		schema,
+		usePlural
+	});
+	const getDefaultFieldName = initGetDefaultFieldName({
+		schema,
+		usePlural
+	});
+	/**
+	* Get the field name which is expected to be saved in the database based on the user's schema.
+	*
+	* This function is useful if you need to save the field name to the database.
+	*
+	* For example, if the user has defined a custom field name for the `user` model, then you can use this function to get the actual field name from the schema.
+	*/
+	function getFieldName({ model: modelName, field: fieldName }) {
+		const model = getDefaultModelName(modelName);
+		const field = getDefaultFieldName({
+			model,
+			field: fieldName
+		});
+		return schema[model]?.fields[field]?.fieldName || field;
+	}
+	return getFieldName;
+};
+const initGetModelName = ({ usePlural, schema }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		schema,
+		usePlural
+	});
+	/**
+	* Users can overwrite the default model of some tables. This function helps find the correct model name.
+	* Furthermore, if the user passes `usePlural` as true in their adapter config,
+	* then we should return the model name ending with an `s`.
+	*/
+	const getModelName = (model) => {
+		const defaultModelKey = getDefaultModelName(model);
+		if (schema && schema[defaultModelKey] && schema[defaultModelKey].modelName !== model) return usePlural ? `${schema[defaultModelKey].modelName}s` : schema[defaultModelKey].modelName;
+		return usePlural ? `${model}s` : model;
+	};
+	return getModelName;
+};
+function withApplyDefault(value, field, action) {
+	if (action === "update") {
+		if (value === void 0 && field.onUpdate !== void 0) {
+			if (typeof field.onUpdate === "function") return field.onUpdate();
+			return field.onUpdate;
+		}
+		return value;
+	}
+	if (action === "create") {
+		if (value === void 0 || field.required === true && value === null) {
+			if (field.defaultValue !== void 0) {
+				if (typeof field.defaultValue === "function") return field.defaultValue();
+				return field.defaultValue;
+			}
+		}
+	}
+	return value;
+}
+let debugLogs = [];
+let transactionId = -1;
+const createAsIsTransaction = (adapter) => (fn) => fn(adapter);
+const createAdapterFactory = ({ adapter: customAdapter, config: cfg }) => (options) => {
+	const uniqueAdapterFactoryInstanceId = Math.random().toString(36).substring(2, 15);
+	const config = {
+		...cfg,
+		supportsBooleans: cfg.supportsBooleans ?? true,
+		supportsDates: cfg.supportsDates ?? true,
+		supportsJSON: cfg.supportsJSON ?? false,
+		adapterName: cfg.adapterName ?? cfg.adapterId,
+		supportsNumericIds: cfg.supportsNumericIds ?? true,
+		supportsUUIDs: cfg.supportsUUIDs ?? false,
+		supportsArrays: cfg.supportsArrays ?? false,
+		transaction: cfg.transaction ?? false,
+		disableTransformInput: cfg.disableTransformInput ?? false,
+		disableTransformOutput: cfg.disableTransformOutput ?? false,
+		disableTransformJoin: cfg.disableTransformJoin ?? false
+	};
+	if ((options.advanced?.database?.useNumberId === true || options.advanced?.database?.generateId === "serial") && config.supportsNumericIds === false) throw new BetterAuthError(`[${config.adapterName}] Your database or database adapter does not support numeric ids. Please disable "useNumberId" in your config.`);
+	const schema = getAuthTables(options);
+	const debugLog = (...args) => {
+		if (config.debugLogs === true || typeof config.debugLogs === "object") {
+			const logger$2 = createLogger({ level: "info" });
+			if (typeof config.debugLogs === "object" && "isRunningAdapterTests" in config.debugLogs) {
+				if (config.debugLogs.isRunningAdapterTests) {
+					args.shift();
+					debugLogs.push({
+						instance: uniqueAdapterFactoryInstanceId,
+						args
+					});
+				}
+				return;
+			}
+			if (typeof config.debugLogs === "object" && config.debugLogs.logCondition && !config.debugLogs.logCondition?.()) return;
+			if (typeof args[0] === "object" && "method" in args[0]) {
+				const method = args.shift().method;
+				if (typeof config.debugLogs === "object") {
+					if (method === "create" && !config.debugLogs.create) return;
+					else if (method === "update" && !config.debugLogs.update) return;
+					else if (method === "updateMany" && !config.debugLogs.updateMany) return;
+					else if (method === "findOne" && !config.debugLogs.findOne) return;
+					else if (method === "findMany" && !config.debugLogs.findMany) return;
+					else if (method === "delete" && !config.debugLogs.delete) return;
+					else if (method === "deleteMany" && !config.debugLogs.deleteMany) return;
+					else if (method === "count" && !config.debugLogs.count) return;
+				}
+				logger$2.info(`[${config.adapterName}]`, ...args);
+			} else logger$2.info(`[${config.adapterName}]`, ...args);
+		}
+	};
+	const logger$1 = createLogger(options.logger);
+	const getDefaultModelName = initGetDefaultModelName({
+		usePlural: config.usePlural,
+		schema
+	});
+	const getDefaultFieldName = initGetDefaultFieldName({
+		usePlural: config.usePlural,
+		schema
+	});
+	const getModelName = initGetModelName({
+		usePlural: config.usePlural,
+		schema
+	});
+	const getFieldName = initGetFieldName({
+		schema,
+		usePlural: config.usePlural
+	});
+	const idField = initGetIdField({
+		schema,
+		options,
+		usePlural: config.usePlural,
+		disableIdGeneration: config.disableIdGeneration,
+		customIdGenerator: config.customIdGenerator,
+		supportsUUIDs: config.supportsUUIDs
+	});
+	const getFieldAttributes = initGetFieldAttributes({
+		schema,
+		options,
+		usePlural: config.usePlural,
+		disableIdGeneration: config.disableIdGeneration,
+		customIdGenerator: config.customIdGenerator
+	});
+	const transformInput = async (data, defaultModelName, action, forceAllowId) => {
+		const transformedData = {};
+		const fields = schema[defaultModelName].fields;
+		const newMappedKeys = config.mapKeysTransformInput ?? {};
+		const useNumberId = options.advanced?.database?.useNumberId || options.advanced?.database?.generateId === "serial";
+		fields.id = idField({
+			customModelName: defaultModelName,
+			forceAllowId: forceAllowId && "id" in data
+		});
+		for (const field in fields) {
+			let value = data[field];
+			const fieldAttributes = fields[field];
+			let newFieldName = newMappedKeys[field] || fields[field].fieldName || field;
+			if (value === void 0 && (fieldAttributes.defaultValue === void 0 && !fieldAttributes.transform?.input && !(action === "update" && fieldAttributes.onUpdate) || action === "update" && !fieldAttributes.onUpdate)) continue;
+			if (fieldAttributes && fieldAttributes.type === "date" && !(value instanceof Date) && typeof value === "string") try {
+				value = new Date(value);
+			} catch {
+				logger$1.error("[Adapter Factory] Failed to convert string to date", {
+					value,
+					field
+				});
+			}
+			let newValue = withApplyDefault(value, fieldAttributes, action);
+			if (fieldAttributes.transform?.input) newValue = await fieldAttributes.transform.input(newValue);
+			if (fieldAttributes.references?.field === "id" && useNumberId) if (Array.isArray(newValue)) newValue = newValue.map((x) => x !== null ? Number(x) : null);
+			else newValue = newValue !== null ? Number(newValue) : null;
+			else if (config.supportsJSON === false && typeof newValue === "object" && fieldAttributes.type === "json") newValue = JSON.stringify(newValue);
+			else if (config.supportsArrays === false && Array.isArray(newValue) && (fieldAttributes.type === "string[]" || fieldAttributes.type === "number[]")) newValue = JSON.stringify(newValue);
+			else if (config.supportsDates === false && newValue instanceof Date && fieldAttributes.type === "date") newValue = newValue.toISOString();
+			else if (config.supportsBooleans === false && typeof newValue === "boolean") newValue = newValue ? 1 : 0;
+			if (config.customTransformInput) newValue = config.customTransformInput({
+				data: newValue,
+				action,
+				field: newFieldName,
+				fieldAttributes,
+				model: getModelName(defaultModelName),
+				schema,
+				options
+			});
+			if (newValue !== void 0) transformedData[newFieldName] = newValue;
+		}
+		return transformedData;
+	};
+	const transformOutput = async (data, unsafe_model, select = [], join) => {
+		const transformSingleOutput = async (data$1, unsafe_model$1, select$1 = []) => {
+			if (!data$1) return null;
+			const newMappedKeys = config.mapKeysTransformOutput ?? {};
+			const transformedData$1 = {};
+			const tableSchema = schema[getDefaultModelName(unsafe_model$1)].fields;
+			const idKey = Object.entries(newMappedKeys).find(([_, v]) => v === "id")?.[0];
+			tableSchema[idKey ?? "id"] = { type: options.advanced?.database?.useNumberId || options.advanced?.database?.generateId === "serial" ? "number" : "string" };
+			for (const key in tableSchema) {
+				if (select$1.length && !select$1.includes(key)) continue;
+				const field = tableSchema[key];
+				if (field) {
+					const originalKey = field.fieldName || key;
+					let newValue = data$1[Object.entries(newMappedKeys).find(([_, v]) => v === originalKey)?.[0] || originalKey];
+					if (field.transform?.output) newValue = await field.transform.output(newValue);
+					let newFieldName = newMappedKeys[key] || key;
+					if (originalKey === "id" || field.references?.field === "id") {
+						if (typeof newValue !== "undefined" && newValue !== null) newValue = String(newValue);
+					} else if (config.supportsJSON === false && typeof newValue === "string" && field.type === "json") newValue = safeJSONParse(newValue);
+					else if (config.supportsArrays === false && typeof newValue === "string" && (field.type === "string[]" || field.type === "number[]")) newValue = safeJSONParse(newValue);
+					else if (config.supportsDates === false && typeof newValue === "string" && field.type === "date") newValue = new Date(newValue);
+					else if (config.supportsBooleans === false && typeof newValue === "number" && field.type === "boolean") newValue = newValue === 1;
+					if (config.customTransformOutput) newValue = config.customTransformOutput({
+						data: newValue,
+						field: newFieldName,
+						fieldAttributes: field,
+						select: select$1,
+						model: getModelName(unsafe_model$1),
+						schema,
+						options
+					});
+					transformedData$1[newFieldName] = newValue;
+				}
+			}
+			return transformedData$1;
+		};
+		if (!join || Object.keys(join).length === 0) return await transformSingleOutput(data, unsafe_model, select);
+		unsafe_model = getDefaultModelName(unsafe_model);
+		let transformedData = await transformSingleOutput(data, unsafe_model, select);
+		const requiredModels = Object.entries(join).map(([model, joinConfig]) => ({
+			modelName: getModelName(model),
+			defaultModelName: getDefaultModelName(model),
+			joinConfig
+		}));
+		if (!data) return null;
+		for (const { modelName, defaultModelName, joinConfig } of requiredModels) {
+			let joinedData = await (async () => {
+				if (options.experimental?.joins) return data[modelName];
+				else return await handleFallbackJoin({
+					baseModel: unsafe_model,
+					baseData: transformedData,
+					joinModel: modelName,
+					specificJoinConfig: joinConfig
+				});
+			})();
+			if (joinedData === void 0 || joinedData === null) joinedData = joinConfig.relation === "one-to-one" ? null : [];
+			if (joinConfig.relation === "one-to-many" && !Array.isArray(joinedData)) joinedData = [joinedData];
+			let transformed = [];
+			if (Array.isArray(joinedData)) for (const item of joinedData) {
+				const transformedItem = await transformSingleOutput(item, modelName, []);
+				transformed.push(transformedItem);
+			}
+			else {
+				const transformedItem = await transformSingleOutput(joinedData, modelName, []);
+				transformed.push(transformedItem);
+			}
+			transformedData[defaultModelName] = (joinConfig.relation === "one-to-one" ? transformed[0] : transformed) ?? null;
+		}
+		return transformedData;
+	};
+	const transformWhereClause = ({ model, where }) => {
+		if (!where) return void 0;
+		const newMappedKeys = config.mapKeysTransformInput ?? {};
+		return where.map((w) => {
+			const { field: unsafe_field, value, operator = "eq", connector = "AND" } = w;
+			if (operator === "in") {
+				if (!Array.isArray(value)) throw new BetterAuthError("Value must be an array");
+			}
+			let newValue = value;
+			const defaultModelName = getDefaultModelName(model);
+			const defaultFieldName = getDefaultFieldName({
+				field: unsafe_field,
+				model
+			});
+			const fieldName = newMappedKeys[defaultFieldName] || getFieldName({
+				field: defaultFieldName,
+				model: defaultModelName
+			});
+			const fieldAttr = getFieldAttributes({
+				field: defaultFieldName,
+				model: defaultModelName
+			});
+			const useNumberId = options.advanced?.database?.useNumberId || options.advanced?.database?.generateId === "serial";
+			if (defaultFieldName === "id" || fieldAttr.references?.field === "id") {
+				if (useNumberId) if (Array.isArray(value)) newValue = value.map(Number);
+				else newValue = Number(value);
+			}
+			if (fieldAttr.type === "date" && value instanceof Date && !config.supportsDates) newValue = value.toISOString();
+			if (fieldAttr.type === "boolean" && typeof value === "boolean" && !config.supportsBooleans) newValue = value ? 1 : 0;
+			if (fieldAttr.type === "json" && typeof value === "object" && !config.supportsJSON) try {
+				newValue = JSON.stringify(value);
+			} catch (error) {
+				throw new Error(`Failed to stringify JSON value for field ${fieldName}`, { cause: error });
+			}
+			return {
+				operator,
+				connector,
+				field: fieldName,
+				value: newValue
+			};
+		});
+	};
+	const transformJoinClause = (baseModel, unsanitizedJoin, select) => {
+		if (!unsanitizedJoin) return void 0;
+		if (Object.keys(unsanitizedJoin).length === 0) return void 0;
+		const transformedJoin = {};
+		for (const [model, join] of Object.entries(unsanitizedJoin)) {
+			if (!join) continue;
+			const defaultModelName = getDefaultModelName(model);
+			const defaultBaseModelName = getDefaultModelName(baseModel);
+			let foreignKeys = Object.entries(schema[defaultModelName].fields).filter(([field, fieldAttributes]) => fieldAttributes.references && getDefaultModelName(fieldAttributes.references.model) === defaultBaseModelName);
+			let isForwardJoin = true;
+			if (!foreignKeys.length) {
+				foreignKeys = Object.entries(schema[defaultBaseModelName].fields).filter(([field, fieldAttributes]) => fieldAttributes.references && getDefaultModelName(fieldAttributes.references.model) === defaultModelName);
+				isForwardJoin = false;
+			}
+			if (!foreignKeys.length) throw new BetterAuthError(`No foreign key found for model ${model} and base model ${baseModel} while performing join operation.`);
+			else if (foreignKeys.length > 1) throw new BetterAuthError(`Multiple foreign keys found for model ${model} and base model ${baseModel} while performing join operation. Only one foreign key is supported.`);
+			const [foreignKey, foreignKeyAttributes] = foreignKeys[0];
+			if (!foreignKeyAttributes.references) throw new BetterAuthError(`No references found for foreign key ${foreignKey} on model ${model} while performing join operation.`);
+			let from;
+			let to;
+			let requiredSelectField;
+			if (isForwardJoin) {
+				requiredSelectField = foreignKeyAttributes.references.field;
+				from = getFieldName({
+					model: baseModel,
+					field: requiredSelectField
+				});
+				to = getFieldName({
+					model,
+					field: foreignKey
+				});
+			} else {
+				requiredSelectField = foreignKey;
+				from = getFieldName({
+					model: baseModel,
+					field: requiredSelectField
+				});
+				to = getFieldName({
+					model,
+					field: foreignKeyAttributes.references.field
+				});
+			}
+			if (select && !select.includes(requiredSelectField)) select.push(requiredSelectField);
+			const isUnique = to === "id" ? true : foreignKeyAttributes.unique ?? false;
+			let limit = options.advanced?.database?.defaultFindManyLimit ?? 100;
+			if (isUnique) limit = 1;
+			else if (typeof join === "object" && typeof join.limit === "number") limit = join.limit;
+			transformedJoin[getModelName(model)] = {
+				on: {
+					from,
+					to
+				},
+				limit,
+				relation: isUnique ? "one-to-one" : "one-to-many"
+			};
+		}
+		return {
+			join: transformedJoin,
+			select
+		};
+	};
+	/**
+	* Handle joins by making separate queries and combining results (fallback for adapters that don't support native joins).
+	*/
+	const handleFallbackJoin = async ({ baseModel, baseData, joinModel, specificJoinConfig: joinConfig }) => {
+		if (!baseData) return baseData;
+		const modelName = getModelName(joinModel);
+		const field = joinConfig.on.to;
+		const value = baseData[getDefaultFieldName({
+			field: joinConfig.on.from,
+			model: baseModel
+		})];
+		if (value === null || value === void 0) return joinConfig.relation === "one-to-one" ? null : [];
+		let result;
+		const where = transformWhereClause({
+			model: modelName,
+			where: [{
+				field,
+				value,
+				operator: "eq",
+				connector: "AND"
+			}]
+		});
+		try {
+			if (joinConfig.relation === "one-to-one") result = await adapterInstance.findOne({
+				model: modelName,
+				where
+			});
+			else {
+				const limit = joinConfig.limit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+				result = await adapterInstance.findMany({
+					model: modelName,
+					where,
+					limit
+				});
+			}
+		} catch (error) {
+			logger$1.error(`Failed to query fallback join for model ${modelName}:`, {
+				where,
+				limit: joinConfig.limit
+			});
+			console.error(error);
+			throw error;
+		}
+		return result;
+	};
+	const adapterInstance = customAdapter({
+		options,
+		schema,
+		debugLog,
+		getFieldName,
+		getModelName,
+		getDefaultModelName,
+		getDefaultFieldName,
+		getFieldAttributes,
+		transformInput,
+		transformOutput,
+		transformWhereClause
+	});
+	let lazyLoadTransaction = null;
+	const adapter = {
+		transaction: async (cb) => {
+			if (!lazyLoadTransaction) if (!config.transaction) lazyLoadTransaction = createAsIsTransaction(adapter);
+			else {
+				logger$1.debug(`[${config.adapterName}] - Using provided transaction implementation.`);
+				lazyLoadTransaction = config.transaction;
+			}
+			return lazyLoadTransaction(cb);
+		},
+		create: async ({ data: unsafeData, model: unsafeModel, select, forceAllowId = false }) => {
+			transactionId++;
+			let thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			unsafeModel = getDefaultModelName(unsafeModel);
+			if ("id" in unsafeData && typeof unsafeData.id !== "undefined" && !forceAllowId) {
+				logger$1.warn(`[${config.adapterName}] - You are trying to create a record with an id. This is not allowed as we handle id generation for you, unless you pass in the \`forceAllowId\` parameter. The id will be ignored.`);
+				const stack = (/* @__PURE__ */ new Error()).stack?.split("\n").filter((_, i) => i !== 1).join("\n").replace("Error:", "Create method with `id` being called at:");
+				console.log(stack);
+				unsafeData.id = void 0;
+			}
+			debugLog({ method: "create" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 4)}`, `${formatMethod("create")} ${formatAction("Unsafe Input")}:`, {
+				model,
+				data: unsafeData
+			});
+			let data = unsafeData;
+			if (!config.disableTransformInput) data = await transformInput(unsafeData, unsafeModel, "create", forceAllowId);
+			debugLog({ method: "create" }, `${formatTransactionId(thisTransactionId)} ${formatStep(2, 4)}`, `${formatMethod("create")} ${formatAction("Parsed Input")}:`, {
+				model,
+				data
+			});
+			const res = await adapterInstance.create({
+				data,
+				model
+			});
+			debugLog({ method: "create" }, `${formatTransactionId(thisTransactionId)} ${formatStep(3, 4)}`, `${formatMethod("create")} ${formatAction("DB Result")}:`, {
+				model,
+				res
+			});
+			let transformed = res;
+			if (!config.disableTransformOutput) transformed = await transformOutput(res, unsafeModel, select, void 0);
+			debugLog({ method: "create" }, `${formatTransactionId(thisTransactionId)} ${formatStep(4, 4)}`, `${formatMethod("create")} ${formatAction("Parsed Result")}:`, {
+				model,
+				data: transformed
+			});
+			return transformed;
+		},
+		update: async ({ model: unsafeModel, where: unsafeWhere, update: unsafeData }) => {
+			transactionId++;
+			let thisTransactionId = transactionId;
+			unsafeModel = getDefaultModelName(unsafeModel);
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere
+			});
+			debugLog({ method: "update" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 4)}`, `${formatMethod("update")} ${formatAction("Unsafe Input")}:`, {
+				model,
+				data: unsafeData
+			});
+			let data = unsafeData;
+			if (!config.disableTransformInput) data = await transformInput(unsafeData, unsafeModel, "update");
+			debugLog({ method: "update" }, `${formatTransactionId(thisTransactionId)} ${formatStep(2, 4)}`, `${formatMethod("update")} ${formatAction("Parsed Input")}:`, {
+				model,
+				data
+			});
+			const res = await adapterInstance.update({
+				model,
+				where,
+				update: data
+			});
+			debugLog({ method: "update" }, `${formatTransactionId(thisTransactionId)} ${formatStep(3, 4)}`, `${formatMethod("update")} ${formatAction("DB Result")}:`, {
+				model,
+				data: res
+			});
+			let transformed = res;
+			if (!config.disableTransformOutput) transformed = await transformOutput(res, unsafeModel, void 0, void 0);
+			debugLog({ method: "update" }, `${formatTransactionId(thisTransactionId)} ${formatStep(4, 4)}`, `${formatMethod("update")} ${formatAction("Parsed Result")}:`, {
+				model,
+				data: transformed
+			});
+			return transformed;
+		},
+		updateMany: async ({ model: unsafeModel, where: unsafeWhere, update: unsafeData }) => {
+			transactionId++;
+			let thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere
+			});
+			unsafeModel = getDefaultModelName(unsafeModel);
+			debugLog({ method: "updateMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 4)}`, `${formatMethod("updateMany")} ${formatAction("Unsafe Input")}:`, {
+				model,
+				data: unsafeData
+			});
+			let data = unsafeData;
+			if (!config.disableTransformInput) data = await transformInput(unsafeData, unsafeModel, "update");
+			debugLog({ method: "updateMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(2, 4)}`, `${formatMethod("updateMany")} ${formatAction("Parsed Input")}:`, {
+				model,
+				data
+			});
+			const updatedCount = await adapterInstance.updateMany({
+				model,
+				where,
+				update: data
+			});
+			debugLog({ method: "updateMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(3, 4)}`, `${formatMethod("updateMany")} ${formatAction("DB Result")}:`, {
+				model,
+				data: updatedCount
+			});
+			debugLog({ method: "updateMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(4, 4)}`, `${formatMethod("updateMany")} ${formatAction("Parsed Result")}:`, {
+				model,
+				data: updatedCount
+			});
+			return updatedCount;
+		},
+		findOne: async ({ model: unsafeModel, where: unsafeWhere, select, join: unsafeJoin }) => {
+			transactionId++;
+			let thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere
+			});
+			unsafeModel = getDefaultModelName(unsafeModel);
+			let join;
+			let passJoinToAdapter = true;
+			if (!config.disableTransformJoin) {
+				const result = transformJoinClause(unsafeModel, unsafeJoin, select);
+				if (result) {
+					join = result.join;
+					select = result.select;
+				}
+				if (!options.experimental?.joins && join && Object.keys(join).length > 0) passJoinToAdapter = false;
+			} else join = unsafeJoin;
+			debugLog({ method: "findOne" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 3)}`, `${formatMethod("findOne")}:`, {
+				model,
+				where,
+				select,
+				join
+			});
+			const res = await adapterInstance.findOne({
+				model,
+				where,
+				select,
+				join: passJoinToAdapter ? join : void 0
+			});
+			debugLog({ method: "findOne" }, `${formatTransactionId(thisTransactionId)} ${formatStep(2, 3)}`, `${formatMethod("findOne")} ${formatAction("DB Result")}:`, {
+				model,
+				data: res
+			});
+			let transformed = res;
+			if (!config.disableTransformOutput) transformed = await transformOutput(res, unsafeModel, select, join);
+			debugLog({ method: "findOne" }, `${formatTransactionId(thisTransactionId)} ${formatStep(3, 3)}`, `${formatMethod("findOne")} ${formatAction("Parsed Result")}:`, {
+				model,
+				data: transformed
+			});
+			return transformed;
+		},
+		findMany: async ({ model: unsafeModel, where: unsafeWhere, limit: unsafeLimit, sortBy, offset, join: unsafeJoin }) => {
+			transactionId++;
+			let thisTransactionId = transactionId;
+			const limit = unsafeLimit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere
+			});
+			unsafeModel = getDefaultModelName(unsafeModel);
+			let join;
+			let passJoinToAdapter = true;
+			if (!config.disableTransformJoin) {
+				const result = transformJoinClause(unsafeModel, unsafeJoin, void 0);
+				if (result) join = result.join;
+				if (!options.experimental?.joins && join && Object.keys(join).length > 0) passJoinToAdapter = false;
+			} else join = unsafeJoin;
+			debugLog({ method: "findMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 3)}`, `${formatMethod("findMany")}:`, {
+				model,
+				where,
+				limit,
+				sortBy,
+				offset,
+				join
+			});
+			const res = await adapterInstance.findMany({
+				model,
+				where,
+				limit,
+				sortBy,
+				offset,
+				join: passJoinToAdapter ? join : void 0
+			});
+			debugLog({ method: "findMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(2, 3)}`, `${formatMethod("findMany")} ${formatAction("DB Result")}:`, {
+				model,
+				data: res
+			});
+			let transformed = res;
+			if (!config.disableTransformOutput) transformed = await Promise.all(res.map(async (r) => {
+				return await transformOutput(r, unsafeModel, void 0, join);
+			}));
+			debugLog({ method: "findMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(3, 3)}`, `${formatMethod("findMany")} ${formatAction("Parsed Result")}:`, {
+				model,
+				data: transformed
+			});
+			return transformed;
+		},
+		delete: async ({ model: unsafeModel, where: unsafeWhere }) => {
+			transactionId++;
+			let thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere
+			});
+			unsafeModel = getDefaultModelName(unsafeModel);
+			debugLog({ method: "delete" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 2)}`, `${formatMethod("delete")}:`, {
+				model,
+				where
+			});
+			await adapterInstance.delete({
+				model,
+				where
+			});
+			debugLog({ method: "delete" }, `${formatTransactionId(thisTransactionId)} ${formatStep(2, 2)}`, `${formatMethod("delete")} ${formatAction("DB Result")}:`, { model });
+		},
+		deleteMany: async ({ model: unsafeModel, where: unsafeWhere }) => {
+			transactionId++;
+			let thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere
+			});
+			unsafeModel = getDefaultModelName(unsafeModel);
+			debugLog({ method: "deleteMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 2)}`, `${formatMethod("deleteMany")} ${formatAction("DeleteMany")}:`, {
+				model,
+				where
+			});
+			const res = await adapterInstance.deleteMany({
+				model,
+				where
+			});
+			debugLog({ method: "deleteMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(2, 2)}`, `${formatMethod("deleteMany")} ${formatAction("DB Result")}:`, {
+				model,
+				data: res
+			});
+			return res;
+		},
+		count: async ({ model: unsafeModel, where: unsafeWhere }) => {
+			transactionId++;
+			let thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere
+			});
+			unsafeModel = getDefaultModelName(unsafeModel);
+			debugLog({ method: "count" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 2)}`, `${formatMethod("count")}:`, {
+				model,
+				where
+			});
+			const res = await adapterInstance.count({
+				model,
+				where
+			});
+			debugLog({ method: "count" }, `${formatTransactionId(thisTransactionId)} ${formatStep(2, 2)}`, `${formatMethod("count")}:`, {
+				model,
+				data: res
+			});
+			return res;
+		},
+		createSchema: adapterInstance.createSchema ? async (_, file) => {
+			const tables = getAuthTables(options);
+			if (options.secondaryStorage && !options.session?.storeSessionInDatabase) delete tables.session;
+			if (options.rateLimit && options.rateLimit.storage === "database" && (typeof options.rateLimit.enabled === "undefined" || options.rateLimit.enabled === true)) tables.ratelimit = {
+				modelName: options.rateLimit.modelName ?? "ratelimit",
+				fields: {
+					key: {
+						type: "string",
+						unique: true,
+						required: true,
+						fieldName: options.rateLimit.fields?.key ?? "key"
+					},
+					count: {
+						type: "number",
+						required: true,
+						fieldName: options.rateLimit.fields?.count ?? "count"
+					},
+					lastRequest: {
+						type: "number",
+						required: true,
+						bigint: true,
+						defaultValue: () => Date.now(),
+						fieldName: options.rateLimit.fields?.lastRequest ?? "lastRequest"
+					}
+				}
+			};
+			return adapterInstance.createSchema({
+				file,
+				tables
+			});
+		} : void 0,
+		options: {
+			adapterConfig: config,
+			...adapterInstance.options ?? {}
+		},
+		id: config.adapterId,
+		...config.debugLogs?.isRunningAdapterTests ? { adapterTestDebugLogs: {
+			resetDebugLogs() {
+				debugLogs = debugLogs.filter((log) => log.instance !== uniqueAdapterFactoryInstanceId);
+			},
+			printDebugLogs() {
+				const separator = `─`.repeat(80);
+				const logs = debugLogs.filter((log$1) => log$1.instance === uniqueAdapterFactoryInstanceId);
+				if (logs.length === 0) return;
+				let log = logs.reverse().map((log$1) => {
+					log$1.args[0] = `\n${log$1.args[0]}`;
+					return [...log$1.args, "\n"];
+				}).reduce((prev, curr) => {
+					return [...curr, ...prev];
+				}, [`\n${separator}`]);
+				console.log(...log);
+			}
+		} } : {}
+	};
+	return adapter;
+};
+function formatTransactionId(transactionId$1) {
+	if (getColorDepth() < 8) return `#${transactionId$1}`;
+	return `${TTY_COLORS.fg.magenta}#${transactionId$1}${TTY_COLORS.reset}`;
+}
+function formatStep(step, total) {
+	return `${TTY_COLORS.bg.black}${TTY_COLORS.fg.yellow}[${step}/${total}]${TTY_COLORS.reset}`;
+}
+function formatMethod(method) {
+	return `${TTY_COLORS.bright}${method}${TTY_COLORS.reset}`;
+}
+function formatAction(action) {
+	return `${TTY_COLORS.dim}(${action})${TTY_COLORS.reset}`;
+}
+
+//#endregion
+export { isTest as _, BetterAuthError as a, getAuthTables as b, safeJSONParse as c, createLogger as d, env as f, isProduction as g, isDevelopment as h, BASE_ERROR_CODES as i, createRandomStringGenerator as l, getEnvVar as m, initGetFieldName as n, defineErrorCodes as o, getBooleanEnvVar as p, initGetModelName as r, generateId as s, createAdapterFactory as t, ENV as u, logger as v, shouldPublishLog as y };