create-croissant 0.1.0 → 0.1.2

package/template/apps/web/node_modules/@better-auth/core/dist/db/adapter/factory.mjs

@@ -0,0 +1,754 @@
+import { BetterAuthError } from "../../error/index.mjs";
+import { getAuthTables } from "../get-tables.mjs";
+import { getColorDepth } from "../../env/color-depth.mjs";
+import { TTY_COLORS, createLogger } from "../../env/logger.mjs";
+import { ATTR_DB_COLLECTION_NAME, ATTR_DB_OPERATION_NAME } from "../../instrumentation/attributes.mjs";
+import { withSpan } from "../../instrumentation/tracer.mjs";
+import { safeJSONParse } from "../../utils/json.mjs";
+import { initGetDefaultModelName } from "./get-default-model-name.mjs";
+import { initGetDefaultFieldName } from "./get-default-field-name.mjs";
+import { initGetIdField } from "./get-id-field.mjs";
+import { initGetFieldAttributes } from "./get-field-attributes.mjs";
+import { initGetFieldName } from "./get-field-name.mjs";
+import { initGetModelName } from "./get-model-name.mjs";
+import { withApplyDefault } from "./utils.mjs";
+//#region src/db/adapter/factory.ts
+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?.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 = 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.info(`[${config.adapterName}]`, ...args);
+			} else logger.info(`[${config.adapterName}]`, ...args);
+		}
+	};
+	const logger = 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?.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];
+			const 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.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, unsafe_model, select = []) => {
+			if (!data) return null;
+			const newMappedKeys = config.mapKeysTransformOutput ?? {};
+			const transformedData = {};
+			const tableSchema = schema[getDefaultModelName(unsafe_model)].fields;
+			const idKey = Object.entries(newMappedKeys).find(([_, v]) => v === "id")?.[0];
+			tableSchema[idKey ?? "id"] = { type: options.advanced?.database?.generateId === "serial" ? "number" : "string" };
+			for (const key in tableSchema) {
+				if (select.length && !select.includes(key)) continue;
+				const field = tableSchema[key];
+				if (field) {
+					const originalKey = field.fieldName || key;
+					let newValue = data[Object.entries(newMappedKeys).find(([_, v]) => v === originalKey)?.[0] || originalKey];
+					if (field.transform?.output) newValue = await field.transform.output(newValue);
+					const 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,
+						model: getModelName(unsafe_model),
+						schema,
+						options
+					});
+					transformedData[newFieldName] = newValue;
+				}
+			}
+			return transformedData;
+		};
+		if (!join || Object.keys(join).length === 0) return await transformSingleOutput(data, unsafe_model, select);
+		unsafe_model = getDefaultModelName(unsafe_model);
+		const 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];
+			const 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, action }) => {
+		if (!where) return void 0;
+		const newMappedKeys = config.mapKeysTransformInput ?? {};
+		return where.map((w) => {
+			const { field: unsafe_field, value, operator = "eq", connector = "AND", mode = "sensitive" } = 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?.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 newValue === "string") newValue = newValue === "true";
+			if (fieldAttr.type === "number") {
+				if (typeof newValue === "string" && newValue.trim() !== "") {
+					const parsed = Number(newValue);
+					if (!Number.isNaN(parsed)) newValue = parsed;
+				} else if (Array.isArray(newValue)) {
+					const parsed = newValue.map((v) => typeof v === "string" && v.trim() !== "" ? Number(v) : NaN);
+					if (parsed.every((n) => !Number.isNaN(n))) newValue = parsed;
+				}
+			}
+			if (fieldAttr.type === "boolean" && typeof newValue === "boolean" && !config.supportsBooleans) newValue = newValue ? 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 });
+			}
+			if (config.customTransformInput) newValue = config.customTransformInput({
+				data: newValue,
+				fieldAttributes: fieldAttr,
+				field: fieldName,
+				model: getModelName(model),
+				schema,
+				options,
+				action
+			});
+			return {
+				operator,
+				connector,
+				field: fieldName,
+				value: newValue,
+				mode
+			};
+		});
+	};
+	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"
+			}],
+			action: "findOne"
+		});
+		try {
+			if (joinConfig.relation === "one-to-one") result = await withSpan(`db findOne ${modelName}`, {
+				[ATTR_DB_OPERATION_NAME]: "findOne",
+				[ATTR_DB_COLLECTION_NAME]: modelName
+			}, () => adapterInstance.findOne({
+				model: modelName,
+				where
+			}));
+			else {
+				const limit = joinConfig.limit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+				result = await withSpan(`db findMany ${modelName}`, {
+					[ATTR_DB_OPERATION_NAME]: "findMany",
+					[ATTR_DB_COLLECTION_NAME]: modelName
+				}, () => adapterInstance.findMany({
+					model: modelName,
+					where,
+					limit
+				}));
+			}
+		} catch (error) {
+			logger.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.debug(`[${config.adapterName}] - Using provided transaction implementation.`);
+				lazyLoadTransaction = config.transaction;
+			}
+			return lazyLoadTransaction(cb);
+		},
+		create: async ({ data: unsafeData, model: unsafeModel, select, forceAllowId = false }) => {
+			transactionId++;
+			const thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			unsafeModel = getDefaultModelName(unsafeModel);
+			if ("id" in unsafeData && typeof unsafeData.id !== "undefined" && !forceAllowId) {
+				logger.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 withSpan(`db create ${model}`, {
+				[ATTR_DB_OPERATION_NAME]: "create",
+				[ATTR_DB_COLLECTION_NAME]: model
+			}, () => 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++;
+			const thisTransactionId = transactionId;
+			unsafeModel = getDefaultModelName(unsafeModel);
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere,
+				action: "update"
+			});
+			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 withSpan(`db update ${model}`, {
+				[ATTR_DB_OPERATION_NAME]: "update",
+				[ATTR_DB_COLLECTION_NAME]: model
+			}, () => 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++;
+			const thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere,
+				action: "updateMany"
+			});
+			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 withSpan(`db updateMany ${model}`, {
+				[ATTR_DB_OPERATION_NAME]: "updateMany",
+				[ATTR_DB_COLLECTION_NAME]: model
+			}, () => 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++;
+			const thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere,
+				action: "findOne"
+			});
+			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 withSpan(`db findOne ${model}`, {
+				[ATTR_DB_OPERATION_NAME]: "findOne",
+				[ATTR_DB_COLLECTION_NAME]: model
+			}, () => 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, select, sortBy, offset, join: unsafeJoin }) => {
+			transactionId++;
+			const thisTransactionId = transactionId;
+			const limit = unsafeLimit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere,
+				action: "findMany"
+			});
+			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: "findMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 3)}`, `${formatMethod("findMany")}:`, {
+				model,
+				where,
+				limit,
+				sortBy,
+				offset,
+				join
+			});
+			const res = await withSpan(`db findMany ${model}`, {
+				[ATTR_DB_OPERATION_NAME]: "findMany",
+				[ATTR_DB_COLLECTION_NAME]: model
+			}, () => adapterInstance.findMany({
+				model,
+				where,
+				limit,
+				select,
+				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++;
+			const thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere,
+				action: "delete"
+			});
+			unsafeModel = getDefaultModelName(unsafeModel);
+			debugLog({ method: "delete" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 2)}`, `${formatMethod("delete")}:`, {
+				model,
+				where
+			});
+			await withSpan(`db delete ${model}`, {
+				[ATTR_DB_OPERATION_NAME]: "delete",
+				[ATTR_DB_COLLECTION_NAME]: model
+			}, () => 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++;
+			const thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere,
+				action: "deleteMany"
+			});
+			unsafeModel = getDefaultModelName(unsafeModel);
+			debugLog({ method: "deleteMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 2)}`, `${formatMethod("deleteMany")} ${formatAction("DeleteMany")}:`, {
+				model,
+				where
+			});
+			const res = await withSpan(`db deleteMany ${model}`, {
+				[ATTR_DB_OPERATION_NAME]: "deleteMany",
+				[ATTR_DB_COLLECTION_NAME]: model
+			}, () => 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++;
+			const thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere,
+				action: "count"
+			});
+			unsafeModel = getDefaultModelName(unsafeModel);
+			debugLog({ method: "count" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 2)}`, `${formatMethod("count")}:`, {
+				model,
+				where
+			});
+			const res = await withSpan(`db count ${model}`, {
+				[ATTR_DB_OPERATION_NAME]: "count",
+				[ATTR_DB_COLLECTION_NAME]: model
+			}, () => 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;
+			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) => log.instance === uniqueAdapterFactoryInstanceId);
+				if (logs.length === 0) return;
+				const log = logs.reverse().map((log) => {
+					log.args[0] = `\n${log.args[0]}`;
+					return [...log.args, "\n"];
+				}).reduce((prev, curr) => {
+					return [...curr, ...prev];
+				}, [`\n${separator}`]);
+				console.log(...log);
+			}
+		} } : {}
+	};
+	return adapter;
+};
+function formatTransactionId(transactionId) {
+	if (getColorDepth() < 8) return `#${transactionId}`;
+	return `${TTY_COLORS.fg.magenta}#${transactionId}${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 { createAdapterFactory };