@better-auth/mongo-adapter 1.5.0-beta.9

package/.turbo/turbo-build.log

@@ -0,0 +1,13 @@
+
+> @better-auth/mongo-adapter@1.5.0-beta.9 build /home/runner/work/better-auth/better-auth/packages/mongo-adapter
+> tsdown
+
+ℹ tsdown v0.19.0 powered by rolldown v1.0.0-beta.59
+ℹ config file: /home/runner/work/better-auth/better-auth/packages/mongo-adapter/tsdown.config.ts 
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ dist/index.mjs    12.70 kB │ gzip: 3.08 kB
+ℹ dist/index.d.mts   1.20 kB │ gzip: 0.55 kB
+ℹ 2 files, total: 13.90 kB
+✔ Build complete in 8298ms

package/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2024 - present, Bereket Engida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,37 @@
+import { DBAdapter, DBAdapterDebugLogOption } from "@better-auth/core/db/adapter";
+import { Db, MongoClient } from "mongodb";
+import { BetterAuthOptions } from "@better-auth/core";
+
+//#region src/mongodb-adapter.d.ts
+interface MongoDBAdapterConfig {
+  /**
+   * MongoDB client instance
+   * If not provided, Database transactions won't be enabled.
+   */
+  client?: MongoClient | undefined;
+  /**
+   * Enable debug logs for the adapter
+   *
+   * @default false
+   */
+  debugLogs?: DBAdapterDebugLogOption | undefined;
+  /**
+   * Use plural table names
+   *
+   * @default false
+   */
+  usePlural?: boolean | undefined;
+  /**
+   * Whether to execute multiple operations in a transaction.
+   *
+   * ⚠️ Important:
+   * - Defaults to `true` when a MongoDB client is provided.
+   * - If your MongoDB instance does not support transactions
+   *   (e.g. standalone server without a replica set),
+   *   you must explicitly set `transaction: false`.
+   */
+  transaction?: boolean | undefined;
+}
+declare const mongodbAdapter: (db: Db, config?: MongoDBAdapterConfig | undefined) => (options: BetterAuthOptions) => DBAdapter<BetterAuthOptions>;
+//#endregion
+export { MongoDBAdapterConfig, mongodbAdapter };

package/dist/index.mjs

