auth 1.7.0-rc.0 → 1.7.0-rc.2

package/dist/api.d.mts

@@ -1,6 +1,5 @@
 import { DBAdapter, DBAdapter as DBAdapter$1 } from "@better-auth/core/db/adapter";
 import { BetterAuthOptions } from "@better-auth/core";
-
 //#region src/generators/types.d.ts
 interface SchemaGeneratorResult {
   code?: string;

package/dist/api.mjs

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
+import { getDatabaseFieldIndexName, getDatabaseIndexStringLength, getPortableDatabaseIdentifierKey, resolveDatabaseSchemaIndexes } from "@better-auth/core/db/internal";
 import { capitalizeFirstLetter, toSnakeCase } from "@better-auth/core/utils/string";
 import { initGetFieldName, initGetModelName } from "better-auth/adapters";
 import { getAuthTables } from "better-auth/db";
@@ -6,22 +7,36 @@ import prettier from "prettier";
 import { getMigrations } from "better-auth/db/migration";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { BetterAuthError } from "@better-auth/core/error";
 import { produceSchema } from "@mrleebo/prisma-ast";
 //#region src/generators/drizzle.ts
 function convertToSnakeCase(str, camelCase) {
 	return camelCase ? str : toSnakeCase(str);
 }
+function toValidIdentifier(str) {
+	let result = str.replace(/[^a-zA-Z0-9_]/g, "").replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/_/g, "").replace(/^[0-9]/, "_$&");
+	if (result.length > 0 && result[0].match(/[A-Z]/)) result = result[0].toLowerCase() + result.slice(1);
+	return result || "schema";
+}
 const generateDrizzleSchema = async ({ options, file, adapter }) => {
 	const tables = getAuthTables(options);
 	const filePath = file || "./auth-schema.ts";
 	const databaseType = adapter.options?.provider;
+	const schemaName = adapter.options?.schemaName;
 	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
+		options,
+		schemaName
 	});
+	let schemaVarName;
+	if (databaseType === "pg" && schemaName) {
+		schemaVarName = `${toValidIdentifier(schemaName)}Schema`;
+		if (schemaVarName === "pgSchema") schemaVarName = "pgCustomSchema";
+		code += `\nconst ${schemaVarName} = pgSchema(${JSON.stringify(schemaName)});\n\n`;
+	}
 	const getModelName = initGetModelName({
 		schema: tables,
 		usePlural: adapter.options?.adapterConfig?.usePlural
@@ -39,12 +54,18 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		const customModelName = table.modelName || tableKey;
 		return model === tableKey || model === customModelName || model === getModelName(tableKey) || model === getModelName(customModelName);
 	});
+	const resolvedIndexesByTable = resolveDatabaseSchemaIndexes(Object.keys(tables).filter((tableKey) => !isMigrationDisabled(tableKey)).map((tableKey) => ({
+		fields: tables[tableKey].fields,
+		indexes: tables[tableKey].indexes,
+		tableName: getModelName(tableKey)
+	})));
 	for (const tableKey in tables) {
 		const table = tables[tableKey];
 		if (isMigrationDisabled(tableKey)) continue;
 		const modelName = getModelName(tableKey);
 		const fields = table.fields;
-		function getType(name, field) {
+		const resolvedTableIndexes = resolvedIndexesByTable.get(modelName) ?? [];
+		function getType(name, field, tableIndexStringLength) {
 			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, adapter.options?.camelCase);
 			if (field.references?.field === "id") {
@@ -70,7 +91,7 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 				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}')`
+					mysql: tableIndexStringLength ? `varchar('${name}', { length: ${tableIndexStringLength} })` : 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' })`,
@@ -119,30 +140,35 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		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}),`);
+			for (const index of indexes) code.push(`  ${index.type}(${JSON.stringify(index.name)}).on(${index.on.map((fieldName) => `table.${fieldName}`).join(", ")}),`);
 			code.push(`]`);
 			return code.join("\n");
 		};
-		const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
+		for (const tableIndex of resolvedTableIndexes) indexes.push({
+			type: tableIndex.unique ? "uniqueIndex" : "index",
+			name: tableIndex.name,
+			on: tableIndex.columns
+		});
+		const schema = `export const ${modelName} = ${databaseType === "pg" && schemaName && schemaVarName ? `${schemaVarName}.table` : `${databaseType}Table`}("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
 					id: ${id},
 					${Object.keys(fields).map((field) => {
 			const attr = fields[field];
 			const fieldName = attr.fieldName || field;
-			let type = getType(fieldName, attr);
+			let type = getType(fieldName, attr, databaseType === "mysql" ? getDatabaseIndexStringLength({
+				columnName: fieldName,
+				dialect: "mysql",
+				fields,
+				indexes: resolvedTableIndexes
+			}) : void 0);
 			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
+				name: getDatabaseFieldIndexName(modelName, fieldName, false),
+				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("${attr.defaultValue}")`;
+			} 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}])`;
@@ -167,12 +193,25 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		const modelName = getModelName(tableKey);
 		const oneRelations = [];
 		const manyRelations = [];
-		const manyRelationsSet = /* @__PURE__ */ new Set();
 		const foreignFields = Object.entries(table.fields).filter(([_, field]) => field.references);
+		const foreignFieldCounts = /* @__PURE__ */ new Map();
+		for (const [_, field] of foreignFields) {
+			const referencedModel = getModelName(field.references.model);
+			foreignFieldCounts.set(referencedModel, (foreignFieldCounts.get(referencedModel) ?? 0) + 1);
+		}
+		const usedOneRelationKeys = /* @__PURE__ */ new Set();
 		for (const [fieldName, field] of foreignFields) {
 			const referencedModel = field.references.model;
 			if (isMigrationDisabled(referencedModel)) continue;
-			const relationKey = getSingularModelName(referencedModel);
+			const hasMultipleRelations = (foreignFieldCounts.get(getModelName(referencedModel)) ?? 0) > 1;
+			let relationKey = hasMultipleRelations ? fieldName.replace(/Id$/, "") : getSingularModelName(referencedModel);
+			if (usedOneRelationKeys.has(relationKey)) relationKey = fieldName;
+			if (usedOneRelationKeys.has(relationKey)) {
+				let suffix = 2;
+				while (usedOneRelationKeys.has(`${relationKey}_${suffix}`)) suffix++;
+				relationKey = `${relationKey}_${suffix}`;
+			}
+			usedOneRelationKeys.add(relationKey);
 			const fieldRef = `${getModelName(tableKey)}.${getFieldName({
 				model: tableKey,
 				field: fieldName
@@ -185,81 +224,49 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 				key: relationKey,
 				model: getModelName(referencedModel),
 				type: "one",
+				relationName: hasMultipleRelations ? `${getModelName(tableKey)}_${fieldName}` : void 0,
 				reference: {
 					field: fieldRef,
-					references: referenceRef,
-					fieldName
+					references: referenceRef
 				}
 			});
 		}
 		const otherModels = Object.entries(tables).filter(([modelName, otherTable]) => modelName !== tableKey && !otherTable.disableMigrations);
-		const modelRelationsMap = /* @__PURE__ */ new Map();
 		for (const [modelName, otherTable] of otherModels) {
 			const foreignKeysPointingHere = Object.entries(otherTable.fields).filter(([_, field]) => field.references?.model === tableKey || field.references?.model === getModelName(tableKey));
 			if (foreignKeysPointingHere.length === 0) continue;
-			const hasUnique = foreignKeysPointingHere.some(([_, field]) => !!field.unique);
-			const hasMany = foreignKeysPointingHere.some(([_, field]) => !field.unique);
-			modelRelationsMap.set(modelName, {
-				modelName,
-				hasUnique,
-				hasMany
-			});
-		}
-		for (const { modelName, hasMany } of modelRelationsMap.values()) {
-			const relationType = hasMany ? "many" : "one";
-			let relationKey = getModelName(modelName);
-			if (!adapter.options?.adapterConfig?.usePlural && relationType === "many") relationKey = `${relationKey}s`;
-			if (!manyRelationsSet.has(relationKey)) {
-				manyRelationsSet.add(relationKey);
+			for (const [fieldName, field] of foreignKeysPointingHere) {
+				const relationType = field.unique ? "one" : "many";
+				let relationKey = getModelName(modelName);
+				if (!adapter.options?.adapterConfig?.usePlural && relationType === "many") relationKey = `${relationKey}s`;
+				const hasMultipleRelations = foreignKeysPointingHere.length > 1;
+				if (hasMultipleRelations) relationKey = `${relationKey}By${fieldName.charAt(0).toUpperCase()}${fieldName.slice(1)}`;
 				manyRelations.push({
 					key: relationKey,
 					model: getModelName(modelName),
-					type: relationType
+					type: relationType,
+					relationName: hasMultipleRelations ? `${getModelName(modelName)}_${fieldName}` : void 0
 				});
 			}
 		}
-		const relationsByModel = /* @__PURE__ */ new Map();
-		for (const relation of oneRelations) if (relation.reference) {
-			const modelKey = relation.key;
-			if (!relationsByModel.has(modelKey)) relationsByModel.set(modelKey, []);
-			relationsByModel.get(modelKey).push(relation);
-		}
-		const duplicateRelations = [];
-		const singleRelations = [];
-		for (const [_modelKey, relations] of relationsByModel.entries()) if (relations.length > 1) duplicateRelations.push(...relations);
-		else singleRelations.push(relations[0]);
-		for (const relation of duplicateRelations) if (relation.reference) {
-			const fieldName = relation.reference.fieldName;
-			const tableRelation = `export const ${`${modelName}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Relations`} = relations(${getModelName(table.modelName)}, ({ one }) => ({
-				${relation.key}: one(${relation.model}, {
+		const hasForwardOne = oneRelations.length > 0;
+		const hasReverseOne = manyRelations.some((relation) => relation.type === "one");
+		const hasReverseMany = manyRelations.some((relation) => relation.type === "many");
+		const hasOne = hasForwardOne || hasReverseOne;
+		const hasMany = hasReverseMany;
+		const renderOneRelation = (relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
 					fields: [${relation.reference.field}],
 					references: [${relation.reference.references}],
-				})
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		}
-		const hasOne = singleRelations.length > 0;
-		const hasMany = manyRelations.length > 0;
-		if (hasOne && hasMany) {
-			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one, many }) => ({
-				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
-					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}],
-				})` : "").filter((x) => x !== "").join(",\n ")}${singleRelations.length > 0 && manyRelations.length > 0 ? "," : ""}
-				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		} else if (hasOne) {
-			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one }) => ({
-				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
-					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}],
-				})` : "").filter((x) => x !== "").join(",\n ")}
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		} else if (hasMany) {
-			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ many }) => ({
-				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
+					${relation.relationName ? `relationName: "${relation.relationName}",` : ""}
+				})` : "";
+		const renderReverseRelation = ({ key, model, type, relationName }) => {
+			return ` ${key}: ${type === "one" ? "one" : "many"}(${model}${relationName ? `, { relationName: "${relationName}" }` : ""})`;
+		};
+		if (hasOne || hasMany) {
+			const helpers = [hasOne ? "one" : null, hasMany ? "many" : null].filter(Boolean).join(", ");
+			const relationEntries = [...oneRelations.map(renderOneRelation).filter((x) => x !== ""), ...manyRelations.map(renderReverseRelation)].join(",\n ");
+			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ ${helpers} }) => ({
+				${relationEntries}
 			}))`;
 			relationsString += `\n${tableRelation}\n`;
 		}
