faire-auth 1.0.0

package/dist/adapter-factory-DT-_2aHJ.cjs

@@ -0,0 +1,893 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+const require_json = require('./json-CcJ2HjGo.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_crypto = require("@faire-auth/core/crypto");
+
+//#region src/adapters/utils.ts
+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 (value === void 0 || value === null) {
+		if (field.defaultValue !== void 0) {
+			if (typeof field.defaultValue === "function") return field.defaultValue();
+			return field.defaultValue;
+		}
+	}
+	return value;
+}
+
+//#endregion
+//#region src/db/get-tables.ts
+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
+			},
+			...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"
+				},
+				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"
+				},
+				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"
+				},
+				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 src/adapters/adapter-factory/index.ts
+let debugLogs = [];
+let transactionId = -1;
+const createAsIsTransaction = (adapter) => (fn) => {
+	const res = fn(adapter);
+	return (0, __faire_auth_core_static.isPromise)(res) ? res : Promise.resolve(res);
+};
+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,
+		transaction: cfg.transaction ?? false,
+		disableTransformInput: cfg.disableTransformInput ?? false,
+		disableTransformOutput: cfg.disableTransformOutput ?? false
+	};
+	if (options.advanced?.database?.useNumberId === true && config.supportsNumericIds === false) throw new __faire_auth_core_error.FaireAuthError(`[${config.adapterName}] Your database or database adapter does not support numeric ids. Please disable "useNumberId" in your config.`);
+	const schema = getAuthTables(options);
+	/**
+	* 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: unsafe_model }) => {
+		if (field === "id" || field === "_id") return "id";
+		const model = getDefaultModelName(unsafe_model);
+		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) {
+			debugLog(`Field ${field} not found in model ${model}`);
+			debugLog(`Schema:`, schema);
+			throw new __faire_auth_core_error.FaireAuthError(`Field ${field} not found in model ${model}`);
+		}
+		return field;
+	};
+	/**
+	* 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 (config.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) {
+			debugLog(`Model "${model}" not found in schema`);
+			debugLog(`Schema:`, schema);
+			throw new __faire_auth_core_error.FaireAuthError(`Model "${model}" not found in schema`);
+		}
+		return m;
+	};
+	/**
+	* 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);
+		const usePlural = config && config.usePlural;
+		if (schema && schema[defaultModelKey] && schema[defaultModelKey].modelName !== model) return usePlural ? `${schema[defaultModelKey].modelName}s` : schema[defaultModelKey].modelName;
+		return usePlural ? `${model}s` : model;
+	};
+	/**
+	* 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: model_name, field: field_name }) {
+		const model = getDefaultModelName(model_name);
+		const field = getDefaultFieldName({
+			model,
+			field: field_name
+		});
+		return schema[model]?.fields[field]?.fieldName || field;
+	}
+	const debugLog = (...args) => {
+		if (config.debugLogs === true || typeof config.debugLogs === "object") {
+			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;
+				}
+				__faire_auth_core_env.logger.info(`[${config.adapterName}]`, ...args);
+			} else __faire_auth_core_env.logger.info(`[${config.adapterName}]`, ...args);
+		}
+	};
+	const idField = ({ customModelName, forceAllowId }) => {
+		const shouldGenerateId = !config.disableIdGeneration && !options.advanced?.database?.useNumberId && !forceAllowId;
+		const model = getDefaultModelName(customModelName ?? "id");
+		return {
+			type: options.advanced?.database?.useNumberId ? "number" : "string",
+			required: shouldGenerateId ? true : false,
+			...shouldGenerateId ? { defaultValue() {
+				if (config.disableIdGeneration) return void 0;
+				const useNumberId = options.advanced?.database?.useNumberId;
+				let generateId$1 = options.advanced?.database?.generateId;
+				if (options.advanced?.generateId !== void 0) {
+					__faire_auth_core_env.logger.warn("Your Faire Auth config includes advanced.generateId which is deprecated. Please use advanced.database.generateId instead. This will be removed in future releases.");
+					generateId$1 = options.advanced?.generateId;
+				}
+				if (generateId$1 === false || useNumberId) return void 0;
+				if (generateId$1) return generateId$1({ model });
+				if (config.customIdGenerator) return config.customIdGenerator({ model });
+				return (0, __faire_auth_core_crypto.generateId)();
+			} } : {}
+		};
+	};
+	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 __faire_auth_core_error.FaireAuthError(`Field ${field} not found in model ${model}`);
+		return fieldAttributes;
+	};
+	const transformInput = async (data, defaultModelName, action, forceAllowId) => {
+		const transformedData = {};
+		const fields = schema[defaultModelName].fields;
+		const newMappedKeys = config.mapKeysTransformInput ?? {};
+		if (!config.disableIdGeneration && !options.advanced?.database?.useNumberId) fields.id = idField({
+			customModelName: defaultModelName,
+			forceAllowId: !!forceAllowId && "id" in data
+		});
+		for (const field in fields) {
+			const 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;
+			let newValue = withApplyDefault(value, fieldAttributes, action);
+			if (fieldAttributes.transform?.input) newValue = await fieldAttributes.transform.input(newValue);
+			if (fieldAttributes.references?.field === "id" && options.advanced?.database?.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.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: defaultModelName,
+				schema,
+				options
+			});
+			if (newValue !== void 0) transformedData[newFieldName] = newValue;
+		}
+		return transformedData;
+	};
+	const transformOutput = async (data, unsafe_model, select = []) => {
+		if (!data) return null;
+		const newMappedKeys = config.mapKeysTransformOutput ?? {};
+		const transformedData = {};
+		const tableSchema = schema[unsafe_model].fields;
+		const idKey = Object.entries(newMappedKeys).find(([_, v]) => v === "id")?.[0];
+		tableSchema[idKey ?? "id"] = { type: options.advanced?.database?.useNumberId ? "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);
+				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 = require_json.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: unsafe_model,
+					schema,
+					options
+				});
+				transformedData[newFieldName] = newValue;
+			}
+		}
+		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 __faire_auth_core_error.FaireAuthError("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
+			});
+			if (defaultFieldName === "id" || fieldAttr.references?.field === "id") {
+				if (options.advanced?.database?.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 adapterInstance = customAdapter({
+		options,
+		schema,
+		debugLog,
+		getFieldName,
+		getModelName,
+		getDefaultModelName,
+		getDefaultFieldName,
+		getFieldAttributes,
+		transformInput,
+		transformOutput,
+		transformWhereClause
+	});
+	let lazyLoadTransaction = null;
+	const adapter = {
+		transaction: (cb) => {
+			if (!lazyLoadTransaction) if (!config.transaction) {
+				if (typeof config.debugLogs === "object" && "isRunningAdapterTests" in config.debugLogs && config.debugLogs.isRunningAdapterTests) {} else __faire_auth_core_env.logger.warn(`[${config.adapterName}] - Transactions are not supported. Executing operations sequentially.`);
+				lazyLoadTransaction = createAsIsTransaction(adapter);
+			} else {
+				__faire_auth_core_env.logger.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 && !forceAllowId) {
+				__faire_auth_core_env.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 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);
+			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);
+			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 }) => {
+			transactionId++;
+			let thisTransactionId = transactionId;
+			const model = getModelName(unsafeModel);
+			const where = transformWhereClause({
+				model: unsafeModel,
+				where: unsafeWhere
+			});
+			unsafeModel = getDefaultModelName(unsafeModel);
+			debugLog({ method: "findOne" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 3)}`, `${formatMethod("findOne")}:`, {
+				model,
+				where,
+				select
+			});
+			const res = await adapterInstance.findOne({
+				model,
+				where,
+				...select && { select }
+			});
+			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);
+			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 }) => {
+			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);
+			debugLog({ method: "findMany" }, `${formatTransactionId(thisTransactionId)} ${formatStep(1, 3)}`, `${formatMethod("findMany")}:`, {
+				model,
+				where,
+				limit,
+				sortBy,
+				offset
+			});
+			const res = await adapterInstance.findMany({
+				model,
+				...where && { where },
+				limit,
+				...sortBy && { sortBy },
+				...offset && { offset }
+			});
+			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) => await transformOutput(r, unsafeModel)));
+			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 && { 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 && { 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 ((0, __faire_auth_core_env.getColorDepth)() < 8) return `#${transactionId$1}`;
+	return `${__faire_auth_core_env.TTY_COLORS.fg.magenta}#${transactionId$1}${__faire_auth_core_env.TTY_COLORS.reset}`;
+}
+function formatStep(step, total) {
+	return `${__faire_auth_core_env.TTY_COLORS.bg.black}${__faire_auth_core_env.TTY_COLORS.fg.yellow}[${step}/${total}]${__faire_auth_core_env.TTY_COLORS.reset}`;
+}
+function formatMethod(method) {
+	return `${__faire_auth_core_env.TTY_COLORS.bright}${method}${__faire_auth_core_env.TTY_COLORS.reset}`;
+}
+function formatAction(action) {
+	return `${__faire_auth_core_env.TTY_COLORS.dim}(${action})${__faire_auth_core_env.TTY_COLORS.reset}`;
+}
+
+//#endregion
+Object.defineProperty(exports, 'createAdapterFactory', {
+  enumerable: true,
+  get: function () {
+    return createAdapterFactory;
+  }
+});
+Object.defineProperty(exports, 'getAuthTables', {
+  enumerable: true,
+  get: function () {
+    return getAuthTables;
+  }
+});