@@ -0,0 +1,398 @@
+import { createAdapterFactory } from "@better-auth/core/db/adapter";
+import { ObjectId } from "mongodb";
+
+//#region src/mongodb-adapter.ts
+var MongoAdapterError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "MongoAdapterError";
+	}
+};
+const mongodbAdapter = (db, config) => {
+	let lazyOptions;
+	const getCustomIdGenerator = (options) => {
+		const generator = options.advanced?.database?.generateId;
+		if (typeof generator === "function") return generator;
+	};
+	const createCustomAdapter = (db$1, session) => ({ getFieldAttributes, getFieldName, schema, getDefaultModelName, options }) => {
+		const customIdGen = getCustomIdGenerator(options);
+		function serializeID({ field, value, model }) {
+			if (customIdGen) return value;
+			model = getDefaultModelName(model);
+			if (field === "id" || field === "_id" || schema[model].fields[field]?.references?.field === "id") {
+				if (value === null || value === void 0) return value;
+				if (typeof value !== "string") {
+					if (value instanceof ObjectId) return value;
+					if (Array.isArray(value)) return value.map((v) => {
+						if (v === null || v === void 0) return v;
+						if (typeof v === "string") try {
+							return new ObjectId(v);
+						} catch {
+							return v;
+						}
+						if (v instanceof ObjectId) return v;
+						throw new MongoAdapterError("INVALID_ID", "Invalid id value");
+					});
+					throw new MongoAdapterError("INVALID_ID", "Invalid id value");
+				}
+				try {
+					return new ObjectId(value);
+				} catch {
+					return value;
+				}
+			}
+			return value;
+		}
+		function convertWhereClause({ where, model }) {
+			if (!where.length) return {};
+			const conditions = where.map((w) => {
+				const { field: field_, value, operator = "eq", connector = "AND" } = w;
+				let condition;
+				let field = getFieldName({
+					model,
+					field: field_
+				});
+				if (field === "id") field = "_id";
+				switch (operator.toLowerCase()) {
+					case "eq":
+						condition = { [field]: serializeID({
+							field,
+							value,
+							model
+						}) };
+						break;
+					case "in":
+						condition = { [field]: { $in: Array.isArray(value) ? value.map((v) => serializeID({
+							field,
+							value: v,
+							model
+						})) : [serializeID({
+							field,
+							value,
+							model
+						})] } };
+						break;
+					case "not_in":
+						condition = { [field]: { $nin: Array.isArray(value) ? value.map((v) => serializeID({
+							field,
+							value: v,
+							model
+						})) : [serializeID({
+							field,
+							value,
+							model
+						})] } };
+						break;
+					case "gt":
+						condition = { [field]: { $gt: serializeID({
+							field,
+							value,
+							model
+						}) } };
+						break;
+					case "gte":
+						condition = { [field]: { $gte: serializeID({
+							field,
+							value,
+							model
+						}) } };
+						break;
+					case "lt":
+						condition = { [field]: { $lt: serializeID({
+							field,
+							value,
+							model
+						}) } };
+						break;
+					case "lte":
+						condition = { [field]: { $lte: serializeID({
+							field,
+							value,
+							model
+						}) } };
+						break;
+					case "ne":
+						condition = { [field]: { $ne: serializeID({
+							field,
+							value,
+							model
+						}) } };
+						break;
+					case "contains":
+						condition = { [field]: { $regex: `.*${escapeForMongoRegex(value)}.*` } };
+						break;
+					case "starts_with":
+						condition = { [field]: { $regex: `^${escapeForMongoRegex(value)}` } };
+						break;
+					case "ends_with":
+						condition = { [field]: { $regex: `${escapeForMongoRegex(value)}$` } };
+						break;
+					default: throw new MongoAdapterError("UNSUPPORTED_OPERATOR", `Unsupported operator: ${operator}`);
+				}
+				return {
+					condition,
+					connector
+				};
+			});
+			if (conditions.length === 1) return conditions[0].condition;
+			const andConditions = conditions.filter((c) => c.connector === "AND").map((c) => c.condition);
+			const orConditions = conditions.filter((c) => c.connector === "OR").map((c) => c.condition);
+			let clause = {};
+			if (andConditions.length) clause = {
+				...clause,
+				$and: andConditions
+			};
+			if (orConditions.length) clause = {
+				...clause,
+				$or: orConditions
+			};
+			return clause;
+		}
+		return {
+			async create({ model, data: values }) {
+				return {
+					_id: (await db$1.collection(model).insertOne(values, { session })).insertedId.toString(),
+					...values
+				};
+			},
+			async findOne({ model, where, select, join }) {
+				const pipeline = [where ? { $match: convertWhereClause({
+					where,
+					model
+				}) } : { $match: {} }];
+				if (join) for (const [joinedModel, joinConfig] of Object.entries(join)) {
+					const localField = getFieldName({
+						field: joinConfig.on.from,
+						model
+					});
+					const foreignField = getFieldName({
+						field: joinConfig.on.to,
+						model: joinedModel
+					});
+					const localFieldName = localField === "id" ? "_id" : localField;
+					const foreignFieldName = foreignField === "id" ? "_id" : foreignField;
+					const isUnique = (schema[getDefaultModelName(joinedModel)]?.fields[joinConfig.on.to])?.unique === true;
+					const shouldLimit = !isUnique && joinConfig.limit !== void 0;
+					const limit = joinConfig.limit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+					if (shouldLimit && limit > 0) {
+						const foreignFieldRef = `$${foreignFieldName}`;
+						pipeline.push({ $lookup: {
+							from: joinedModel,
+							let: { localFieldValue: `$${localFieldName}` },
+							pipeline: [{ $match: { $expr: { $eq: [foreignFieldRef, "$$localFieldValue"] } } }, { $limit: limit }],
+							as: joinedModel
+						} });
+					} else pipeline.push({ $lookup: {
+						from: joinedModel,
+						localField: localFieldName,
+						foreignField: foreignFieldName,
+						as: joinedModel
+					} });
+					if (isUnique) pipeline.push({ $unwind: {
+						path: `$${joinedModel}`,
+						preserveNullAndEmptyArrays: true
+					} });
+				}
+				if (select) {
+					const projection = {};
+					select.forEach((field) => {
+						projection[getFieldName({
+							field,
+							model
+						})] = 1;
+					});
+					if (join) for (const joinedModel of Object.keys(join)) projection[joinedModel] = 1;
+					pipeline.push({ $project: projection });
+				}
+				pipeline.push({ $limit: 1 });
+				const res = await db$1.collection(model).aggregate(pipeline, { session }).toArray();
+				if (!res || res.length === 0) return null;
+				return res[0];
+			},
+			async findMany({ model, where, limit, offset, sortBy, join }) {
+				const pipeline = [where ? { $match: convertWhereClause({
+					where,
+					model
+				}) } : { $match: {} }];
+				if (join) for (const [joinedModel, joinConfig] of Object.entries(join)) {
+					const localField = getFieldName({
+						field: joinConfig.on.from,
+						model
+					});
+					const foreignField = getFieldName({
+						field: joinConfig.on.to,
+						model: joinedModel
+					});
+					const localFieldName = localField === "id" ? "_id" : localField;
+					const foreignFieldName = foreignField === "id" ? "_id" : foreignField;
+					const isUnique = getFieldAttributes({
+						model: joinedModel,
+						field: joinConfig.on.to
+					})?.unique === true;
+					const shouldLimit = joinConfig.relation !== "one-to-one" && joinConfig.limit !== void 0;
+					const limit$1 = joinConfig.limit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+					if (shouldLimit && limit$1 > 0) {
+						const foreignFieldRef = `$${foreignFieldName}`;
+						pipeline.push({ $lookup: {
+							from: joinedModel,
+							let: { localFieldValue: `$${localFieldName}` },
+							pipeline: [{ $match: { $expr: { $eq: [foreignFieldRef, "$$localFieldValue"] } } }, { $limit: limit$1 }],
+							as: joinedModel
+						} });
+					} else pipeline.push({ $lookup: {
+						from: joinedModel,
+						localField: localFieldName,
+						foreignField: foreignFieldName,
+						as: joinedModel
+					} });
+					if (isUnique) pipeline.push({ $unwind: {
+						path: `$${joinedModel}`,
+						preserveNullAndEmptyArrays: true
+					} });
+				}
+				if (sortBy) pipeline.push({ $sort: { [getFieldName({
+					field: sortBy.field,
+					model
+				})]: sortBy.direction === "desc" ? -1 : 1 } });
+				if (offset) pipeline.push({ $skip: offset });
+				if (limit) pipeline.push({ $limit: limit });
+				return await db$1.collection(model).aggregate(pipeline, { session }).toArray();
+			},
+			async count({ model, where }) {
+				const pipeline = [where ? { $match: convertWhereClause({
+					where,
+					model
+				}) } : { $match: {} }, { $count: "total" }];
+				const res = await db$1.collection(model).aggregate(pipeline, { session }).toArray();
+				if (!res || res.length === 0) return 0;
+				return res[0]?.total ?? 0;
+			},
+			async update({ model, where, update: values }) {
+				const clause = convertWhereClause({
+					where,
+					model
+				});
+				const doc = (await db$1.collection(model).findOneAndUpdate(clause, { $set: values }, {
+					session,
+					returnDocument: "after",
+					includeResultMetadata: true
+				}))?.value ?? null;
+				if (!doc) return null;
+				return doc;
+			},
+			async updateMany({ model, where, update: values }) {
+				const clause = convertWhereClause({
+					where,
+					model
+				});
+				return (await db$1.collection(model).updateMany(clause, { $set: values }, { session })).modifiedCount;
+			},
+			async delete({ model, where }) {
+				const clause = convertWhereClause({
+					where,
+					model
+				});
+				await db$1.collection(model).deleteOne(clause, { session });
+			},
+			async deleteMany({ model, where }) {
+				const clause = convertWhereClause({
+					where,
+					model
+				});
+				return (await db$1.collection(model).deleteMany(clause, { session })).deletedCount;
+			}
+		};
+	};
+	let lazyAdapter = null;
+	let adapterOptions = null;
+	adapterOptions = {
+		config: {
+			adapterId: "mongodb-adapter",
+			adapterName: "MongoDB Adapter",
+			usePlural: config?.usePlural ?? false,
+			debugLogs: config?.debugLogs ?? false,
+			mapKeysTransformInput: { id: "_id" },
+			mapKeysTransformOutput: { _id: "id" },
+			supportsArrays: true,
+			supportsNumericIds: false,
+			transaction: config?.client && (config?.transaction ?? true) ? async (cb) => {
+				if (!config.client) return cb(lazyAdapter(lazyOptions));
+				const session = config.client.startSession();
+				try {
+					session.startTransaction();
+					const result = await cb(createAdapterFactory({
+						config: adapterOptions.config,
+						adapter: createCustomAdapter(db, session)
+					})(lazyOptions));
+					await session.commitTransaction();
+					return result;
+				} catch (err) {
+					await session.abortTransaction();
+					throw err;
+				} finally {
+					await session.endSession();
+				}
+			} : false,
+			customTransformInput({ action, data, field, fieldAttributes, schema, model, options }) {
+				const customIdGen = getCustomIdGenerator(options);
+				if (field === "_id" || fieldAttributes.references?.field === "id") {
+					if (customIdGen) return data;
+					if (action !== "create") return data;
+					if (Array.isArray(data)) return data.map((v) => {
+						if (typeof v === "string") try {
+							return new ObjectId(v);
+						} catch {
+							return v;
+						}
+						return v;
+					});
+					if (typeof data === "string") try {
+						return new ObjectId(data);
+					} catch {
+						return data;
+					}
+					if (fieldAttributes?.references?.field === "id" && !fieldAttributes?.required && data === null) return null;
+					return new ObjectId();
+				}
+				return data;
+			},
+			customTransformOutput({ data, field, fieldAttributes }) {
+				if (field === "id" || fieldAttributes.references?.field === "id") {
+					if (data instanceof ObjectId) return data.toHexString();
+					if (Array.isArray(data)) return data.map((v) => {
+						if (v instanceof ObjectId) return v.toHexString();
+						return v;
+					});
+					return data;
+				}
+				return data;
+			},
+			customIdGenerator() {
+				return new ObjectId().toString();
+			}
+		},
+		adapter: createCustomAdapter(db)
+	};
+	lazyAdapter = createAdapterFactory(adapterOptions);
+	return (options) => {
+		lazyOptions = options;
+		return lazyAdapter(options);
+	};
+};
+/**
+* Safely escape user input for use in a MongoDB regex.
+* This ensures the resulting pattern is treated as literal text,
+* and not as a regex with special syntax.
+*
+* @param input - The input string to escape. Any type that isn't a string will be converted to an empty string.
+* @param maxLength - The maximum length of the input string to escape. Defaults to 256. This is to prevent DOS attacks.
+* @returns The escaped string.
+*/
+function escapeForMongoRegex(input, maxLength = 256) {
+	if (typeof input !== "string") return "";
+	return input.slice(0, maxLength).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+//#endregion
+export { mongodbAdapter };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@better-auth/mongo-adapter",
+  "version": "1.5.0-beta.9",
+  "description": "Mongo adapter for Better Auth",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/better-auth/better-auth.git",
+    "directory": "packages/mongo-adapter"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "dev-source": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "peerDependencies": {
+    "@better-auth/utils": "^0.3.0",
+    "mongodb": "^6.0.0 || ^7.0.0",
+    "@better-auth/core": "1.5.0-beta.9"
+  },
+  "devDependencies": {
+    "@better-auth/utils": "^0.3.0",
+    "mongodb": "^7.0.0",
+    "tsdown": "^0.19.0",
+    "typescript": "^5.9.3",
+    "@better-auth/core": "1.5.0-beta.9"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./mongodb-adapter";

package/src/mongodb-adapter.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it, vi } from "vitest";
+import { mongodbAdapter } from "./mongodb-adapter";
+
+describe("mongodb-adapter", () => {
+	it("should create mongodb adapter", () => {
+		const db = {
+			collection: vi.fn(),
+		} as any;
+		const adapter = mongodbAdapter(db);
+		expect(adapter).toBeDefined();
+	});
+});

package/src/mongodb-adapter.ts

@@ -0,0 +1,701 @@
+import type { BetterAuthOptions } from "@better-auth/core";
+import type {
+	AdapterFactoryCustomizeAdapterCreator,
+	AdapterFactoryOptions,
+	DBAdapter,
+	DBAdapterDebugLogOption,
+	Where,
+} from "@better-auth/core/db/adapter";
+import { createAdapterFactory } from "@better-auth/core/db/adapter";
+import type { ClientSession, Db, MongoClient } from "mongodb";
+import { ObjectId } from "mongodb";
+
+class MongoAdapterError extends Error {
+	constructor(
+		public code: "INVALID_ID" | "UNSUPPORTED_OPERATOR",
+		message: string,
+	) {
+		super(message);
+		this.name = "MongoAdapterError";
+	}
+}
+
+export interface MongoDBAdapterConfig {
+	/**
+	 * MongoDB client instance
+	 * If not provided, Database transactions won't be enabled.
+	 */
+	client?: MongoClient | undefined;
+	/**
+	 * Enable debug logs for the adapter
+	 *
+	 * @default false
+	 */
+	debugLogs?: DBAdapterDebugLogOption | undefined;
+	/**
+	 * Use plural table names
+	 *
+	 * @default false
+	 */
+	usePlural?: boolean | undefined;
+	/**
+	 * Whether to execute multiple operations in a transaction.
+	 *
+	 * ⚠️ Important:
+	 * - Defaults to `true` when a MongoDB client is provided.
+	 * - If your MongoDB instance does not support transactions
+	 *   (e.g. standalone server without a replica set),
+	 *   you must explicitly set `transaction: false`.
+	 */
+	transaction?: boolean | undefined;
+}
+
+export const mongodbAdapter = (
+	db: Db,
+	config?: MongoDBAdapterConfig | undefined,
+) => {
+	let lazyOptions: BetterAuthOptions | null;
+
+	const getCustomIdGenerator = (options: BetterAuthOptions) => {
+		const generator = options.advanced?.database?.generateId;
+		if (typeof generator === "function") {
+			return generator;
+		}
+		return undefined;
+	};
+
+	const createCustomAdapter =
+		(
+			db: Db,
+			session?: ClientSession | undefined,
+		): AdapterFactoryCustomizeAdapterCreator =>
+		({
+			getFieldAttributes,
+			getFieldName,
+			schema,
+			getDefaultModelName,
+			options,
+		}) => {
+			const customIdGen = getCustomIdGenerator(options);
+
+			function serializeID({
+				field,
+				value,
+				model,
+			}: {
+				field: string;
+				value: any;
+				model: string;
+			}) {
+				if (customIdGen) {
+					return value;
+				}
+				model = getDefaultModelName(model);
+				if (
+					field === "id" ||
+					field === "_id" ||
+					schema[model]!.fields[field]?.references?.field === "id"
+				) {
+					if (value === null || value === undefined) {
+						return value;
+					}
+					if (typeof value !== "string") {
+						if (value instanceof ObjectId) {
+							return value;
+						}
+						if (Array.isArray(value)) {
+							return value.map((v) => {
+								if (v === null || v === undefined) {
+									return v;
+								}
+								if (typeof v === "string") {
+									try {
+										return new ObjectId(v);
+									} catch {
+										return v;
+									}
+								}
+								if (v instanceof ObjectId) {
+									return v;
+								}
+								throw new MongoAdapterError("INVALID_ID", "Invalid id value");
+							});
+						}
+						throw new MongoAdapterError("INVALID_ID", "Invalid id value");
+					}
+					try {
+						return new ObjectId(value);
+					} catch {
+						return value;
+					}
+				}
+				return value;
+			}
+
+			function convertWhereClause({
+				where,
+				model,
+			}: {
+				where: Where[];
+				model: string;
+			}) {
+				if (!where.length) return {};
+				const conditions = where.map((w) => {
+					const {
+						field: field_,
+						value,
+						operator = "eq",
+						connector = "AND",
+					} = w;
+					let condition: any;
+					let field = getFieldName({ model, field: field_ });
+					if (field === "id") field = "_id";
+					switch (operator.toLowerCase()) {
+						case "eq":
+							condition = {
+								[field]: serializeID({
+									field,
+									value,
+									model,
+								}),
+							};
+							break;
+						case "in":
+							condition = {
+								[field]: {
+									$in: Array.isArray(value)
+										? value.map((v) => serializeID({ field, value: v, model }))
+										: [serializeID({ field, value, model })],
+								},
+							};
+							break;
+						case "not_in":
+							condition = {
+								[field]: {
+									$nin: Array.isArray(value)
+										? value.map((v) => serializeID({ field, value: v, model }))
+										: [serializeID({ field, value, model })],
+								},
+							};
+							break;
+						case "gt":
+							condition = {
+								[field]: {
+									$gt: serializeID({
+										field,
+										value,
+										model,
+									}),
+								},
+							};
+							break;
+						case "gte":
+							condition = {
+								[field]: {
+									$gte: serializeID({
+										field,
+										value,
+										model,
+									}),
+								},
+							};
+							break;
+						case "lt":
+							condition = {
+								[field]: {
+									$lt: serializeID({
+										field,
+										value,
+										model,
+									}),
+								},
+							};
+							break;
+						case "lte":
+							condition = {
+								[field]: {
+									$lte: serializeID({
+										field,
+										value,
+										model,
+									}),
+								},
+							};
+							break;
+						case "ne":
+							condition = {
+								[field]: {
+									$ne: serializeID({
+										field,
+										value,
+										model,
+									}),
+								},
+							};
+							break;
+						case "contains":
+							condition = {
+								[field]: {
+									$regex: `.*${escapeForMongoRegex(value as string)}.*`,
+								},
+							};
+							break;
+						case "starts_with":
+							condition = {
+								[field]: { $regex: `^${escapeForMongoRegex(value as string)}` },
+							};
+							break;
+						case "ends_with":
+							condition = {
+								[field]: { $regex: `${escapeForMongoRegex(value as string)}$` },
+							};
+							break;
+						default:
+							throw new MongoAdapterError(
+								"UNSUPPORTED_OPERATOR",
+								`Unsupported operator: ${operator}`,
+							);
+					}
+					return { condition, connector };
+				});
+				if (conditions.length === 1) {
+					return conditions[0]!.condition;
+				}
+				const andConditions = conditions
+					.filter((c) => c.connector === "AND")
+					.map((c) => c.condition);
+				const orConditions = conditions
+					.filter((c) => c.connector === "OR")
+					.map((c) => c.condition);
+
+				let clause = {};
+				if (andConditions.length) {
+					clause = { ...clause, $and: andConditions };
+				}
+				if (orConditions.length) {
+					clause = { ...clause, $or: orConditions };
+				}
+				return clause;
+			}
+
+			return {
+				async create({ model, data: values }) {
+					const res = await db.collection(model).insertOne(values, { session });
+					const insertedData = { _id: res.insertedId.toString(), ...values };
+					return insertedData as any;
+				},
+				async findOne({ model, where, select, join }) {
+					const matchStage = where
+						? { $match: convertWhereClause({ where, model }) }
+						: { $match: {} };
+					const pipeline: any[] = [matchStage];
+
+					if (join) {
+						for (const [joinedModel, joinConfig] of Object.entries(join)) {
+							const localField = getFieldName({
+								field: joinConfig.on.from,
+								model,
+							});
+							const foreignField = getFieldName({
+								field: joinConfig.on.to,
+								model: joinedModel,
+							});
+
+							const localFieldName = localField === "id" ? "_id" : localField;
+							const foreignFieldName =
+								foreignField === "id" ? "_id" : foreignField;
+
+							// Only unwind if the foreign field has a unique constraint (one-to-one relationship)
+							const joinedModelSchema =
+								schema[getDefaultModelName(joinedModel)];
+							const foreignFieldAttribute =
+								joinedModelSchema?.fields[joinConfig.on.to];
+							const isUnique = foreignFieldAttribute?.unique === true;
+
+							// For unique relationships, limit is ignored (as per JoinConfig type)
+							// For non-unique relationships, apply limit if specified
+							const shouldLimit = !isUnique && joinConfig.limit !== undefined;
+							const limit =
+								joinConfig.limit ??
+								options.advanced?.database?.defaultFindManyLimit ??
+								100;
+							if (shouldLimit && limit > 0) {
+								// Use pipeline syntax to support limit
+								// Construct the field reference string for the foreign field
+								const foreignFieldRef = `$${foreignFieldName}`;
+								pipeline.push({
+									$lookup: {
+										from: joinedModel,
+										let: { localFieldValue: `$${localFieldName}` },
+										pipeline: [
+											{
+												$match: {
+													$expr: {
+														$eq: [foreignFieldRef, "$$localFieldValue"],
+													},
+												},
+											},
+											{ $limit: limit },
+										],
+										as: joinedModel,
+									},
+								});
+							} else {
+								// Use simple syntax when no limit is needed
+								pipeline.push({
+									$lookup: {
+										from: joinedModel,
+										localField: localFieldName,
+										foreignField: foreignFieldName,
+										as: joinedModel,
+									},
+								});
+							}
+
+							if (isUnique) {
+								// For one-to-one relationships, unwind to flatten to a single object
+								pipeline.push({
+									$unwind: {
+										path: `$${joinedModel}`,
+										preserveNullAndEmptyArrays: true,
+									},
+								});
+							}
+							// For one-to-many, keep as array - no unwind
+						}
+					}
+
+					if (select) {
+						const projection: any = {};
+						select.forEach((field) => {
+							projection[getFieldName({ field, model })] = 1;
+						});
+
+						// Include joined collections in projection
+						if (join) {
+							for (const joinedModel of Object.keys(join)) {
+								projection[joinedModel] = 1;
+							}
+						}
+
+						pipeline.push({ $project: projection });
+					}
+
+					pipeline.push({ $limit: 1 });
+
+					const res = await db
+						.collection(model)
+						.aggregate(pipeline, { session })
+						.toArray();
+
+					if (!res || res.length === 0) return null;
+					return res[0] as any;
+				},
+				async findMany({ model, where, limit, offset, sortBy, join }) {
+					const matchStage = where
+						? { $match: convertWhereClause({ where, model }) }
+						: { $match: {} };
+					const pipeline: any[] = [matchStage];
+
+					if (join) {
+						for (const [joinedModel, joinConfig] of Object.entries(join)) {
+							const localField = getFieldName({
+								field: joinConfig.on.from,
+								model,
+							});
+							const foreignField = getFieldName({
+								field: joinConfig.on.to,
+								model: joinedModel,
+							});
+
+							const localFieldName = localField === "id" ? "_id" : localField;
+							const foreignFieldName =
+								foreignField === "id" ? "_id" : foreignField;
+
+							// Only unwind if the foreign field has a unique constraint (one-to-one relationship)
+							const foreignFieldAttribute = getFieldAttributes({
+								model: joinedModel,
+								field: joinConfig.on.to,
+							});
+							const isUnique = foreignFieldAttribute?.unique === true;
+
+							// For unique relationships, limit is ignored (as per JoinConfig type)
+							// For non-unique relationships, apply limit if specified
+							const shouldLimit =
+								joinConfig.relation !== "one-to-one" &&
+								joinConfig.limit !== undefined;
+
+							const limit =
+								joinConfig.limit ??
+								options.advanced?.database?.defaultFindManyLimit ??
+								100;
+							if (shouldLimit && limit > 0) {
+								// Use pipeline syntax to support limit
+								// Construct the field reference string for the foreign field
+								const foreignFieldRef = `$${foreignFieldName}`;
+								pipeline.push({
+									$lookup: {
+										from: joinedModel,
+										let: { localFieldValue: `$${localFieldName}` },
+										pipeline: [
+											{
+												$match: {
+													$expr: {
+														$eq: [foreignFieldRef, "$$localFieldValue"],
+													},
+												},
+											},
+											{ $limit: limit },
+										],
+										as: joinedModel,
+									},
+								});
+							} else {
+								// Use simple syntax when no limit is needed
+								pipeline.push({
+									$lookup: {
+										from: joinedModel,
+										localField: localFieldName,
+										foreignField: foreignFieldName,
+										as: joinedModel,
+									},
+								});
+							}
+
+							if (isUnique) {
+								// For one-to-one relationships, unwind to flatten to a single object
+								pipeline.push({
+									$unwind: {
+										path: `$${joinedModel}`,
+										preserveNullAndEmptyArrays: true,
+									},
+								});
+							}
+							// For one-to-many, keep as array - no unwind
+						}
+					}
+
+					if (sortBy) {
+						pipeline.push({
+							$sort: {
+								[getFieldName({ field: sortBy.field, model })]:
+									sortBy.direction === "desc" ? -1 : 1,
+							},
+						});
+					}
+
+					if (offset) {
+						pipeline.push({ $skip: offset });
+					}
+
+					if (limit) {
+						pipeline.push({ $limit: limit });
+					}
+
+					const res = await db
+						.collection(model)
+						.aggregate(pipeline, { session })
+						.toArray();
+
+					return res as any;
+				},
+				async count({ model, where }) {
+					const matchStage = where
+						? { $match: convertWhereClause({ where, model }) }
+						: { $match: {} };
+					const pipeline: any[] = [matchStage, { $count: "total" }];
+
+					const res = await db
+						.collection(model)
+						.aggregate(pipeline, { session })
+						.toArray();
+
+					if (!res || res.length === 0) return 0;
+					return res[0]?.total ?? 0;
+				},
+				async update({ model, where, update: values }) {
+					const clause = convertWhereClause({ where, model });
+
+					const res = await db.collection(model).findOneAndUpdate(
+						clause,
+						{ $set: values as any },
+						{
+							session,
+							returnDocument: "after",
+							includeResultMetadata: true,
+						},
+					);
+					const doc = (res as any)?.value ?? null;
+					if (!doc) return null;
+					return doc as any;
+				},
+				async updateMany({ model, where, update: values }) {
+					const clause = convertWhereClause({ where, model });
+
+					const res = await db.collection(model).updateMany(
+						clause,
+						{
+							$set: values as any,
+						},
+						{ session },
+					);
+					return res.modifiedCount;
+				},
+				async delete({ model, where }) {
+					const clause = convertWhereClause({ where, model });
+					await db.collection(model).deleteOne(clause, { session });
+				},
+				async deleteMany({ model, where }) {
+					const clause = convertWhereClause({ where, model });
+					const res = await db
+						.collection(model)
+						.deleteMany(clause, { session });
+					return res.deletedCount;
+				},
+			};
+		};
+
+	let lazyAdapter:
+		| ((options: BetterAuthOptions) => DBAdapter<BetterAuthOptions>)
+		| null = null;
+	let adapterOptions: AdapterFactoryOptions | null = null;
+	adapterOptions = {
+		config: {
+			adapterId: "mongodb-adapter",
+			adapterName: "MongoDB Adapter",
+			usePlural: config?.usePlural ?? false,
+			debugLogs: config?.debugLogs ?? false,
+			mapKeysTransformInput: {
+				id: "_id",
+			},
+			mapKeysTransformOutput: {
+				_id: "id",
+			},
+			supportsArrays: true,
+			supportsNumericIds: false,
+			transaction:
+				config?.client && (config?.transaction ?? true)
+					? async (cb) => {
+							if (!config.client) {
+								return cb(lazyAdapter!(lazyOptions!));
+							}
+
+							const session = config.client.startSession();
+
+							try {
+								session.startTransaction();
+
+								const adapter = createAdapterFactory({
+									config: adapterOptions!.config,
+									adapter: createCustomAdapter(db, session),
+								})(lazyOptions!);
+
+								const result = await cb(adapter);
+
+								await session.commitTransaction();
+								return result;
+							} catch (err) {
+								await session.abortTransaction();
+								throw err;
+							} finally {
+								await session.endSession();
+							}
+						}
+					: false,
+			customTransformInput({
+				action,
+				data,
+				field,
+				fieldAttributes,
+				schema,
+				model,
+				options,
+			}) {
+				const customIdGen = getCustomIdGenerator(options);
+				if (field === "_id" || fieldAttributes.references?.field === "id") {
+					if (customIdGen) {
+						return data;
+					}
+					if (action !== "create") {
+						return data;
+					}
+					if (Array.isArray(data)) {
+						return data.map((v) => {
+							if (typeof v === "string") {
+								try {
+									const oid = new ObjectId(v);
+									return oid;
+								} catch {
+									return v;
+								}
+							}
+							return v;
+						});
+					}
+					if (typeof data === "string") {
+						try {
+							const oid = new ObjectId(data);
+							return oid;
+						} catch {
+							return data;
+						}
+					}
+					if (
+						fieldAttributes?.references?.field === "id" &&
+						!fieldAttributes?.required &&
+						data === null
+					) {
+						return null;
+					}
+					const oid = new ObjectId();
+					return oid;
+				}
+				return data;
+			},
+			customTransformOutput({ data, field, fieldAttributes }) {
+				if (field === "id" || fieldAttributes.references?.field === "id") {
+					if (data instanceof ObjectId) {
+						return data.toHexString();
+					}
+					if (Array.isArray(data)) {
+						return data.map((v) => {
+							if (v instanceof ObjectId) {
+								return v.toHexString();
+							}
+							return v;
+						});
+					}
+					return data;
+				}
+				return data;
+			},
+			customIdGenerator() {
+				return new ObjectId().toString();
+			},
+		},
+		adapter: createCustomAdapter(db),
+	};
+	lazyAdapter = createAdapterFactory(adapterOptions);
+
+	return (options: BetterAuthOptions): DBAdapter<BetterAuthOptions> => {
+		lazyOptions = options;
+		return lazyAdapter(options);
+	};
+};
+
+/**
+ * Safely escape user input for use in a MongoDB regex.
+ * This ensures the resulting pattern is treated as literal text,
+ * and not as a regex with special syntax.
+ *
+ * @param input - The input string to escape. Any type that isn't a string will be converted to an empty string.
+ * @param maxLength - The maximum length of the input string to escape. Defaults to 256. This is to prevent DOS attacks.
+ * @returns The escaped string.
+ */
+function escapeForMongoRegex(input: string, maxLength = 256): string {
+	if (typeof input !== "string") return "";
+
+	// Escape all PCRE special characters
+	// Source: PCRE docs — https://www.pcre.org/original/doc/html/pcrepattern.html
+	return input.slice(0, maxLength).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["./src"],
+  "references": [
+    {
+      "path": "../core/tsconfig.json"
+    }
+  ]
+}

package/tsdown.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+	dts: { build: true, incremental: true },
+	format: ["esm"],
+	entry: ["./src/index.ts"],
+});

package/vitest.config.ts

@@ -0,0 +1,3 @@
+import { defineProject } from "vitest/config";
+
+export default defineProject({});