@@ -271,7 +278,7 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		overwrite: fileExist
 	};
 };
-function generateImport({ databaseType, tables, options }) {
+function generateImport({ databaseType, tables, options, schemaName }) {
 	const rootImports = ["relations"];
 	const coreImports = [];
 	let hasBigint = false;
@@ -285,7 +292,8 @@ function generateImport({ databaseType, tables, options }) {
 	}
 	const useNumberId = options.advanced?.database?.generateId === "serial";
 	const useUUIDs = options.advanced?.database?.generateId === "uuid";
-	coreImports.push(`${databaseType}Table`);
+	if (databaseType === "pg" && schemaName) coreImports.push("pgSchema");
+	if (!(databaseType === "pg" && schemaName)) 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" : "");
@@ -305,8 +313,8 @@ function generateImport({ databaseType, tables, options }) {
 		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));
+	const hasIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.index && !field.unique) || (table.indexes?.some((index) => !index.unique) ?? false));
+	const hasUniqueIndexes = Object.values(tables).some((table) => table.indexes?.some((index) => index.unique) ?? false);
 	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`;
@@ -340,11 +348,58 @@ function getPrismaVersion(cwd) {
 }
 //#endregion
 //#region src/generators/prisma.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function parsePrismaStringLiteral(value) {
+	if (typeof value !== "string") return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		return typeof parsed === "string" ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function getPrismaIndexDefinition(property) {
+	if (!isRecord(property) || property.type !== "attribute" || property.kind !== "object" || property.name !== "index" && property.name !== "unique" || !Array.isArray(property.args)) return;
+	const propertyArgs = property.args;
+	let columns;
+	let mappedName;
+	let validFullColumns = false;
+	for (const argument of propertyArgs) {
+		if (!isRecord(argument) || !isRecord(argument.value)) continue;
+		const value = argument.value;
+		if (value.type === "array" && Array.isArray(value.args) && value.args.every((column) => typeof column === "string")) {
+			columns = value.args.map((column) => String(column));
+			validFullColumns = true;
+		} else if (value.type === "keyValue" && value.key === "map") mappedName = parsePrismaStringLiteral(value.value);
+	}
+	return {
+		columns: columns ?? [],
+		mappedName,
+		setMappedName(name) {
+			propertyArgs.push({
+				type: "attributeArgument",
+				value: {
+					type: "keyValue",
+					key: "map",
+					value: JSON.stringify(name)
+				}
+			});
+		},
+		unique: property.name === "unique",
+		validFullColumns
+	};
+}
+function prismaIndexMatches(existing, configured) {
+	return existing.validFullColumns && existing.unique === (configured.unique ?? false) && existing.columns.length === configured.columns.length && existing.columns.every((column, position) => column === configured.columns[position]);
+}
 const generatePrismaSchema = async ({ adapter, options, file }) => {
 	const provider = adapter.options?.provider || "postgresql";
 	const tables = getAuthTables(options);
 	const filePath = file || "./prisma/schema.prisma";
-	const schemaPrismaExist = existsSync(path.join(process.cwd(), filePath));
+	const resolvedFilePath = path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
+	const schemaPrismaExist = existsSync(resolvedFilePath);
 	const getModelName = initGetModelName({
 		schema: getAuthTables(options),
 		usePlural: adapter.options?.adapterConfig?.usePlural
@@ -358,8 +413,16 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 		const customModelName = table.modelName || tableKey;
 		return model === tableKey || model === customModelName || model === getModelName(tableKey) || model === getModelName(customModelName);
 	});
+	const resolvedIndexesByTable = resolveDatabaseSchemaIndexes(Object.keys(tables).filter((tableKey) => !isMigrationDisabled(tableKey)).map((tableKey) => {
+		const customModelName = tables[tableKey]?.modelName || tableKey;
+		return {
+			fields: tables[tableKey].fields,
+			indexes: tables[tableKey].indexes,
+			tableName: getModelName(customModelName)
+		};
+	}));
 	let schemaPrisma = "";
-	if (schemaPrismaExist) schemaPrisma = await fs.readFile(path.join(process.cwd(), filePath), "utf-8");
+	if (schemaPrismaExist) schemaPrisma = await fs.readFile(resolvedFilePath, "utf-8");
 	else schemaPrisma = getNewPrisma(provider, process.cwd());
 	const prismaVersion = getPrismaVersion(process.cwd());
 	if (prismaVersion && prismaVersion >= 7 && schemaPrismaExist) schemaPrisma = produceSchema(schemaPrisma, (builder) => {
@@ -410,8 +473,10 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 			const customModelName = tables[table]?.modelName || table;
 			const modelName = capitalizeFirstLetter(getModelName(customModelName));
 			const fields = tables[table]?.fields;
+			const resolvedTableIndexes = resolvedIndexesByTable.get(getModelName(customModelName)) ?? [];
 			function getType({ isBigint, isOptional, type }) {
 				if (type === "string") return isOptional ? "String?" : "String";
+				if (Array.isArray(type)) return isOptional ? "String?" : "String";
 				if (type === "number" && isBigint) return isOptional ? "BigInt?" : "BigInt";
 				if (type === "number") return isOptional ? "Int?" : "Int";
 				if (type === "boolean") return isOptional ? "Boolean?" : "Boolean";
@@ -477,6 +542,18 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 								isAlreadyExist.array = fieldTypeParts.isArray || void 0;
 							}
 						}
+						if (provider === "mysql" && (attr.type === "string" || Array.isArray(attr.type)) && typeof isAlreadyExist.fieldType === "string" && getFieldTypeParts(isAlreadyExist.fieldType).fieldType === "String") {
+							const tableIndexStringLength = getDatabaseIndexStringLength({
+								columnName: fieldName,
+								dialect: "mysql",
+								fields: fields ?? {},
+								indexes: resolvedTableIndexes
+							});
+							if (tableIndexStringLength) {
+								isAlreadyExist.attributes = isAlreadyExist.attributes?.filter((attribute) => attribute.group !== "db");
+								builder.model(modelName).field(fieldName).attribute(`db.VarChar(${tableIndexStringLength})`);
+							}
+						}
 						continue;
 					}
 				}
@@ -544,7 +621,31 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 					})}], onDelete: ${action})`;
 					builder.model(modelName).field(referencedCustomModelName.toLowerCase(), `${capitalizeFirstLetter(referencedCustomModelName)}${attr.required === false ? "?" : ""}`).attribute(relationField);
 				}
