@better-auth/drizzle-adapter 1.7.0-beta.1 → 1.7.0-beta.10

package/dist/generate-drizzle-schema-BdVT4xKv.mjs

@@ -0,0 +1,311 @@
+import { initGetFieldName, initGetModelName } from "@better-auth/core/db/adapter";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { getAuthTables } from "@better-auth/core/db";
+//#region src/relations-v2/generate-drizzle-schema.ts
+function convertToSnakeCase(str, camelCase) {
+	if (camelCase) return str;
+	return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").toLowerCase();
+}
+const generateDrizzleSchema = async ({ options, file, provider, adapterConfig, camelCase, tables: propsTables }) => {
+	const tables = propsTables ?? getAuthTables(options);
+	const filePath = file || "./auth-schema.ts";
+	const databaseType = provider;
+	if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
+	const fileExist = existsSync(filePath);
+	let code = generateImport({
+		databaseType,
+		tables,
+		options
+	});
+	const getModelName = initGetModelName({
+		schema: tables,
+		usePlural: adapterConfig?.usePlural
+	});
+	const getSingularModelName = initGetModelName({
+		schema: tables,
+		usePlural: false
+	});
+	const getFieldName = initGetFieldName({
+		schema: tables,
+		usePlural: adapterConfig?.usePlural
+	});
+	for (const tableKey in tables) {
+		const table = tables[tableKey];
+		const modelName = getModelName(tableKey);
+		const fields = table.fields;
+		function getType(name, field) {
+			if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
+			name = convertToSnakeCase(name, camelCase);
+			if (field.references?.field === "id") {
+				const useNumberId = options.advanced?.database?.generateId === "serial";
+				const useUUIDs = options.advanced?.database?.generateId === "uuid";
+				if (useNumberId) if (databaseType === "pg") return `integer('${name}')`;
+				else if (databaseType === "mysql") return `int('${name}')`;
+				else return `integer('${name}')`;
+				if (useUUIDs && databaseType === "pg") return `uuid('${name}')`;
+				if (field.references.field) {
+					if (databaseType === "mysql") return `varchar('${name}', { length: 36 })`;
+				}
+				return `text('${name}')`;
+			}
+			const type = field.type;
+			if (typeof type !== "string") if (Array.isArray(type) && type.every((x) => typeof x === "string")) return {
+				sqlite: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
+				pg: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
+				mysql: `mysqlEnum('${name}', [${type.map((x) => `'${x}'`).join(", ")}])`
+			}[databaseType];
+			else throw new TypeError(`Invalid field type for field ${name} in model ${modelName}`);
+			const dbTypeMap = {
+				string: {
+					sqlite: `text('${name}')`,
+					pg: `text('${name}')`,
+					mysql: field.unique ? `varchar('${name}', { length: 255 })` : field.references ? `varchar('${name}', { length: 36 })` : field.sortable ? `varchar('${name}', { length: 255 })` : field.index ? `varchar('${name}', { length: 255 })` : `text('${name}')`
+				},
+				boolean: {
+					sqlite: `integer('${name}', { mode: 'boolean' })`,
+					pg: `boolean('${name}')`,
+					mysql: `boolean('${name}')`
+				},
+				number: {
+					sqlite: `integer('${name}')`,
+					pg: field.bigint ? `bigint('${name}', { mode: 'number' })` : `integer('${name}')`,
+					mysql: field.bigint ? `bigint('${name}', { mode: 'number' })` : `int('${name}')`
+				},
+				date: {
+					sqlite: `integer('${name}', { mode: 'timestamp_ms' })`,
+					pg: `timestamp('${name}')`,
+					mysql: `timestamp('${name}', { fsp: 3 })`
+				},
+				"number[]": {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: field.bigint ? `bigint('${name}', { mode: 'number' }).array()` : `integer('${name}').array()`,
+					mysql: `json('${name}')`
+				},
+				"string[]": {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: `text('${name}').array()`,
+					mysql: `json('${name}')`
+				},
+				json: {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: `jsonb('${name}')`,
+					mysql: `json('${name}')`
+				}
+			}[type];
+			if (!dbTypeMap) throw new Error(`Unsupported field type '${field.type}' for field '${name}'.`);
+			return dbTypeMap[databaseType];
+		}
+		let id = "";
+		const useNumberId = options.advanced?.database?.generateId === "serial";
+		if (options.advanced?.database?.generateId === "uuid" && databaseType === "pg") id = `uuid("id").default(sql\`pg_catalog.gen_random_uuid()\`).primaryKey()`;
+		else if (useNumberId) if (databaseType === "pg") id = `integer("id").generatedByDefaultAsIdentity().primaryKey()`;
+		else if (databaseType === "sqlite") id = `integer("id", { mode: "number" }).primaryKey({ autoIncrement: true })`;
+		else id = `int("id").autoincrement().primaryKey()`;
+		else if (databaseType === "mysql") id = `varchar('id', { length: 36 }).primaryKey()`;
+		else if (databaseType === "pg") id = `text('id').primaryKey()`;
+		else id = `text('id').primaryKey()`;
+		const indexes = [];
+		const assignIndexes = (indexes) => {
+			if (!indexes.length) return "";
+			const code = [`, (table) => [`];
+			for (const index of indexes) code.push(`  ${index.type}("${index.name}").on(table.${index.on}),`);
+			code.push(`]`);
+			return code.join("\n");
+		};
+		const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, camelCase)}", {
+					id: ${id},
+					${Object.keys(fields).map((field) => {
+			const attr = fields[field];
+			const fieldName = attr.fieldName || field;
+			let type = getType(fieldName, attr);
+			if (attr.index && !attr.unique) indexes.push({
+				type: "index",
+				name: `${modelName}_${fieldName}_idx`,
+				on: fieldName
+			});
+			else if (attr.index && attr.unique) indexes.push({
+				type: "uniqueIndex",
+				name: `${modelName}_${fieldName}_uidx`,
+				on: fieldName
+			});
+			if (attr.defaultValue !== null && typeof attr.defaultValue !== "undefined") if (typeof attr.defaultValue === "function") {
+				if (attr.type === "date" && attr.defaultValue.toString().includes("new Date()")) if (databaseType === "sqlite") type += `.default(sql\`(cast(unixepoch('subsecond') * 1000 as integer))\`)`;
+				else type += `.defaultNow()`;
+			} else if (typeof attr.defaultValue === "string") type += `.default(${JSON.stringify(attr.defaultValue)})`;
+			else if (Array.isArray(attr.defaultValue)) {
+				const elements = attr.defaultValue.map((value) => JSON.stringify(value)).join(", ");
+				type += `.default([${elements}])`;
+			} else if (typeof attr.defaultValue === "object" && attr.defaultValue !== null) type += `.default(${JSON.stringify(attr.defaultValue)})`;
+			else type += `.default(${attr.defaultValue})`;
+			if (attr.onUpdate && attr.type === "date") {
+				if (typeof attr.onUpdate === "function") type += `.$onUpdate(${attr.onUpdate})`;
+			}
+			return `${fieldName}: ${type}${attr.required ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${attr.references ? `.references(()=> ${getModelName(attr.references.model)}.${getFieldName({
+				model: attr.references.model,
+				field: attr.references.field
+			})}, { onDelete: '${attr.references.onDelete || "cascade"}' })` : ""}`;
+		}).join(",\n ")}
+					}${assignIndexes(indexes)});`;
+		code += `\n${schema}\n`;
+	}
+	const schemaObjectKeys = [];
+	for (const tableKey in tables) {
+		const modelName = getModelName(tableKey);
+		schemaObjectKeys.push(modelName);
+	}
+	const schemaObject = `{ ${schemaObjectKeys.join(", ")} }`;
+	const relationsMap = /* @__PURE__ */ new Map();
+	for (const tableKey in tables) {
+		const table = tables[tableKey];
+		const modelName = getModelName(tableKey);
+		const modelRelations = [];
+		const foreignFields = Object.entries(table.fields).filter(([_, field]) => field.references);
+		for (const [fieldName, field] of foreignFields) {
+			const referencedModel = field.references.model;
+			const targetModelName = getModelName(referencedModel);
+			const fromField = getFieldName({
+				model: tableKey,
+				field: fieldName
+			});
+			const toField = getFieldName({
+				model: referencedModel,
+				field: field.references.field || "id"
+			});
+			const existingToSameModel = modelRelations.filter((r) => r.targetModel === targetModelName && r.type === "one");
+			const singularName = getSingularModelName(referencedModel);
+			const relationKey = existingToSameModel.length > 0 ? `${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}${singularName.charAt(0).toUpperCase() + singularName.slice(1)}` : singularName;
+			modelRelations.push({
+				key: relationKey,
+				type: "one",
+				targetModel: targetModelName,
+				fromField,
+				toField,
+				sourceModel: modelName
+			});
+		}
+		const otherModels = Object.entries(tables).filter(([modelName]) => modelName !== tableKey);
+		for (const [otherTableKey, otherTable] of otherModels) {
+			const foreignKeysPointingHere = Object.entries(otherTable.fields).filter(([_, field]) => field.references?.model === tableKey || field.references?.model === modelName);
+			if (foreignKeysPointingHere.length === 0) continue;
+			const otherModelName = getModelName(otherTableKey);
+			if (foreignKeysPointingHere.some(([_, field]) => !field.unique)) {
+				const nonUniqueFKs = foreignKeysPointingHere.filter(([_, field]) => !field.unique);
+				for (let i = 0; i < nonUniqueFKs.length; i++) {
+					const fkField = nonUniqueFKs[i];
+					if (!fkField) continue;
+					const [fkFieldName, fkFieldAttr] = fkField;
+					const fromField = getFieldName({
+						model: tableKey,
+						field: fkFieldAttr.references?.field || "id"
+					});
+					const toField = getFieldName({
+						model: otherTableKey,
+						field: fkFieldName
+					});
+					let relationKey = otherModelName;
+					if (!adapterConfig?.usePlural) relationKey = otherModelName.endsWith("s") ? otherModelName : `${otherModelName}s`;
+					if (nonUniqueFKs.length > 1) {
+						const capitalizedField = fkFieldName.charAt(0).toUpperCase() + fkFieldName.slice(1);
+						relationKey = `${relationKey}By${capitalizedField}`;
+					}
+					modelRelations.push({
+						key: relationKey,
+						type: "many",
+						targetModel: otherModelName,
+						fromField,
+						toField,
+						sourceModel: modelName
+					});
+				}
+			} else {
+				const fkField = foreignKeysPointingHere.find(([_, field]) => field.unique);
+				if (fkField) {
+					const [fkFieldName, fieldAttr] = fkField;
+					const fromField = getFieldName({
+						model: tableKey,
+						field: fieldAttr.references?.field || "id"
+					});
+					const toField = getFieldName({
+						model: otherTableKey,
+						field: fkFieldName
+					});
+					const relationKey = otherModelName;
+					modelRelations.push({
+						key: relationKey,
+						type: "one",
+						targetModel: otherModelName,
+						fromField,
+						toField,
+						sourceModel: modelName
+					});
+				}
+			}
+		}
+		if (modelRelations.length > 0) relationsMap.set(modelName, modelRelations);
+	}
+	let relationsString = "";
+	if (relationsMap.size > 0) {
+		const relationsEntries = [];
+		for (const [modelName, relations] of relationsMap.entries()) {
+			const relationDefs = [];
+			for (const relation of relations) if (relation.type === "one") relationDefs.push(`    ${relation.key}: r.one.${relation.targetModel}({\n      from: r.${relation.sourceModel}.${relation.fromField},\n      to: r.${relation.targetModel}.${relation.toField},\n    })`);
+			else relationDefs.push(`    ${relation.key}: r.many.${relation.targetModel}({\n      from: r.${relation.sourceModel}.${relation.fromField},\n      to: r.${relation.targetModel}.${relation.toField},\n    })`);
+			if (relationDefs.length > 0) relationsEntries.push(`  ${modelName}: {\n${relationDefs.join(",\n")}\n  }`);
+		}
+		if (relationsEntries.length > 0) relationsString = `\n\nexport const authRelations = defineRelationsPart(${schemaObject}, (r) => ({\n${relationsEntries.join(",\n")}\n}));\n`;
+	}
+	code += relationsString;
+	let formattedCode = code;
+	try {
+		const { format } = await new Function("moduleName", "return import(moduleName);")("prettier");
+		formattedCode = await format(code, { parser: "typescript" });
+	} catch {}
+	return {
+		code: formattedCode,
+		fileName: path.basename(filePath),
+		overwrite: fileExist,
+		path: filePath,
+		append: false
+	};
+};
+function generateImport({ databaseType, tables, options }) {
+	const rootImports = ["defineRelationsPart"];
+	const coreImports = [];
+	let hasBigint = false;
+	let hasJson = false;
+	for (const table of Object.values(tables)) {
+		for (const field of Object.values(table.fields)) {
+			if (field.bigint) hasBigint = true;
+			if (field.type === "json" || databaseType === "mysql" && (field.type === "number[]" || field.type === "string[]")) hasJson = true;
+		}
+		if (hasJson && hasBigint) break;
+	}
+	const useNumberId = options.advanced?.database?.generateId === "serial";
+	const useUUIDs = options.advanced?.database?.generateId === "uuid";
+	coreImports.push(`${databaseType}Table`);
+	coreImports.push(databaseType === "mysql" ? "varchar, text" : databaseType === "pg" ? "text" : "text");
+	coreImports.push(hasBigint ? databaseType !== "sqlite" ? "bigint" : "" : "");
+	coreImports.push(databaseType !== "sqlite" ? "timestamp, boolean" : "");
+	if (databaseType === "mysql") {
+		const hasNonBigintNumber = Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint));
+		if (!!useNumberId || hasNonBigintNumber) coreImports.push("int");
+		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => typeof field.type !== "string" && Array.isArray(field.type) && field.type.every((x) => typeof x === "string")))) coreImports.push("mysqlEnum");
+	} else if (databaseType === "pg") {
+		if (useUUIDs) rootImports.push("sql");
+		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint)) || options.advanced?.database?.generateId === "serial") coreImports.push("integer");
+	} else coreImports.push("integer");
+	if (databaseType === "pg" && useUUIDs) coreImports.push("uuid");
+	if (hasJson) {
+		if (databaseType === "pg") coreImports.push("jsonb");
+		if (databaseType === "mysql") coreImports.push("json");
+	}
+	if (databaseType === "sqlite" && Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.type === "date" && field.defaultValue && typeof field.defaultValue === "function" && field.defaultValue.toString().includes("new Date()")))) rootImports.push("sql");
+	const hasIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.index && !field.unique));
+	const hasUniqueIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.unique && field.index));
+	if (hasIndexes) coreImports.push("index");
+	if (hasUniqueIndexes) coreImports.push("uniqueIndex");
+	return `${rootImports.length > 0 ? `import { ${rootImports.join(", ")} } from "drizzle-orm";\n` : ""}import { ${coreImports.map((x) => x.trim()).filter((x) => x !== "").join(", ")} } from "drizzle-orm/${databaseType}-core";\n`;
+}
+//#endregion
+export { generateDrizzleSchema };

package/dist/index.mjs

@@ -1,46 +1,47 @@
+import { a as insensitiveNe, i as insensitiveInArray, n as insensitiveEq, o as insensitiveNotInArray, r as insensitiveIlike } from "./query-builders-D2eE7gbx.mjs";
 import { createAdapterFactory } from "@better-auth/core/db/adapter";
 import { logger } from "@better-auth/core/env";
 import { BetterAuthError } from "@better-auth/core/error";
-import { and, asc, count, desc, eq, gt, gte, ilike, inArray, isNotNull, isNull, like, lt, lte, ne, notInArray, or, sql } from "drizzle-orm";
-//#region src/query-builders.ts
-/**
-* Case-insensitive LIKE/ILIKE for pattern matching.
-* Uses ILIKE on PostgreSQL, LOWER()+LIKE on MySQL/SQLite.
-*/
-function insensitiveIlike(column, pattern, provider) {
-	return provider === "pg" ? ilike(column, pattern) : sql`LOWER(${column}) LIKE LOWER(${pattern})`;
-}
-/**
-* Case-insensitive IN for string arrays.
-*/
-function insensitiveInArray(column, values) {
-	if (values.length === 0) return sql`false`;
-	return sql`LOWER(${column}) IN (${sql.join(values.map((v) => sql`LOWER(${v})`), sql`, `)})`;
-}
+import { and, asc, count, desc, eq, gt, gte, inArray, isNotNull, isNull, like, lt, lte, ne, notInArray, or, sql } from "drizzle-orm";
+//#region src/drizzle-adapter.ts
 /**
-* Case-insensitive NOT IN for string arrays.
+* Derive the number of affected rows from a Drizzle write result.
+*
+* Drizzle's drivers report affected rows under different shapes: postgres-js
+* exposes `rowCount`, mysql2 reports `affectedRows`/`rowsAffected` (sometimes as
+* the first element of a result-header array), and better-sqlite3 uses
+* `changes`. This normalizes those so write methods that depend on affected
+* rows honor the adapter contract instead of leaking the raw driver result.
 */
-function insensitiveNotInArray(column, values) {
-	if (values.length === 0) return sql`true`;
-	return sql`LOWER(${column}) NOT IN (${sql.join(values.map((v) => sql`LOWER(${v})`), sql`, `)})`;
+function getAffectedRowCount(result, operation, context) {
+	let count = 0;
+	if (result && typeof result === "object" && "rowCount" in result) count = result.rowCount;
+	else if (Array.isArray(result)) count = result.length > 0 && hasDriverRowCount(result[0]) ? readDriverRowCount(result[0]) : result.length;
+	else if (hasDriverRowCount(result)) count = readDriverRowCount(result);
+	if (typeof count !== "number" || !Number.isFinite(count)) {
+		logger.error(`[Drizzle Adapter] The result of the ${operation} operation is not a finite number. This is likely a bug in the adapter. Please report this issue to the Better Auth team.`, {
+			result,
+			...context
+		});
+		throw new BetterAuthError(`Drizzle adapter ${operation} returned an invalid affected row count`);
+	}
+	return count;
 }
-/**
-* Case-insensitive equality for strings.
-*/
-function insensitiveEq(column, value) {
-	return sql`LOWER(${column}) = LOWER(${value})`;
+function hasDriverRowCount(result) {
+	return !!result && typeof result === "object" && ("affectedRows" in result || "rowsAffected" in result || "changes" in result);
 }
-/**
-* Case-insensitive inequality for strings.
-*/
-function insensitiveNe(column, value) {
-	return sql`LOWER(${column}) <> LOWER(${value})`;
+function readDriverRowCount(result) {
+	const r = result;
+	return r.affectedRows ?? r.rowsAffected ?? r.changes;
 }
-//#endregion
-//#region src/drizzle-adapter.ts
 const drizzleAdapter = (db, config) => {
 	let lazyOptions = null;
-	const createCustomAdapter = (db) => ({ getFieldName, getDefaultFieldName, options }) => {
+	let mysqlNoIdWarned = false;
+	const createCustomAdapter = (db, inTransaction = false) => ({ getFieldName, getDefaultFieldName, getDefaultModelName, options, schema: baSchema }) => {
+		if (config.provider === "mysql" && options.advanced?.database?.generateId === false && !mysqlNoIdWarned) {
+			mysqlNoIdWarned = true;
+			logger.warn("[Drizzle Adapter] MySQL does not support INSERT...RETURNING. With generateId set to false, the adapter uses best-effort fallback strategies (unique columns, full-field match) to retrieve inserted rows. For reliable behavior, use Better Auth's default ID generation, a custom generateId function, or generateId: \"serial\" for auto-increment.");
+		}
 		function getSchema(model) {
 			const schema = config.schema || db._.fullSchema;
 			if (!schema) throw new BetterAuthError("Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object.");
@@ -62,15 +63,44 @@ const drizzleAdapter = (db, config) => {
 					return w;
 				}), model);
 				return (await db.select().from(schemaModel).where(...clause))[0];
-			} else if (builderVal && builderVal[0]?.id?.value) {
-				let tId = builderVal[0]?.id?.value;
-				if (!tId) tId = (await db.select({ id: sql`LAST_INSERT_ID()` }).from(schemaModel).orderBy(desc(schemaModel.id)).limit(1))[0].id;
-				return (await db.select().from(schemaModel).where(eq(schemaModel.id, tId)).limit(1).execute())[0];
-			} else if (data.id) return (await db.select().from(schemaModel).where(eq(schemaModel.id, data.id)).limit(1).execute())[0];
-			else {
-				if (!("id" in schemaModel)) throw new BetterAuthError(`The model "${model}" does not have an "id" field. Please use the "id" field as your primary key.`);
-				return (await db.select().from(schemaModel).orderBy(desc(schemaModel.id)).limit(1).execute())[0];
 			}
+			const fetchInserted = async (tx) => {
+				const builderId = builderVal?.[0]?.id?.value;
+				if (builderId) return (await tx.select().from(schemaModel).where(eq(schemaModel.id, builderId)).limit(1).execute())[0] ?? null;
+				if (data.id) return (await tx.select().from(schemaModel).where(eq(schemaModel.id, data.id)).limit(1).execute())[0] ?? null;
+				if (options.advanced?.database?.generateId === "serial" && schemaModel.id) {
+					const lastId = (await tx.select({ id: sql`LAST_INSERT_ID()` }).from(schemaModel).limit(1).execute())[0]?.id;
+					if (lastId) return (await tx.select().from(schemaModel).where(eq(schemaModel.id, lastId)).limit(1).execute())[0] ?? null;
+				}
+				const modelSchema = baSchema[getDefaultModelName(model)]?.fields;
+				if (modelSchema) for (const [fieldKey, fieldAttr] of Object.entries(modelSchema)) {
+					if (!fieldAttr.unique) continue;
+					const dbFieldName = getFieldName({
+						model,
+						field: fieldKey
+					});
+					const val = data[dbFieldName];
+					if (val === void 0 || val === null) continue;
+					if (!schemaModel[dbFieldName]) continue;
+					const res = await tx.select().from(schemaModel).where(eq(schemaModel[dbFieldName], val)).limit(1).execute();
+					if (res[0]) return res[0];
+				}
+				const conditions = [];
+				for (const [key, val] of Object.entries(data)) {
+					if (val === void 0 || !schemaModel[key]) continue;
+					conditions.push(val === null ? isNull(schemaModel[key]) : eq(schemaModel[key], val));
+				}
+				if (conditions.length > 0) {
+					const combined = and(...conditions);
+					if (combined) {
+						const res = await tx.select().from(schemaModel).where(combined).limit(2).execute();
+						if (res.length === 1) return res[0];
+					}
+				}
+				logger.warn(`[Drizzle Adapter] Unable to safely identify the inserted "${model}" row on MySQL. Enable Better Auth ID generation or use generateId: "serial" for reliable behavior.`);
+				return null;
+			};
+			return inTransaction ? fetchInserted(db) : db.transaction(fetchInserted);
 		};
 		function convertWhereClause(where, model) {
 			const schemaModel = getSchema(model);
@@ -204,10 +234,10 @@ const drizzleAdapter = (db, config) => {
 				if (isInsensitive && typeof w.value === "string") return insensitiveEq(schemaModel[field], w.value);
 				return eq(schemaModel[field], w.value);
 			}));
-			const clause = [];
-			if (andGroup.length) clause.push(andClause);
-			if (orGroup.length) clause.push(orClause);
-			return clause;
+			if (andGroup.length && orGroup.length) return [and(andClause, orClause)];
+			if (andGroup.length) return [andClause];
+			if (orGroup.length) return [orClause];
+			return [];
 		}
 		function checkMissingFields(schema, model, values) {
 			if (!schema) throw new BetterAuthError("Drizzle adapter failed to initialize. Drizzle Schema not found. Please provide a schema object in the adapter options object.");
@@ -397,7 +427,10 @@ const drizzleAdapter = (db, config) => {
 			async updateMany({ model, where, update: values }) {
 				const schemaModel = getSchema(model);
 				const clause = convertWhereClause(where, model);
-				return await db.update(schemaModel).set(values).where(...clause);
+				return getAffectedRowCount(await db.update(schemaModel).set(values).where(...clause), "updateMany", {
+					model,
+					where
+				});
 			},
 			async delete({ model, where }) {
 				const schemaModel = getSchema(model);
@@ -407,17 +440,76 @@ const drizzleAdapter = (db, config) => {
 			async deleteMany({ model, where }) {
 				const schemaModel = getSchema(model);
 				const clause = convertWhereClause(where, model);
-				const res = await db.delete(schemaModel).where(...clause);
-				let count = 0;
-				if (res && "rowCount" in res) count = res.rowCount;
-				else if (Array.isArray(res)) count = res.length;
-				else if (res && ("affectedRows" in res || "rowsAffected" in res || "changes" in res)) count = res.affectedRows ?? res.rowsAffected ?? res.changes;
-				if (typeof count !== "number") logger.error("[Drizzle Adapter] The result of the deleteMany operation is not a number. This is likely a bug in the adapter. Please report this issue to the Better Auth team.", {
-					res,
+				return getAffectedRowCount(await db.delete(schemaModel).where(...clause), "deleteMany", {
 					model,
 					where
 				});
-				return count;
+			},
+			async consumeOne({ model, where }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				const idField = getFieldName({
+					model,
+					field: "id"
+				});
+				const idColumn = schemaModel[idField];
+				if (config.provider === "mysql") {
+					const claimFromTransaction = async (tx) => {
+						const target = (await tx.select().from(schemaModel).where(...clause).for("update").limit(1))[0];
+						if (!target) return null;
+						const targetId = target[idField] ?? target.id;
+						if (targetId === void 0 || targetId === null || !idColumn) return null;
+						return getAffectedRowCount(await tx.delete(schemaModel).where(eq(idColumn, targetId)).execute(), "consumeOne", {
+							model,
+							where
+						}) > 0 ? target : null;
+					};
+					return inTransaction ? claimFromTransaction(db) : db.transaction(claimFromTransaction);
+				}
+				if (!idColumn) return null;
+				const targetIds = db.select({ id: idColumn }).from(schemaModel).where(...clause).limit(1);
+				return (await db.delete(schemaModel).where(inArray(idColumn, targetIds)).returning())[0] ?? null;
+			},
+			async incrementOne({ model, where, increment, set }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				const idField = getFieldName({
+					model,
+					field: "id"
+				});
+				const idColumn = schemaModel[idField];
+				const assignments = {};
+				for (const [field, delta] of Object.entries(increment)) {
+					const columnName = getFieldName({
+						model,
+						field
+					});
+					const column = schemaModel[columnName];
+					if (!column) throw new BetterAuthError(`The field "${field}" does not exist in the schema for the model "${model}". Please update your schema.`);
+					assignments[columnName] = sql`${column} + ${sql.param(delta)}`;
+				}
+				if (set) for (const [field, value] of Object.entries(set)) {
+					const columnName = getFieldName({
+						model,
+						field
+					});
+					if (!schemaModel[columnName]) throw new BetterAuthError(`The field "${field}" does not exist in the schema for the model "${model}". Please update your schema.`);
+					assignments[columnName] = value;
+				}
+				if (config.provider === "mysql") {
+					const mutateInTransaction = async (tx) => {
+						const target = (await tx.select().from(schemaModel).where(...clause).for("update").limit(1))[0];
+						if (!target) return null;
+						const targetId = target[idField] ?? target.id;
+						if (targetId === void 0 || targetId === null || !idColumn) return null;
+						await tx.update(schemaModel).set(assignments).where(eq(idColumn, targetId)).execute();
+						return (await tx.select().from(schemaModel).where(eq(idColumn, targetId)).limit(1).execute())[0] ?? null;
+					};
+					return inTransaction ? mutateInTransaction(db) : db.transaction(mutateInTransaction);
+				}
+				if (!idColumn) return null;
+				const targetIds = db.select({ id: idColumn }).from(schemaModel).where(...clause).limit(1);
+				return (await db.update(schemaModel).set(assignments).where(inArray(idColumn, targetIds)).returning())[0] ?? null;
 			},
 			options: config
 		};
@@ -441,8 +533,11 @@ const drizzleAdapter = (db, config) => {
 			},
 			transaction: config.transaction ?? false ? (cb) => db.transaction((tx) => {
 				return cb(createAdapterFactory({
-					config: adapterOptions.config,
-					adapter: createCustomAdapter(tx)
+					config: {
+						...adapterOptions.config,
+						transaction: false
+					},
+					adapter: createCustomAdapter(tx, true)
 				})(lazyOptions));
 			}) : false
 		},

package/dist/query-builders-D2eE7gbx.mjs

@@ -0,0 +1,52 @@
+import { ilike, sql } from "drizzle-orm";
+//#region src/query-builders.ts
+/**
+* Case-insensitive LIKE/ILIKE for pattern matching.
+* Uses ILIKE on PostgreSQL, LOWER()+LIKE on MySQL/SQLite.
+*/
+function insensitiveIlike(column, pattern, provider) {
+	return provider === "pg" ? ilike(column, pattern) : sql`LOWER(${column}) LIKE LOWER(${pattern})`;
+}
+/**
+* LIKE/ILIKE with an explicit backslash escape character so callers can match a
+* literal `%` or `_`. SQLite has no default LIKE escape, so the ESCAPE clause is
+* always supplied. The escape character is passed as a bound parameter.
+*
+* This does not support MySQL's `NO_BACKSLASH_ESCAPES` sql_mode, under which the
+* bound backslash is rejected as a two-character ESCAPE argument.
+*
+* @see https://www.sqlite.org/lang_expr.html
+*/
+function escapedLike(column, pattern, provider, mode = "sensitive") {
+	const escape = "\\";
+	if (mode === "insensitive") return provider === "pg" ? sql`${column} ILIKE ${pattern} ESCAPE ${escape}` : sql`LOWER(${column}) LIKE LOWER(${pattern}) ESCAPE ${escape}`;
+	return sql`${column} LIKE ${pattern} ESCAPE ${escape}`;
+}
+/**
+* Case-insensitive IN for string arrays.
+*/
+function insensitiveInArray(column, values) {
+	if (values.length === 0) return sql`false`;
+	return sql`LOWER(${column}) IN (${sql.join(values.map((v) => sql`LOWER(${v})`), sql`, `)})`;
+}
+/**
+* Case-insensitive NOT IN for string arrays.
+*/
+function insensitiveNotInArray(column, values) {
+	if (values.length === 0) return sql`true`;
+	return sql`LOWER(${column}) NOT IN (${sql.join(values.map((v) => sql`LOWER(${v})`), sql`, `)})`;
+}
+/**
+* Case-insensitive equality for strings.
+*/
+function insensitiveEq(column, value) {
+	return sql`LOWER(${column}) = LOWER(${value})`;
+}
+/**
+* Case-insensitive inequality for strings.
+*/
+function insensitiveNe(column, value) {
+	return sql`LOWER(${column}) <> LOWER(${value})`;
+}
+//#endregion
+export { insensitiveNe as a, insensitiveInArray as i, insensitiveEq as n, insensitiveNotInArray as o, insensitiveIlike as r, escapedLike as t };

package/dist/relations-v2/index.d.mts

@@ -0,0 +1,47 @@
+import { DBAdapter, DBAdapterDebugLogOption } from "@better-auth/core/db/adapter";
+import { BetterAuthOptions } from "@better-auth/core";
+
+//#region src/relations-v2/index.d.ts
+interface DB {
+  [key: string]: any;
+}
+interface DrizzleAdapterConfig {
+  /**
+   * The schema object that defines the tables and fields
+   */
+  schema?: Record<string, any> | undefined;
+  /**
+   * The database provider
+   */
+  provider: "pg" | "mysql" | "sqlite";
+  /**
+   * If the table names in the schema are plural
+   * set this to true. For example, if the schema
+   * has an object with a key "users" instead of "user"
+   */
+  usePlural?: boolean | undefined;
+  /**
+   * Enable debug logs for the adapter
+   *
+   * @default false
+   */
+  debugLogs?: DBAdapterDebugLogOption | undefined;
+  /**
+   * By default snake case is used for table and field names
+   * when the CLI is used to generate the schema. If you want
+   * to use camel case, set this to true.
+   * @default false
+   */
+  camelCase?: boolean | undefined;
+  /**
+   * Whether to execute multiple operations in a transaction.
+   *
+   * If the database doesn't support transactions,
+   * set this to `false` and operations will be executed sequentially.
+   * @default false
+   */
+  transaction?: boolean | undefined;
+}
+declare const drizzleAdapter: (db: DB, config: DrizzleAdapterConfig) => (options: BetterAuthOptions) => DBAdapter<BetterAuthOptions>;
+//#endregion
+export { DB, DrizzleAdapterConfig, drizzleAdapter };

package/dist/relations-v2/index.mjs

@@ -0,0 +1,554 @@
+import { a as insensitiveNe, i as insensitiveInArray, n as insensitiveEq, o as insensitiveNotInArray, t as escapedLike } from "../query-builders-D2eE7gbx.mjs";
+import { createAdapterFactory } from "@better-auth/core/db/adapter";
+import { logger } from "@better-auth/core/env";
+import { BetterAuthError } from "@better-auth/core/error";
+import { and, asc, count, desc, eq, gt, gte, inArray, isNotNull, isNull, lt, lte, ne, notInArray, or, sql } from "drizzle-orm";
+//#region src/relations-v2/index.ts
+function escapeLikePattern(value) {
+	if (value == null) return "";
+	return String(value).replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+function readDriverRowCount(result) {
+	if (!result || typeof result !== "object") return void 0;
+	if ("affectedRows" in result) return result.affectedRows;
+	if ("rowsAffected" in result) return result.rowsAffected;
+	if ("changes" in result) return result.changes;
+	if ("meta" in result) {
+		const meta = result.meta;
+		if (meta && typeof meta === "object" && "changes" in meta) return meta.changes;
+	}
+}
+function hasDriverRowCount(result) {
+	return readDriverRowCount(result) !== void 0;
+}
+function getAffectedRowCount(result, operation, context) {
+	let count = 0;
+	if (result && typeof result === "object" && "rowCount" in result) count = result.rowCount;
+	else if (result && typeof result === "object" && typeof result.count === "number") count = result.count;
+	else if (Array.isArray(result)) count = result.length > 0 && hasDriverRowCount(result[0]) ? readDriverRowCount(result[0]) : result.length;
+	else if (hasDriverRowCount(result)) count = readDriverRowCount(result);
+	if (typeof count !== "number" || !Number.isFinite(count)) {
+		logger.error(`[Drizzle Adapter] The result of the ${operation} operation is not a finite number. This is likely a bug in the adapter. Please report this issue to the Better Auth team.`, {
+			result,
+			...context
+		});
+		throw new BetterAuthError(`Drizzle adapter ${operation} returned an invalid affected row count`);
+	}
+	return count;
+}
+/**
+* Maps a single Where entry to a drizzle SQL expression.
+* Shared by convertWhereClause across single / AND / OR branches.
+*/
+function applyWhereOperator(column, w, fieldLabel, provider) {
+	const isInsensitive = (w.mode ?? "sensitive") === "insensitive" && (typeof w.value === "string" || Array.isArray(w.value) && w.value.every((v) => typeof v === "string"));
+	if (w.operator === "in") {
+		if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${fieldLabel}" must be an array when using the "in" operator.`);
+		if (isInsensitive) return insensitiveInArray(column, w.value);
+		return inArray(column, w.value);
+	}
+	if (w.operator === "not_in") {
+		if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${fieldLabel}" must be an array when using the "not_in" operator.`);
+		if (isInsensitive) return insensitiveNotInArray(column, w.value);
+		return notInArray(column, w.value);
+	}
+	const likeMode = isInsensitive && typeof w.value === "string" ? "insensitive" : "sensitive";
+	if (w.operator === "contains") return escapedLike(column, `%${escapeLikePattern(w.value)}%`, provider, likeMode);
+	if (w.operator === "starts_with") return escapedLike(column, `${escapeLikePattern(w.value)}%`, provider, likeMode);
+	if (w.operator === "ends_with") return escapedLike(column, `%${escapeLikePattern(w.value)}`, provider, likeMode);
+	if (w.operator === "lt") return lt(column, w.value);
+	if (w.operator === "lte") return lte(column, w.value);
+	if (w.operator === "ne") {
+		if (w.value === null) return isNotNull(column);
+		if (isInsensitive && typeof w.value === "string") return insensitiveNe(column, w.value);
+		return ne(column, w.value);
+	}
+	if (w.operator === "gt") return gt(column, w.value);
+	if (w.operator === "gte") return gte(column, w.value);
+	if (w.value === null) return isNull(column);
+	if (isInsensitive && typeof w.value === "string") return insensitiveEq(column, w.value);
+	return eq(column, w.value);
+}
+const drizzleAdapter = (db, config) => {
+	let lazyOptions = null;
+	let mysqlNoIdWarned = false;
+	const createCustomAdapter = (db, inTransaction = false) => ({ getFieldName, getDefaultModelName, options, schema: baSchema }) => {
+		if (config.provider === "mysql" && options.advanced?.database?.generateId === false && !mysqlNoIdWarned) {
+			mysqlNoIdWarned = true;
+			logger.warn("[Drizzle Adapter] MySQL does not support INSERT...RETURNING. With generateId set to false, the adapter uses best-effort fallback strategies (unique columns, full-field match) to retrieve inserted rows. For reliable behavior, use Better Auth's default ID generation, a custom generateId function, or generateId: \"serial\" for auto-increment.");
+		}
+		function getSchema(model) {
+			const schema = config.schema || db._.fullSchema;
+			if (!schema) throw new BetterAuthError("Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object.");
+			const schemaModel = schema[model];
+			if (!schemaModel) throw new BetterAuthError(`[# Drizzle Adapter]: The model "${model}" was not found in the schema object. Please pass the schema directly to the adapter options.`);
+			return schemaModel;
+		}
+		/**
+		* Resolve the `db.query` key for a model.
+		*
+		* `db.query` is keyed by the Drizzle schema export names, which are
+		* often plural ("users") even when Better Auth uses singular model
+		* names. Try the model directly, then the `usePlural` variant, then
+		* scan the schema for the key pointing at the same table.
+		*/
+		function getQueryModel(model) {
+			if (!db.query) return null;
+			if (db.query[model]) return model;
+			if (config.usePlural) {
+				const plural = `${model}s`;
+				if (db.query[plural]) return plural;
+			}
+			if (config.schema) {
+				const targetTable = config.schema[model];
+				if (targetTable) {
+					const relations = db._?.relations;
+					const fullSchema = db._?.fullSchema;
+					for (const key of Object.keys(db.query)) if ((relations?.[key]?.table ?? fullSchema?.[key]) === targetTable) return key;
+				}
+			}
+			return null;
+		}
+		/**
+		* Mirror the schema generator's relation-key naming. One-to-one keeps
+		* the singular model name. One-to-many is pluralized unless the model
+		* already ends in "s" or `usePlural` keeps the schema keys as-is.
+		*/
+		function getJoinRelationKey(model, isUnique) {
+			if (isUnique || config.usePlural || model.endsWith("s")) return model;
+			return `${model}s`;
+		}
+		const withReturning = async (model, builder, data, where) => {
+			if (config.provider !== "mysql") return (await builder.returning())[0];
+			const isSerialInsert = where === void 0 && options.advanced?.database?.generateId === "serial";
+			const insertResult = isSerialInsert ? await builder.$returningId().execute() : await builder.execute();
+			const schemaModel = getSchema(model);
+			const builderVal = builder.config?.values;
+			if (where?.length) {
+				const clause = convertWhereClause(where.map((w) => {
+					if (data[w.field] !== void 0) return {
+						...w,
+						value: data[w.field]
+					};
+					return w;
+				}), model);
+				return (await db.select().from(schemaModel).where(...clause))[0];
+			}
+			const fetchInserted = async (tx) => {
+				const builderId = builderVal?.[0]?.id?.value;
+				if (builderId) return (await tx.select().from(schemaModel).where(eq(schemaModel.id, builderId)).limit(1).execute())[0] ?? null;
+				if (data.id) return (await tx.select().from(schemaModel).where(eq(schemaModel.id, data.id)).limit(1).execute())[0] ?? null;
+				const insertId = isSerialInsert ? insertResult?.[0]?.id : void 0;
+				if (insertId && schemaModel.id) return (await tx.select().from(schemaModel).where(eq(schemaModel.id, insertId)).limit(1).execute())[0] ?? null;
+				const modelSchema = baSchema[getDefaultModelName(model)]?.fields;
+				if (modelSchema) for (const [fieldKey, fieldAttr] of Object.entries(modelSchema)) {
+					if (!fieldAttr.unique) continue;
+					const dbFieldName = getFieldName({
+						model,
+						field: fieldKey
+					});
+					const val = data[dbFieldName];
+					if (val === void 0 || val === null) continue;
+					if (!schemaModel[dbFieldName]) continue;
+					const res = await tx.select().from(schemaModel).where(eq(schemaModel[dbFieldName], val)).limit(1).execute();
+					if (res[0]) return res[0];
+				}
+				const conditions = [];
+				for (const [key, val] of Object.entries(data)) {
+					if (val === void 0 || !schemaModel[key]) continue;
+					conditions.push(val === null ? isNull(schemaModel[key]) : eq(schemaModel[key], val));
+				}
+				if (conditions.length > 0) {
+					const combined = and(...conditions);
+					if (combined) {
+						const res = await tx.select().from(schemaModel).where(combined).limit(2).execute();
+						if (res.length === 1) return res[0];
+					}
+				}
+				logger.warn(`[Drizzle Adapter] Unable to safely identify the inserted "${model}" row on MySQL. Enable Better Auth ID generation or use generateId: "serial" for reliable behavior.`);
+				return null;
+			};
+			return inTransaction ? fetchInserted(db) : db.transaction(fetchInserted);
+		};
+		function resolveColumn(model, w) {
+			const schemaModel = getSchema(model);
+			const field = getFieldName({
+				model,
+				field: w.field
+			});
+			if (!schemaModel[field]) throw new BetterAuthError(`The field "${w.field}" does not exist in the schema for the model "${model}". Please update your schema.`);
+			return {
+				column: schemaModel[field],
+				field
+			};
+		}
+		function convertWhereClause(where, model) {
+			if (!where) return [];
+			if (where.length === 1) {
+				const w = where[0];
+				if (!w) return [];
+				const { column } = resolveColumn(model, w);
+				return [applyWhereOperator(column, w, w.field, config.provider)];
+			}
+			const andGroup = where.filter((w) => w.connector === "AND" || !w.connector);
+			const orGroup = where.filter((w) => w.connector === "OR");
+			const combined = and(and(...andGroup.map((w) => {
+				const { column } = resolveColumn(model, w);
+				return applyWhereOperator(column, w, w.field, config.provider);
+			})), or(...orGroup.map((w) => {
+				const { column } = resolveColumn(model, w);
+				return applyWhereOperator(column, w, w.field, config.provider);
+			})));
+			return combined ? [combined] : [];
+		}
+		function convertNewWhereClause(where, model) {
+			const schemaModel = getSchema(model);
+			if (!where || where.length === 0) return {};
+			const rawCondition = (w, field) => ({ RAW: (table) => applyWhereOperator(table[field], w, w.field, config.provider) });
+			const convertWhereToColumn = (w) => {
+				const field = getFieldName({
+					model,
+					field: w.field
+				});
+				if (!schemaModel[field]) throw new BetterAuthError(`The field "${w.field}" does not exist in the schema for the model "${model}". Please update your schema.`);
+				const columnObj = {};
+				let raw;
+				const isInsensitive = w.mode === "insensitive" && (typeof w.value === "string" || Array.isArray(w.value) && w.value.every((v) => typeof v === "string"));
+				if (w.operator === "contains" || w.operator === "starts_with" || w.operator === "ends_with" || isInsensitive) raw = rawCondition(w, field);
+				else if (w.operator === "in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "in" operator.`);
+					columnObj.in = w.value;
+				} else if (w.operator === "not_in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "not_in" operator.`);
+					columnObj.notIn = w.value;
+				} else if (w.operator === "lt") columnObj.lt = w.value;
+				else if (w.operator === "lte") columnObj.lte = w.value;
+				else if (w.operator === "ne") if (w.value === null) columnObj.isNotNull = true;
+				else columnObj.ne = w.value;
+				else if (w.operator === "gt") columnObj.gt = w.value;
+				else if (w.operator === "gte") columnObj.gte = w.value;
+				else if (w.value === null) columnObj.isNull = true;
+				else columnObj.eq = w.value;
+				return {
+					field,
+					columnObj,
+					raw
+				};
+			};
+			if (where.length === 1) {
+				const w = where[0];
+				if (!w) return {};
+				const { field, columnObj, raw } = convertWhereToColumn(w);
+				return raw ?? { [field]: columnObj };
+			}
+			const andGroup = where.filter((w) => w.connector === "AND" || !w.connector);
+			const orGroup = where.filter((w) => w.connector === "OR");
+			const result = {};
+			if (andGroup.length > 0) {
+				const fieldMap = {};
+				const rawConditions = [];
+				for (const w of andGroup) {
+					const { field, columnObj, raw } = convertWhereToColumn(w);
+					if (raw) {
+						rawConditions.push(raw);
+						continue;
+					}
+					if (!fieldMap[field]) fieldMap[field] = [];
+					fieldMap[field].push(columnObj);
+				}
+				for (const [field, conditions] of Object.entries(fieldMap)) if (conditions.length === 1) result[field] = conditions[0];
+				else result[field] = { AND: conditions };
+				if (rawConditions.length > 0) result.AND = rawConditions;
+			}
+			if (orGroup.length > 0) {
+				const orConditions = [];
+				for (const w of orGroup) {
+					const { field, columnObj, raw } = convertWhereToColumn(w);
+					orConditions.push(raw ?? { [field]: columnObj });
+				}
+				if (orConditions.length > 0) result.OR = orConditions;
+			}
+			return result;
+		}
+		function checkMissingFields(schema, model, values) {
+			if (!schema) throw new BetterAuthError("Drizzle adapter failed to initialize. Drizzle Schema not found. Please provide a schema object in the adapter options object.");
+			for (const key in values) if (!schema[key]) throw new BetterAuthError(`The field "${key}" does not exist in the "${model}" Drizzle schema. Please update your drizzle schema or re-generate using "npx @better-auth/cli@latest generate".`);
+		}
+		return {
+			async create({ model, data: values }) {
+				const schemaModel = getSchema(model);
+				checkMissingFields(schemaModel, model, values);
+				return await withReturning(model, db.insert(schemaModel).values(values), values);
+			},
+			async findOne({ model, where, select, join }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				if (options.experimental?.joins) {
+					const queryModel = getQueryModel(model);
+					if (!db.query || !queryModel) {
+						logger.error(`[# Drizzle Adapter]: The model "${model}" was not found in the query object. Please update your Drizzle schema to include relations or re-generate using "npx @better-auth/cli@latest generate".`);
+						logger.info("Falling back to regular query");
+					} else {
+						let includes;
+						const pluralJoinResults = [];
+						if (join) {
+							includes = {};
+							const joinEntries = Object.entries(join);
+							for (const [model, joinAttr] of joinEntries) {
+								const limit = joinAttr.limit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+								const isUnique = joinAttr.relation === "one-to-one";
+								const relationKey = getJoinRelationKey(model, isUnique);
+								includes[relationKey] = isUnique ? true : { limit };
+								if (!isUnique) pluralJoinResults.push({
+									key: relationKey,
+									target: model
+								});
+							}
+						}
+						const clause = convertNewWhereClause(where, model);
+						const res = await db.query[queryModel].findFirst({
+							where: clause,
+							columns: select?.length && select.length > 0 ? select.reduce((acc, field) => {
+								acc[getFieldName({
+									model,
+									field
+								})] = true;
+								return acc;
+							}, {}) : void 0,
+							with: includes
+						});
+						if (res) for (const { key, target } of pluralJoinResults) {
+							if (key === target) continue;
+							res[target] = res[key];
+							delete res[key];
+						}
+						return res;
+					}
+				}
+				const res = await db.select(select?.length && select.length > 0 ? select.reduce((acc, field) => {
+					const fieldName = getFieldName({
+						model,
+						field
+					});
+					return {
+						...acc,
+						[fieldName]: schemaModel[fieldName]
+					};
+				}, {}) : void 0).from(schemaModel).where(...clause);
+				if (!res.length) return null;
+				return res[0];
+			},
+			async findMany({ model, where, sortBy, limit, select, offset, join }) {
+				const schemaModel = getSchema(model);
+				const clause = where ? convertWhereClause(where, model) : [];
+				const sortFn = sortBy?.direction === "desc" ? desc : asc;
+				if (options.experimental?.joins) {
+					const queryModel = getQueryModel(model);
+					if (!db.query || !queryModel) {
+						logger.error(`[# Drizzle Adapter]: The model "${model}" was not found in the query object. Please update your Drizzle schema to include relations or re-generate using "npx @better-auth/cli@latest generate".`);
+						logger.info("Falling back to regular query");
+					} else {
+						let includes;
+						const pluralJoinResults = [];
+						if (join) {
+							includes = {};
+							const joinEntries = Object.entries(join);
+							for (const [model, joinAttr] of joinEntries) {
+								const isUnique = joinAttr.relation === "one-to-one";
+								const limit = joinAttr.limit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+								const relationKey = getJoinRelationKey(model, isUnique);
+								includes[relationKey] = isUnique ? true : { limit };
+								if (!isUnique) pluralJoinResults.push({
+									key: relationKey,
+									target: model
+								});
+							}
+						}
+						let orderBy = void 0;
+						if (sortBy?.field) orderBy = { [getFieldName({
+							model,
+							field: sortBy.field
+						})]: sortBy.direction === "desc" ? "desc" : "asc" };
+						const res = await db.query[queryModel].findMany({
+							where: where ? convertNewWhereClause(where, model) : void 0,
+							with: includes,
+							columns: select?.length && select.length > 0 ? select.reduce((acc, field) => {
+								acc[getFieldName({
+									model,
+									field
+								})] = true;
+								return acc;
+							}, {}) : void 0,
+							limit: limit ?? 100,
+							offset: offset ?? 0,
+							orderBy
+						});
+						if (res) for (const item of res) for (const { key, target } of pluralJoinResults) {
+							if (key === target) continue;
+							item[target] = item[key];
+							delete item[key];
+						}
+						return res;
+					}
+				}
+				let builder = db.select(select?.length && select.length > 0 ? select.reduce((acc, field) => {
+					const fieldName = getFieldName({
+						model,
+						field
+					});
+					return {
+						...acc,
+						[fieldName]: schemaModel[fieldName]
+					};
+				}, {}) : void 0).from(schemaModel);
+				const effectiveLimit = limit;
+				const effectiveOffset = offset;
+				if (typeof effectiveLimit !== "undefined") builder = builder.limit(effectiveLimit);
+				if (typeof effectiveOffset !== "undefined") builder = builder.offset(effectiveOffset);
+				if (sortBy?.field) builder = builder.orderBy(sortFn(schemaModel[getFieldName({
+					model,
+					field: sortBy?.field
+				})]));
+				return await builder.where(...clause);
+			},
+			async count({ model, where }) {
+				const schemaModel = getSchema(model);
+				const clause = where ? convertWhereClause(where, model) : [];
+				return (await db.select({ count: count() }).from(schemaModel).where(...clause))[0].count;
+			},
+			async update({ model, where, update: values }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				return await withReturning(model, db.update(schemaModel).set(values).where(...clause), values, where);
+			},
+			async updateMany({ model, where, update: values }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				return getAffectedRowCount(await db.update(schemaModel).set(values).where(...clause), "updateMany", {
+					model,
+					where
+				});
+			},
+			async delete({ model, where }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				return await db.delete(schemaModel).where(...clause);
+			},
+			async deleteMany({ model, where }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				return getAffectedRowCount(await db.delete(schemaModel).where(...clause), "deleteMany", {
+					model,
+					where
+				});
+			},
+			async consumeOne({ model, where }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				const idField = getFieldName({
+					model,
+					field: "id"
+				});
+				const idColumn = schemaModel[idField];
+				if (config.provider === "mysql") {
+					const claimFromTransaction = async (tx) => {
+						const target = (await tx.select().from(schemaModel).where(...clause).for("update").limit(1))[0];
+						if (!target) return null;
+						const targetId = target[idField] ?? target.id;
+						if (targetId === void 0 || targetId === null || !idColumn) return null;
+						return getAffectedRowCount(await tx.delete(schemaModel).where(eq(idColumn, targetId)).execute(), "consumeOne", {
+							model,
+							where
+						}) > 0 ? target : null;
+					};
+					return inTransaction ? claimFromTransaction(db) : db.transaction(claimFromTransaction);
+				}
+				if (!idColumn) return null;
+				const targetIds = db.select({ id: idColumn }).from(schemaModel).where(...clause).limit(1);
+				return (await db.delete(schemaModel).where(inArray(idColumn, targetIds)).returning())[0] ?? null;
+			},
+			async incrementOne({ model, where, increment, set }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				const idField = getFieldName({
+					model,
+					field: "id"
+				});
+				const idColumn = schemaModel[idField];
+				const assignments = {};
+				for (const [field, delta] of Object.entries(increment)) {
+					const columnName = getFieldName({
+						model,
+						field
+					});
+					const column = schemaModel[columnName];
+					if (!column) throw new BetterAuthError(`The field "${field}" does not exist in the schema for the model "${model}". Please update your schema.`);
+					assignments[columnName] = sql`${column} + ${sql.param(delta)}`;
+				}
+				if (set) for (const [field, value] of Object.entries(set)) {
+					const columnName = getFieldName({
+						model,
+						field
+					});
+					if (!schemaModel[columnName]) throw new BetterAuthError(`The field "${field}" does not exist in the schema for the model "${model}". Please update your schema.`);
+					assignments[columnName] = value;
+				}
+				if (config.provider === "mysql") {
+					const mutateInTransaction = async (tx) => {
+						const target = (await tx.select().from(schemaModel).where(...clause).for("update").limit(1))[0];
+						if (!target) return null;
+						const targetId = target[idField] ?? target.id;
+						if (targetId === void 0 || targetId === null || !idColumn) return null;
+						await tx.update(schemaModel).set(assignments).where(eq(idColumn, targetId)).execute();
+						return (await tx.select().from(schemaModel).where(eq(idColumn, targetId)).limit(1).execute())[0] ?? null;
+					};
+					return inTransaction ? mutateInTransaction(db) : db.transaction(mutateInTransaction);
+				}
+				if (!idColumn) return null;
+				const targetIds = db.select({ id: idColumn }).from(schemaModel).where(...clause).limit(1);
+				return (await db.update(schemaModel).set(assignments).where(inArray(idColumn, targetIds)).returning())[0] ?? null;
+			},
+			async createSchema(props) {
+				const { generateDrizzleSchema } = await import("../generate-drizzle-schema-BdVT4xKv.mjs");
+				return await generateDrizzleSchema({
+					adapterConfig: config,
+					options,
+					provider: config.provider,
+					camelCase: config.camelCase,
+					file: props.file,
+					tables: props.tables
+				});
+			},
+			options: config
+		};
+	};
+	let adapterOptions = null;
+	adapterOptions = {
+		config: {
+			adapterId: "drizzle",
+			adapterName: "Drizzle Adapter",
+			usePlural: config.usePlural ?? false,
+			debugLogs: config.debugLogs ?? false,
+			supportsUUIDs: config.provider === "pg" ? true : false,
+			supportsJSON: true,
+			supportsArrays: true,
+			transaction: config.transaction ?? false ? (cb) => db.transaction((tx) => {
+				return cb(createAdapterFactory({
+					config: {
+						...adapterOptions.config,
+						transaction: false
+					},
+					adapter: createCustomAdapter(tx, true)
+				})(lazyOptions));
+			}) : false
+		},
+		adapter: createCustomAdapter(db)
+	};
+	const adapter = createAdapterFactory(adapterOptions);
+	return (options) => {
+		lazyOptions = options;
+		return adapter(options);
+	};
+};
+//#endregion
+export { drizzleAdapter };

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@better-auth/drizzle-adapter",
-  "version": "1.7.0-beta.1",
+  "version": "1.7.0-beta.10",
+  "bugs": {
+    "url": "https://github.com/better-auth/better-auth/issues"
+  },
   "description": "Drizzle adapter for Better Auth",
   "type": "module",
   "license": "MIT",