-				if (!attr.unique && !attr.references && provider === "mysql" && attr.type === "string") builder.model(modelName).field(fieldName).attribute("db.Text");
+				if (provider === "mysql" && (attr.type === "string" || Array.isArray(attr.type))) {
+					const tableIndexStringLength = getDatabaseIndexStringLength({
+						columnName: fieldName,
+						dialect: "mysql",
+						fields: fields ?? {},
+						indexes: resolvedTableIndexes
+					});
+					const nativeType = tableIndexStringLength ? `db.VarChar(${tableIndexStringLength})` : !attr.unique && !attr.references ? "db.Text" : void 0;
+					if (nativeType) builder.model(modelName).field(fieldName).attribute(nativeType);
+				}
+			}
+			for (const tableIndex of resolvedTableIndexes) {
+				const attributeName = tableIndex.unique ? "unique" : "index";
+				const existingIndexes = prismaModel?.properties.map(getPrismaIndexDefinition).filter((index) => index !== void 0) ?? [];
+				const existingMappedIndex = existingIndexes.find((index) => index.mappedName !== void 0 && getPortableDatabaseIdentifierKey(index.mappedName) === getPortableDatabaseIdentifierKey(tableIndex.name));
+				if (existingMappedIndex) {
+					if (!prismaIndexMatches(existingMappedIndex, tableIndex)) throw new BetterAuthError(`Prisma index "${tableIndex.name}" on model "${modelName}" does not match the configured fields and uniqueness. Rename or replace the existing index, then generate the schema again.`);
+					continue;
+				}
+				const existingUnmappedIndex = existingIndexes.find((index) => index.mappedName === void 0 && prismaIndexMatches(index, tableIndex));
+				if (existingUnmappedIndex) {
+					existingUnmappedIndex.setMappedName(tableIndex.name);
+					continue;
+				}
+				builder.model(modelName).blockAttribute(`${attributeName}([${tableIndex.columns.join(", ")}], map: ${JSON.stringify(tableIndex.name)})`);
 			}
 			if (manyToManyRelations.has(modelName)) for (const relatedModel of manyToManyRelations.get(modelName)) {
 				const relatedTableName = Object.keys(tables).find((key) => capitalizeFirstLetter(tables[key]?.modelName || key) === relatedModel);

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+import "dotenv/config";
+//#region src/index.d.ts
+declare let cliVersion: string;
+//#endregion
+export { cliVersion };

package/dist/index.mjs

@@ -20,6 +20,7 @@ import { createPathsMatcher, getTsconfig, parseTsconfig } from "get-tsconfig";
 import fs$1 from "node:fs/promises";
 import { createTelemetry, getTelemetryAuthConfig } from "@better-auth/telemetry";
 import { getAdapter } from "better-auth/db/adapter";
+import { getDatabaseFieldIndexName, getDatabaseIndexStringLength, getPortableDatabaseIdentifierKey, resolveDatabaseSchemaIndexes } from "@better-auth/core/db/internal";
 import { capitalizeFirstLetter, toSnakeCase } from "@better-auth/core/utils/string";
 import { initGetFieldName, initGetModelName } from "better-auth/adapters";
 import { getAuthTables } from "better-auth/db";
@@ -703,6 +704,11 @@ function addCloudflareVirtualModules(aliases) {
 * modules the real files depend on are not, which is why we stub `$app/*`
 * directly rather than resolving SvelteKit's on-disk files.
 *
+* The one exception is `$app/env/{private,public}` (explicit environment
+* variables): their exports are arbitrary names declared in the project's
+* `src/env.ts`, so they cannot be enumerated. They are stubbed with a Proxy
+* default export instead — see `createExplicitEnvModule`.
+*
 * The authoritative export surfaces this mirrors:
 *
 * @see https://github.com/sveltejs/kit/tree/main/packages/kit/src/runtime/app
@@ -713,6 +719,9 @@ function addSvelteKitVirtualModules(aliases) {
 	aliases["$env/dynamic/public"] = createStubModule(createDynamicEnvModule("public"));
 	aliases["$env/static/private"] = createStubModule(createStaticEnvModule(filterPrivateEnv("PUBLIC_", "")));
 	aliases["$env/static/public"] = createStubModule(createStaticEnvModule(filterPublicEnv("PUBLIC_", "")));
+	const explicitEnvStub = createStubModule(createExplicitEnvModule());
+	aliases["$app/env/private"] = explicitEnvStub;
+	aliases["$app/env/public"] = explicitEnvStub;
 	for (const [id, body] of Object.entries(appModuleStubs)) aliases[id] = createStubModule(body);
 }
 /**
@@ -824,6 +833,31 @@ export const env = new Proxy(
   },
 );`;
 }
+/**
+* Body for the explicit `$app/env/{private,public}` modules. Their exports are
+* named after the vars declared in `src/env.ts`, which the CLI cannot know, so
+* unlike the other stubs this cannot enumerate them. A Proxy exported as the
+* *default* sidesteps that: jiti compiles `import { FOO } from "..."` to a
+* member access on the (interop) default, which the Proxy answers from
+* process.env. No prefix filtering — the public/private split is a `src/env.ts`
+* config concern that does not affect schema generation.
+*/
+function createExplicitEnvModule() {
+	return `
+export default new Proxy(
+  {},
+  {
+    get: (_, key) =>
+      typeof key === "string" ? process.env[key] : undefined,
+    has: (_, key) => typeof key === "string" && key in process.env,
+    ownKeys: () => Object.keys(process.env),
+    getOwnPropertyDescriptor: (_, key) =>
+      typeof key === "string" && key in process.env
+        ? { value: process.env[key], enumerable: true, configurable: true }
+        : undefined,
+  },
+);`;
+}
 function filterPrivateEnv(publicPrefix, privatePrefix) {
 	return Object.fromEntries(Object.entries(process.env).filter(([k]) => k.startsWith(privatePrefix) && (publicPrefix === "" || !k.startsWith(publicPrefix))));
 }
@@ -831,7 +865,7 @@ function filterPublicEnv(publicPrefix, privatePrefix) {
 	return Object.fromEntries(Object.entries(process.env).filter(([k]) => k.startsWith(publicPrefix) && (privatePrefix === "" || !k.startsWith(privatePrefix))));
 }
 const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-const reserved = new Set([
+const reserved = /* @__PURE__ */ new Set([
 	"do",
 	"if",
 	"in",
@@ -1051,7 +1085,7 @@ function resolveWithMatchers(specifier, matchers) {
 * a jiti-side preprocessor artifact observed in the AST; revisit on jiti
 * major version bumps (the regression suite catches a rename but not the why).
 */
-const LOADER_IDENTIFIERS = new Set([
+const LOADER_IDENTIFIERS = /* @__PURE__ */ new Set([
 	"require",
 	"import",
 	"jitiImport"
@@ -1133,7 +1167,27 @@ const resolveAuthModule = (mod) => {
 };
 const isServerOnlyError = (e) => typeof e === "object" && e !== null && "message" in e && typeof e.message === "string" && e.message.includes("This module cannot be imported from a Client Component module");
 const SERVER_ONLY_HINT = `Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`;
-async function getConfig({ cwd, configPath, shouldThrowOnError = false }) {
+/** Strips a source extension so paths can be compared across TS and JS inputs. */
+function withoutSourceExtension(filePath) {
+	const ext = path.extname(filePath);
+	return SOURCE_EXTENSIONS_SET.has(ext) ? filePath.slice(0, -ext.length) : filePath;
+}
+/**
+* Detects a first-run config import of the exact schema file being generated.
+* Only relative imports are eligible, so unrelated packages and missing files
+* continue to fail normally.
+*
+* @see https://github.com/better-auth/better-auth/issues/10136
+*/
+function resolvesMissingOutputModule(error, configFilePath, resolvedOutputPath) {
+	if (!error || typeof error !== "object" || error.code !== "MODULE_NOT_FOUND") return false;
+	const specifier = ("message" in error && typeof error.message === "string" ? error.message : "").match(/Cannot find module ['"](\.\.?\/[^'"]+)['"]/)?.[1];
+	if (!specifier) return false;
+	const requireStack = "requireStack" in error && Array.isArray(error.requireStack) ? error.requireStack : [];
+	const importedFrom = typeof requireStack[0] === "string" ? requireStack[0] : configFilePath;
+	return withoutSourceExtension(path.resolve(path.dirname(importedFrom), specifier)) === withoutSourceExtension(resolvedOutputPath);
+}
+async function getConfig({ cwd, configPath, outputPath, shouldThrowOnError = false }) {
 	const fail = (message, error) => {
 		if (shouldThrowOnError) throw error instanceof Error ? error : new Error(message);
 		const log = `[#better-auth]: ${message}`;
@@ -1141,13 +1195,30 @@ async function getConfig({ cwd, configPath, shouldThrowOnError = false }) {
 		else console.error(log);
 		process.exit(1);
 	};
-	const load = (configFile) => loadConfig({
-		configFile,
-		dotenv: { fileName: [".env", ".env.local"] },
-		jitiOptions: jitiOptions(cwd),
-		resolveModule: resolveAuthModule,
-		cwd
-	});
+	const resolvedOutputPath = outputPath ? path.resolve(cwd, outputPath) : void 0;
+	const load = async (configFile) => {
+		const loadOnce = () => loadConfig({
+			configFile,
+			dotenv: { fileName: [".env", ".env.local"] },
+			jitiOptions: jitiOptions(cwd),
+			resolveModule: resolveAuthModule,
+			cwd
+		});
+		try {
+			return await loadOnce();
+		} catch (error) {
+			const resolvedConfigPath = path.isAbsolute(configFile) ? configFile : path.resolve(cwd, configFile);
+			if (!resolvedOutputPath || existsSync(resolvedOutputPath) || !resolvesMissingOutputModule(error, resolvedConfigPath, resolvedOutputPath)) throw error;
+			await fs.promises.mkdir(path.dirname(resolvedOutputPath), { recursive: true });
+			await fs.promises.writeFile(resolvedOutputPath, "");
+			try {
+				return await loadOnce();
+			} catch (retryError) {
+				await fs.promises.rm(resolvedOutputPath, { force: true }).catch(() => {});
+				throw retryError;
+			}
+		}
+	};
 	try {
 		if (configPath) {
 			const resolvedPath = existsSync(configPath) ? configPath : path.join(cwd, configPath);
@@ -1288,17 +1359,30 @@ const createAdmin = new Command("create-admin").description("Create an initial a
 function convertToSnakeCase(str, camelCase) {
 	return camelCase ? str : toSnakeCase(str);
 }
+function toValidIdentifier(str) {
+	let result = str.replace(/[^a-zA-Z0-9_]/g, "").replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/_/g, "").replace(/^[0-9]/, "_$&");
+	if (result.length > 0 && result[0].match(/[A-Z]/)) result = result[0].toLowerCase() + result.slice(1);
+	return result || "schema";
+}
 const generateDrizzleSchema = async ({ options, file, adapter }) => {
 	const tables = getAuthTables(options);
 	const filePath = file || "./auth-schema.ts";
 	const databaseType = adapter.options?.provider;
+	const schemaName = adapter.options?.schemaName;
 	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
+		options,
+		schemaName
 	});
+	let schemaVarName;
+	if (databaseType === "pg" && schemaName) {
+		schemaVarName = `${toValidIdentifier(schemaName)}Schema`;
+		if (schemaVarName === "pgSchema") schemaVarName = "pgCustomSchema";
+		code += `\nconst ${schemaVarName} = pgSchema(${JSON.stringify(schemaName)});\n\n`;
+	}
 	const getModelName = initGetModelName({
 		schema: tables,
 		usePlural: adapter.options?.adapterConfig?.usePlural
@@ -1316,12 +1400,18 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		const customModelName = table.modelName || tableKey;
 		return model === tableKey || model === customModelName || model === getModelName(tableKey) || model === getModelName(customModelName);
 	});
+	const resolvedIndexesByTable = resolveDatabaseSchemaIndexes(Object.keys(tables).filter((tableKey) => !isMigrationDisabled(tableKey)).map((tableKey) => ({
+		fields: tables[tableKey].fields,
+		indexes: tables[tableKey].indexes,
+		tableName: getModelName(tableKey)
+	})));
 	for (const tableKey in tables) {
 		const table = tables[tableKey];
 		if (isMigrationDisabled(tableKey)) continue;
 		const modelName = getModelName(tableKey);
 		const fields = table.fields;
-		function getType(name, field) {
+		const resolvedTableIndexes = resolvedIndexesByTable.get(modelName) ?? [];
+		function getType(name, field, tableIndexStringLength) {
 			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, adapter.options?.camelCase);
 			if (field.references?.field === "id") {
@@ -1347,7 +1437,7 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 				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}')`
+					mysql: tableIndexStringLength ? `varchar('${name}', { length: ${tableIndexStringLength} })` : 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' })`,
@@ -1396,30 +1486,35 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		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}),`);
+			for (const index of indexes) code.push(`  ${index.type}(${JSON.stringify(index.name)}).on(${index.on.map((fieldName) => `table.${fieldName}`).join(", ")}),`);
 			code.push(`]`);
 			return code.join("\n");
 		};
-		const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
+		for (const tableIndex of resolvedTableIndexes) indexes.push({
+			type: tableIndex.unique ? "uniqueIndex" : "index",
+			name: tableIndex.name,
+			on: tableIndex.columns
+		});
+		const schema = `export const ${modelName} = ${databaseType === "pg" && schemaName && schemaVarName ? `${schemaVarName}.table` : `${databaseType}Table`}("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
 					id: ${id},
 					${Object.keys(fields).map((field) => {
 			const attr = fields[field];
 			const fieldName = attr.fieldName || field;
-			let type = getType(fieldName, attr);
+			let type = getType(fieldName, attr, databaseType === "mysql" ? getDatabaseIndexStringLength({
+				columnName: fieldName,
+				dialect: "mysql",
+				fields,
+				indexes: resolvedTableIndexes
+			}) : void 0);
 			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
+				name: getDatabaseFieldIndexName(modelName, fieldName, false),
+				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("${attr.defaultValue}")`;
+			} 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}])`;
@@ -1444,12 +1539,25 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		const modelName = getModelName(tableKey);
 		const oneRelations = [];
 		const manyRelations = [];
-		const manyRelationsSet = /* @__PURE__ */ new Set();
 		const foreignFields = Object.entries(table.fields).filter(([_, field]) => field.references);
+		const foreignFieldCounts = /* @__PURE__ */ new Map();
+		for (const [_, field] of foreignFields) {
+			const referencedModel = getModelName(field.references.model);
+			foreignFieldCounts.set(referencedModel, (foreignFieldCounts.get(referencedModel) ?? 0) + 1);
+		}
+		const usedOneRelationKeys = /* @__PURE__ */ new Set();
 		for (const [fieldName, field] of foreignFields) {
 			const referencedModel = field.references.model;
 			if (isMigrationDisabled(referencedModel)) continue;
-			const relationKey = getSingularModelName(referencedModel);
+			const hasMultipleRelations = (foreignFieldCounts.get(getModelName(referencedModel)) ?? 0) > 1;
+			let relationKey = hasMultipleRelations ? fieldName.replace(/Id$/, "") : getSingularModelName(referencedModel);
+			if (usedOneRelationKeys.has(relationKey)) relationKey = fieldName;
+			if (usedOneRelationKeys.has(relationKey)) {
+				let suffix = 2;
+				while (usedOneRelationKeys.has(`${relationKey}_${suffix}`)) suffix++;
+				relationKey = `${relationKey}_${suffix}`;
+			}
+			usedOneRelationKeys.add(relationKey);
 			const fieldRef = `${getModelName(tableKey)}.${getFieldName({
 				model: tableKey,
 				field: fieldName
@@ -1462,81 +1570,49 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 				key: relationKey,
 				model: getModelName(referencedModel),
 				type: "one",
+				relationName: hasMultipleRelations ? `${getModelName(tableKey)}_${fieldName}` : void 0,
 				reference: {
 					field: fieldRef,
-					references: referenceRef,
-					fieldName
+					references: referenceRef
 				}
 			});
 		}
 		const otherModels = Object.entries(tables).filter(([modelName, otherTable]) => modelName !== tableKey && !otherTable.disableMigrations);
-		const modelRelationsMap = /* @__PURE__ */ new Map();
 		for (const [modelName, otherTable] of otherModels) {
 			const foreignKeysPointingHere = Object.entries(otherTable.fields).filter(([_, field]) => field.references?.model === tableKey || field.references?.model === getModelName(tableKey));
 			if (foreignKeysPointingHere.length === 0) continue;
-			const hasUnique = foreignKeysPointingHere.some(([_, field]) => !!field.unique);
-			const hasMany = foreignKeysPointingHere.some(([_, field]) => !field.unique);
-			modelRelationsMap.set(modelName, {
-				modelName,
-				hasUnique,
-				hasMany
-			});
-		}
-		for (const { modelName, hasMany } of modelRelationsMap.values()) {
-			const relationType = hasMany ? "many" : "one";
-			let relationKey = getModelName(modelName);
-			if (!adapter.options?.adapterConfig?.usePlural && relationType === "many") relationKey = `${relationKey}s`;
-			if (!manyRelationsSet.has(relationKey)) {
-				manyRelationsSet.add(relationKey);
+			for (const [fieldName, field] of foreignKeysPointingHere) {
+				const relationType = field.unique ? "one" : "many";
+				let relationKey = getModelName(modelName);
+				if (!adapter.options?.adapterConfig?.usePlural && relationType === "many") relationKey = `${relationKey}s`;
+				const hasMultipleRelations = foreignKeysPointingHere.length > 1;
+				if (hasMultipleRelations) relationKey = `${relationKey}By${fieldName.charAt(0).toUpperCase()}${fieldName.slice(1)}`;
 				manyRelations.push({
 					key: relationKey,
 					model: getModelName(modelName),
-					type: relationType
+					type: relationType,
+					relationName: hasMultipleRelations ? `${getModelName(modelName)}_${fieldName}` : void 0
 				});
 			}
 		}
-		const relationsByModel = /* @__PURE__ */ new Map();
-		for (const relation of oneRelations) if (relation.reference) {
-			const modelKey = relation.key;
-			if (!relationsByModel.has(modelKey)) relationsByModel.set(modelKey, []);
-			relationsByModel.get(modelKey).push(relation);
-		}
-		const duplicateRelations = [];
-		const singleRelations = [];
-		for (const [_modelKey, relations] of relationsByModel.entries()) if (relations.length > 1) duplicateRelations.push(...relations);
-		else singleRelations.push(relations[0]);
-		for (const relation of duplicateRelations) if (relation.reference) {
-			const fieldName = relation.reference.fieldName;
-			const tableRelation = `export const ${`${modelName}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Relations`} = relations(${getModelName(table.modelName)}, ({ one }) => ({
-				${relation.key}: one(${relation.model}, {
+		const hasForwardOne = oneRelations.length > 0;
+		const hasReverseOne = manyRelations.some((relation) => relation.type === "one");
+		const hasReverseMany = manyRelations.some((relation) => relation.type === "many");
+		const hasOne = hasForwardOne || hasReverseOne;
+		const hasMany = hasReverseMany;
+		const renderOneRelation = (relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
 					fields: [${relation.reference.field}],
 					references: [${relation.reference.references}],
-				})
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		}
-		const hasOne = singleRelations.length > 0;
-		const hasMany = manyRelations.length > 0;
-		if (hasOne && hasMany) {
-			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one, many }) => ({
-				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
-					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}],
-				})` : "").filter((x) => x !== "").join(",\n ")}${singleRelations.length > 0 && manyRelations.length > 0 ? "," : ""}
-				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		} else if (hasOne) {
-			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one }) => ({
-				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
-					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}],
-				})` : "").filter((x) => x !== "").join(",\n ")}
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		} else if (hasMany) {
-			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ many }) => ({
-				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
+					${relation.relationName ? `relationName: "${relation.relationName}",` : ""}
+				})` : "";
+		const renderReverseRelation = ({ key, model, type, relationName }) => {
+			return ` ${key}: ${type === "one" ? "one" : "many"}(${model}${relationName ? `, { relationName: "${relationName}" }` : ""})`;
+		};
+		if (hasOne || hasMany) {
+			const helpers = [hasOne ? "one" : null, hasMany ? "many" : null].filter(Boolean).join(", ");
+			const relationEntries = [...oneRelations.map(renderOneRelation).filter((x) => x !== ""), ...manyRelations.map(renderReverseRelation)].join(",\n ");
+			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ ${helpers} }) => ({
+				${relationEntries}
 			}))`;
 			relationsString += `\n${tableRelation}\n`;
 		}
@@ -1548,7 +1624,7 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		overwrite: fileExist
 	};
 };
-function generateImport({ databaseType, tables, options }) {
+function generateImport({ databaseType, tables, options, schemaName }) {
 	const rootImports = ["relations"];
 	const coreImports = [];
 	let hasBigint = false;
@@ -1562,7 +1638,8 @@ function generateImport({ databaseType, tables, options }) {
 	}
 	const useNumberId = options.advanced?.database?.generateId === "serial";
 	const useUUIDs = options.advanced?.database?.generateId === "uuid";
-	coreImports.push(`${databaseType}Table`);
+	if (databaseType === "pg" && schemaName) coreImports.push("pgSchema");
+	if (!(databaseType === "pg" && schemaName)) 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" : "");
@@ -1582,8 +1659,8 @@ function generateImport({ databaseType, tables, options }) {
 		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));
+	const hasIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.index && !field.unique) || (table.indexes?.some((index) => !index.unique) ?? false));
+	const hasUniqueIndexes = Object.values(tables).some((table) => table.indexes?.some((index) => index.unique) ?? false);
 	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`;
@@ -1702,11 +1779,58 @@ async function findMonorepoRoot(startDir) {
 }
 //#endregion
 //#region src/generators/prisma.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function parsePrismaStringLiteral(value) {
+	if (typeof value !== "string") return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		return typeof parsed === "string" ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function getPrismaIndexDefinition(property) {
+	if (!isRecord(property) || property.type !== "attribute" || property.kind !== "object" || property.name !== "index" && property.name !== "unique" || !Array.isArray(property.args)) return;
+	const propertyArgs = property.args;
+	let columns;
+	let mappedName;
+	let validFullColumns = false;
+	for (const argument of propertyArgs) {
+		if (!isRecord(argument) || !isRecord(argument.value)) continue;
+		const value = argument.value;
+		if (value.type === "array" && Array.isArray(value.args) && value.args.every((column) => typeof column === "string")) {
+			columns = value.args.map((column) => String(column));
+			validFullColumns = true;
+		} else if (value.type === "keyValue" && value.key === "map") mappedName = parsePrismaStringLiteral(value.value);
+	}
+	return {
+		columns: columns ?? [],
+		mappedName,
+		setMappedName(name) {
+			propertyArgs.push({
+				type: "attributeArgument",
+				value: {
+					type: "keyValue",
+					key: "map",
+					value: JSON.stringify(name)
+				}
+			});
+		},
+		unique: property.name === "unique",
+		validFullColumns
+	};
+}
+function prismaIndexMatches(existing, configured) {
+	return existing.validFullColumns && existing.unique === (configured.unique ?? false) && existing.columns.length === configured.columns.length && existing.columns.every((column, position) => column === configured.columns[position]);
+}
 const generatePrismaSchema = async ({ adapter, options, file }) => {
 	const provider = adapter.options?.provider || "postgresql";
 	const tables = getAuthTables(options);
 	const filePath = file || "./prisma/schema.prisma";
-	const schemaPrismaExist = existsSync(path.join(process.cwd(), filePath));
+	const resolvedFilePath = path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
+	const schemaPrismaExist = existsSync(resolvedFilePath);
 	const getModelName = initGetModelName({
 		schema: getAuthTables(options),
 		usePlural: adapter.options?.adapterConfig?.usePlural
@@ -1720,8 +1844,16 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 		const customModelName = table.modelName || tableKey;
 		return model === tableKey || model === customModelName || model === getModelName(tableKey) || model === getModelName(customModelName);
 	});
+	const resolvedIndexesByTable = resolveDatabaseSchemaIndexes(Object.keys(tables).filter((tableKey) => !isMigrationDisabled(tableKey)).map((tableKey) => {
+		const customModelName = tables[tableKey]?.modelName || tableKey;
+		return {
+			fields: tables[tableKey].fields,
+			indexes: tables[tableKey].indexes,
+			tableName: getModelName(customModelName)
+		};
+	}));
 	let schemaPrisma = "";
-	if (schemaPrismaExist) schemaPrisma = await fs$1.readFile(path.join(process.cwd(), filePath), "utf-8");
+	if (schemaPrismaExist) schemaPrisma = await fs$1.readFile(resolvedFilePath, "utf-8");
 	else schemaPrisma = getNewPrisma(provider, process.cwd());
 	const prismaVersion = getPrismaVersion(process.cwd());
 	if (prismaVersion && prismaVersion >= 7 && schemaPrismaExist) schemaPrisma = produceSchema(schemaPrisma, (builder) => {
@@ -1772,8 +1904,10 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 			const customModelName = tables[table]?.modelName || table;
 			const modelName = capitalizeFirstLetter(getModelName(customModelName));
 			const fields = tables[table]?.fields;
+			const resolvedTableIndexes = resolvedIndexesByTable.get(getModelName(customModelName)) ?? [];
 			function getType({ isBigint, isOptional, type }) {
 				if (type === "string") return isOptional ? "String?" : "String";
+				if (Array.isArray(type)) return isOptional ? "String?" : "String";
 				if (type === "number" && isBigint) return isOptional ? "BigInt?" : "BigInt";
 				if (type === "number") return isOptional ? "Int?" : "Int";
 				if (type === "boolean") return isOptional ? "Boolean?" : "Boolean";
@@ -1839,6 +1973,18 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 								isAlreadyExist.array = fieldTypeParts.isArray || void 0;
 							}
 						}
+						if (provider === "mysql" && (attr.type === "string" || Array.isArray(attr.type)) && typeof isAlreadyExist.fieldType === "string" && getFieldTypeParts(isAlreadyExist.fieldType).fieldType === "String") {
+							const tableIndexStringLength = getDatabaseIndexStringLength({
+								columnName: fieldName,
+								dialect: "mysql",
+								fields: fields ?? {},
+								indexes: resolvedTableIndexes
+							});
+							if (tableIndexStringLength) {
+								isAlreadyExist.attributes = isAlreadyExist.attributes?.filter((attribute) => attribute.group !== "db");
+								builder.model(modelName).field(fieldName).attribute(`db.VarChar(${tableIndexStringLength})`);
+							}
+						}
 						continue;
 					}
 				}
@@ -1906,7 +2052,31 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 					})}], onDelete: ${action})`;
 					builder.model(modelName).field(referencedCustomModelName.toLowerCase(), `${capitalizeFirstLetter(referencedCustomModelName)}${attr.required === false ? "?" : ""}`).attribute(relationField);
 				}
-				if (!attr.unique && !attr.references && provider === "mysql" && attr.type === "string") builder.model(modelName).field(fieldName).attribute("db.Text");
+				if (provider === "mysql" && (attr.type === "string" || Array.isArray(attr.type))) {
+					const tableIndexStringLength = getDatabaseIndexStringLength({
+						columnName: fieldName,
+						dialect: "mysql",
+						fields: fields ?? {},
+						indexes: resolvedTableIndexes
+					});
+					const nativeType = tableIndexStringLength ? `db.VarChar(${tableIndexStringLength})` : !attr.unique && !attr.references ? "db.Text" : void 0;
+					if (nativeType) builder.model(modelName).field(fieldName).attribute(nativeType);
+				}
+			}
+			for (const tableIndex of resolvedTableIndexes) {
+				const attributeName = tableIndex.unique ? "unique" : "index";
+				const existingIndexes = prismaModel?.properties.map(getPrismaIndexDefinition).filter((index) => index !== void 0) ?? [];
+				const existingMappedIndex = existingIndexes.find((index) => index.mappedName !== void 0 && getPortableDatabaseIdentifierKey(index.mappedName) === getPortableDatabaseIdentifierKey(tableIndex.name));
+				if (existingMappedIndex) {
+					if (!prismaIndexMatches(existingMappedIndex, tableIndex)) throw new BetterAuthError(`Prisma index "${tableIndex.name}" on model "${modelName}" does not match the configured fields and uniqueness. Rename or replace the existing index, then generate the schema again.`);
+					continue;
+				}
+				const existingUnmappedIndex = existingIndexes.find((index) => index.mappedName === void 0 && prismaIndexMatches(index, tableIndex));
+				if (existingUnmappedIndex) {
+					existingUnmappedIndex.setMappedName(tableIndex.name);
+					continue;
+				}
+				builder.model(modelName).blockAttribute(`${attributeName}([${tableIndex.columns.join(", ")}], map: ${JSON.stringify(tableIndex.name)})`);
 			}
 			if (manyToManyRelations.has(modelName)) for (const relatedModel of manyToManyRelations.get(modelName)) {
 				const relatedTableName = Object.keys(tables).find((key) => capitalizeFirstLetter(tables[key]?.modelName || key) === relatedModel);
@@ -2066,18 +2236,33 @@ async function generateAction(opts) {
 		console.error(`The directory "${cwd}" does not exist.`);
 		process.exit(1);
 	}
+	let outputIsDirectory = false;
+	if (options.output) try {
+		outputIsDirectory = (await fs$1.stat(path.resolve(cwd, options.output))).isDirectory();
+	} catch {}
+	const configOutputPath = options.output && !outputIsDirectory ? options.output : void 0;
+	const resolvedConfigOutputPath = configOutputPath ? path.resolve(cwd, configOutputPath) : void 0;
+	const outputExistedBefore = resolvedConfigOutputPath ? existsSync(resolvedConfigOutputPath) : true;
+	const removeGeneratedStub = async () => {
+		if (!resolvedConfigOutputPath || outputExistedBefore) return;
+		await fs$1.rm(resolvedConfigOutputPath, { force: true }).catch(() => {});
+	};
 	const config = await getConfig({
 		cwd,
-		configPath: options.config
+		configPath: options.config,
+		outputPath: configOutputPath
 	});
 	if (!config) {
+		await removeGeneratedStub();
 		console.error("No configuration file found. Add a `auth.ts` file to your project or pass the path to the configuration file using the `--config` flag.");
 		return;
 	}
+	await removeGeneratedStub();
 	let adapter;
 	if (options.adapter) adapter = createMockAdapter$1(options.adapter, options.dialect);
-	else adapter = await getAdapter(config).catch((e) => {
+	else adapter = await getAdapter(config).catch(async (e) => {
 		console.error(e.message);
+		await removeGeneratedStub();
 		process.exit(1);
 	});
 	options.output = await resolveSchemaOutputPath({
@@ -2085,14 +2270,16 @@ async function generateAction(opts) {
 		output: options.output,
 		adapterId: adapter.id
 	});
+	const resolvedOutputPath = options.output ? path.resolve(cwd, options.output) : void 0;
 	const spinner = yoctoSpinner({ text: "preparing schema..." }).start();
 	const schema = await generateSchema({
 		adapter,
-		file: options.output,
+		file: resolvedOutputPath ?? options.output,
 		options: config
 	});
 	spinner.stop();
 	if (!schema.code) {
+		await removeGeneratedStub();
 		console.log("Your schema is already up to date.");
 		try {
 			await (await createTelemetry(config)).publish({
@@ -2116,9 +2303,10 @@ async function generateAction(opts) {
 			message: `The file ${schema.fileName} already exists. Do you want to ${chalk.yellow(`${schema.overwrite ? "overwrite" : "append"}`)} the schema to the file?`
 		})).confirm;
 		if (confirm) {
-			if (!existsSync(path.join(cwd, schema.fileName))) await fs$1.mkdir(path.dirname(path.join(cwd, schema.fileName)), { recursive: true });
-			if (schema.overwrite) await fs$1.writeFile(path.join(cwd, schema.fileName), schema.code);
-			else await fs$1.appendFile(path.join(cwd, schema.fileName), schema.code);
+			const schemaPath = path.isAbsolute(schema.fileName) ? schema.fileName : path.join(cwd, schema.fileName);
+			if (!existsSync(schemaPath)) await fs$1.mkdir(path.dirname(schemaPath), { recursive: true });
+			if (schema.overwrite) await fs$1.writeFile(schemaPath, schema.code);
+			else await fs$1.appendFile(schemaPath, schema.code);
 			console.log(`🚀 Schema was ${schema.overwrite ? "overwritten" : "appended"} successfully!`);
 			try {
 				await (await createTelemetry(config)).publish({
@@ -2132,6 +2320,7 @@ async function generateAction(opts) {
 			process.exit(0);
 		} else {
 			console.error("Schema generation aborted.");
+			await removeGeneratedStub();
 			try {
 				await (await createTelemetry(config)).publish({
 					type: "cli_generate",
@@ -2156,6 +2345,7 @@ async function generateAction(opts) {
 	})).confirm;
 	if (!confirm) {
 		console.error("Schema generation aborted.");
+		await removeGeneratedStub();
 		try {
 			await (await createTelemetry(config)).publish({
 				type: "cli_generate",
@@ -2167,10 +2357,9 @@ async function generateAction(opts) {
 		} catch {}
 		process.exit(1);
 	}
-	if (!options.output) {
-		if (!existsSync(path.dirname(path.join(cwd, schema.fileName)))) await fs$1.mkdir(path.dirname(path.join(cwd, schema.fileName)), { recursive: true });
-	}
-	await fs$1.writeFile(options.output || path.join(cwd, schema.fileName), schema.code);
+	const writePath = resolvedOutputPath ?? path.join(cwd, schema.fileName);
+	if (!existsSync(path.dirname(writePath))) await fs$1.mkdir(path.dirname(writePath), { recursive: true });
+	await fs$1.writeFile(writePath, schema.code);
 	console.log(`🚀 Schema was generated successfully!`);
 	try {
 		await (await createTelemetry(config)).publish({
@@ -4762,26 +4951,6 @@ const tempPluginsConfig = {
 			}]
 		}
 	},
-	scim: {
-		displayName: "SCIM",
-		dependencies: ["@better-auth/scim"],
-		auth: {
-			function: "scim",
-			imports: [{
-				path: "@better-auth/scim",
-				imports: [createImport({ name: "scim" })],
-				isNamedImport: false
-			}]
-		},
-		authClient: {
-			function: "scimClient",
-			imports: [{
-				path: "@better-auth/scim/client",
-				imports: [createImport({ name: "scimClient" })],
-				isNamedImport: false
-			}]
-		}
-	},
 	sso: {
 		displayName: "SSO",
 		dependencies: ["@better-auth/sso"],
@@ -5194,11 +5363,12 @@ const getAuthPluginsCode = async ({ plugins, options = {}, installDependency })
 	const getArguments = await getArgumentsPrompt(options, plugins, "auth");
 	const pluginsCode = [];
 	for (const plugin of plugins) {
-		const args = convertArgumentsCodeToStringArray(await buildArgumentsCode(plugin.auth.arguments, getArguments, plugin.auth.function));
+		const argumentsCode = await buildArgumentsCode(plugin.auth.arguments, getArguments, plugin.auth.function);
+		const args = convertArgumentsCodeToStringArray(argumentsCode);
 		removeTrailingUndefined(args);
 		pluginsCode.push(`${plugin.auth.function}(${args.join(", ")})`);
-		const dependencies = new Set([...plugin.dependencies || [], ...plugin.auth.dependencies || []]);
-		const devDependencies = new Set([...plugin.devDependencies || [], ...plugin.auth.devDependencies || []]);
+		const dependencies = /* @__PURE__ */ new Set([...plugin.dependencies || [], ...plugin.auth.dependencies || []]);
+		const devDependencies = /* @__PURE__ */ new Set([...plugin.devDependencies || [], ...plugin.auth.devDependencies || []]);
 		if (dependencies.size > 0) await installDependency([...dependencies]);
 		if (devDependencies.size > 0) await installDependency([...devDependencies], "dev");
 	}
@@ -5212,11 +5382,12 @@ const getAuthClientPluginsCode = async ({ plugins, options = {}, installDependen
 	const pluginsCode = [];
 	for (const plugin of pluginsWithClient) {
 		if (!plugin.authClient) continue;
-		const args = convertArgumentsCodeToStringArray(await buildArgumentsCode(plugin.authClient.arguments, getArguments, plugin.authClient.function));
+		const argumentsCode = await buildArgumentsCode(plugin.authClient.arguments, getArguments, plugin.authClient.function);
+		const args = convertArgumentsCodeToStringArray(argumentsCode);
 		removeTrailingUndefined(args);
 		pluginsCode.push(`${plugin.authClient.function}(${args.join(", ")})`);
-		const dependencies = new Set([...plugin.dependencies || [], ...plugin.authClient.dependencies || []]);
-		const devDependencies = new Set([...plugin.devDependencies || [], ...plugin.authClient.devDependencies || []]);
+		const dependencies = /* @__PURE__ */ new Set([...plugin.dependencies || [], ...plugin.authClient.dependencies || []]);
+		const devDependencies = /* @__PURE__ */ new Set([...plugin.devDependencies || [], ...plugin.authClient.devDependencies || []]);
 		if (dependencies.size > 0) await installDependency([...dependencies]);
 		if (devDependencies.size > 0) await installDependency([...devDependencies], "dev");
 	}
@@ -6389,9 +6560,10 @@ export const auth = betterAuth({
 		}
 		databaseChoice = dbChoice || null;
 		if (databaseChoice === "yes") {
+			const availableORMs = getAvailableORMs();
 			const selectedOption = await select({
 				message: `Select the database you want to use:`,
-				options: getAvailableORMs().map((opt) => ({
+				options: availableORMs.map((opt) => ({
 					value: opt.adapter || opt.value,
 					label: opt.label
 				}))
@@ -6425,9 +6597,10 @@ export const auth = betterAuth({
 				database = sqliteVariants;
 			} else if (isDirectAdapter(selectedOption)) database = selectedOption;
 			else {
+				const availableDialects = getDialectsForORM(selectedOption);
 				const selectedDialect = await select({
 					message: `Select the database dialect:`,
-					options: getDialectsForORM(selectedOption).map((d) => ({
+					options: availableDialects.map((d) => ({
 						value: d.adapter,
 						label: d.label
 					}))
@@ -6445,7 +6618,7 @@ export const auth = betterAuth({
 				const { shouldInstallDeps } = await prompts({
 					type: "confirm",
 					name: "shouldInstallDeps",
-					message: `Would you like to install the following dependencies: ${[...new Set([...databaseConfig.dependencies, ...databaseConfig.devDependencies || []])].map((x) => chalk.cyan(x)).join(", ")}?`,
+					message: `Would you like to install the following dependencies: ${[.../* @__PURE__ */ new Set([...databaseConfig.dependencies, ...databaseConfig.devDependencies || []])].map((x) => chalk.cyan(x)).join(", ")}?`,
 					initial: true
 				});
 				if (isCancel(shouldInstallDeps)) {
@@ -7162,8 +7335,8 @@ async function migrateAction(opts) {
 		process.exit(1);
 	}
 	const spinner = yoctoSpinner({ text: "preparing migration..." }).start();
-	const { toBeAdded, toBeCreated, runMigrations } = await getMigrations(config);
-	if (!toBeAdded.length && !toBeCreated.length) {
+	const { toBeAdded, toBeAddedIndexes, toBeCreated, runMigrations } = await getMigrations(config);
+	if (!toBeAdded.length && !toBeAddedIndexes.length && !toBeCreated.length) {
 		spinner.stop();
 		console.log("🚀 No migrations needed.");
 		try {
@@ -7180,6 +7353,7 @@ async function migrateAction(opts) {
 	spinner.stop();
 	console.log(`🔑 The migration will affect the following:`);
 	for (const table of [...toBeCreated, ...toBeAdded]) console.log("->", chalk.magenta(Object.keys(table.fields).join(", ")), chalk.white("fields on"), chalk.yellow(`${table.table}`), chalk.white("table."));
+	for (const { index, table } of toBeAddedIndexes) console.log("->", chalk.magenta(index.columns.join(", ")), chalk.white(index.unique ? "fields in a unique index on" : "fields indexed on"), chalk.yellow(table), chalk.white("table."));
 	if (options.y) {
 		console.warn("WARNING: --y is deprecated. Consider -y or --yes");
 		options.yes = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auth",
-  "version": "1.7.0-rc.0",
+  "version": "1.7.0-rc.2",
   "description": "The CLI for Better Auth",
   "type": "module",
   "license": "MIT",
@@ -50,7 +50,7 @@
     "@babel/preset-react": "^7.28.5",
     "@babel/preset-typescript": "^7.28.5",
     "@better-auth/utils": "0.4.2",
-    "@clack/prompts": "^1.5.1",
+    "@clack/prompts": "^1.6.0",
     "@mrleebo/prisma-ast": "^0.16.0",
     "c12": "^4.0.0-beta.5",
     "chalk": "^5.6.2",
@@ -64,9 +64,9 @@
     "semver": "^7.8.4",
     "yocto-spinner": "^1.2.0",
     "zod": "^4.3.6",
-    "@better-auth/core": "1.7.0-rc.0",
-    "@better-auth/telemetry": "1.7.0-rc.0",
-    "better-auth": "1.7.0-rc.0"
+    "@better-auth/core": "1.7.0-rc.2",
+    "@better-auth/telemetry": "1.7.0-rc.2",
+    "better-auth": "1.7.0-rc.2"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
@@ -74,11 +74,11 @@
     "@types/semver": "^7.7.1",
     "better-sqlite3": "^12.11.1",
     "memfs": "^4.56.10",
-    "tsdown": "0.21.1",
+    "tsdown": "0.22.7",
     "tsx": "^4.21.0",
     "type-fest": "^5.7.0",
-    "typescript": "^5.9.3",
-    "@better-auth/passkey": "1.7.0-rc.0"
+    "typescript": "^6.0.3",
+    "@better-auth/passkey": "1.7.0-rc.2"
   },
   "scripts": {
     "build": "tsdown",