@@ -29,15 +32,20 @@
   "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "dev-source": "./src/index.ts",
       "types": "./dist/index.d.mts",
+      "dev-source": "./src/index.ts",
       "default": "./dist/index.mjs"
+    },
+    "./relations-v2": {
+      "types": "./dist/relations-v2/index.d.mts",
+      "dev-source": "./src/relations-v2/index.ts",
+      "default": "./dist/relations-v2/index.mjs"
     }
   },
   "peerDependencies": {
-    "@better-auth/utils": "0.4.0",
-    "drizzle-orm": ">=0.41.0",
-    "@better-auth/core": "^1.7.0-beta.1"
+    "@better-auth/utils": "0.4.2",
+    "drizzle-orm": "^0.45.2 || >=1.0.0-rc.1 <2.0.0",
+    "@better-auth/core": "^1.7.0-beta.10"
   },
   "peerDependenciesMeta": {
     "drizzle-orm": {
@@ -45,11 +53,11 @@
     }
   },
   "devDependencies": {
-    "@better-auth/utils": "0.4.0",
+    "@better-auth/utils": "0.4.2",
     "drizzle-orm": "^0.45.2",
     "tsdown": "0.21.1",
     "typescript": "^5.9.3",
-    "@better-auth/core": "1.7.0-beta.1"
+    "@better-auth/core": "1.7.0-beta.10"
   },
   "scripts": {
     "build": "tsdown",