@better-auth/cli 1.4.0-beta.20 → 1.4.0-beta.21

package/dist/index.mjs

@@ -11,6 +11,7 @@ import path from "path";
 import prompts from "prompts";
 import yoctoSpinner from "yocto-spinner";
 import * as z from "zod/v4";
+import { initGetFieldName, initGetModelName } from "better-auth/adapters";
 import prettier, { format } from "prettier";
 import { produceSchema } from "@mrleebo/prisma-ast";
 import babelPresetReact from "@babel/preset-react";
@@ -45,9 +46,17 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		tables,
 		options
 	});
+	const getModelName = initGetModelName({
+		schema: tables,
+		usePlural: adapter.options?.adapterConfig?.usePlural
+	});
+	const getFieldName = initGetFieldName({
+		schema: tables,
+		usePlural: adapter.options?.adapterConfig?.usePlural
+	});
 	for (const tableKey in tables) {
 		const table = tables[tableKey];
-		const modelName = getModelName(table.modelName, adapter.options);
+		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`);
@@ -112,7 +121,7 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		let id = "";
 		const useNumberId = options.advanced?.database?.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 = `serial("id").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()`;
@@ -150,11 +159,61 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 			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(tables[attr.references.model]?.modelName || attr.references.model, adapter.options)}.${fields[attr.references.field]?.fieldName || attr.references.field}, { onDelete: '${attr.references.onDelete || "cascade"}' })` : ""}`;
+			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`;
 	}
+	let relationsString = "";
+	for (const tableKey in tables) {
+		const table = tables[tableKey];
+		const relations = [];
+		const foreignFields = Object.entries(table.fields).filter(([_, field]) => field.references);
+		for (const [fieldName, field] of foreignFields) {
+			const referencedModel = field.references.model;
+			relations.push({
+				key: getModelName(referencedModel),
+				model: getModelName(referencedModel),
+				type: "one",
+				reference: {
+					field: `${getModelName(tableKey)}.${getFieldName({
+						model: tableKey,
+						field: fieldName
+					})}`,
+					references: `${getModelName(referencedModel)}.${getFieldName({
+						model: referencedModel,
+						field: field.references.field || "id"
+					})}`
+				}
+			});
+		}
+		const otherModels = Object.entries(tables).filter(([modelName]) => modelName !== tableKey);
+		for (const [modelName, otherTable] of otherModels) {
+			const foreignKeysPointingHere = Object.entries(otherTable.fields).filter(([_, field]) => field.references?.model === tableKey || field.references?.model === getModelName(tableKey));
+			for (const [fieldName, field] of foreignKeysPointingHere) {
+				const isUnique = !!field.unique;
+				const relationKey = isUnique ? getModelName(modelName) : `${getModelName(modelName)}s`;
+				relations.push({
+					key: relationKey,
+					model: getModelName(modelName),
+					type: isUnique ? "one" : "many"
+				});
+			}
+		}
+		const hasOne = relations.some((relation) => relation.type === "one");
+		const hasMany = relations.some((relation) => relation.type === "many");
+		let tableRelation = `export const ${table.modelName}Relations = relations(${getModelName(table.modelName)}, ({ ${hasOne ? "one" : ""}${hasMany ? `${hasOne ? ", " : ""}many` : ""} }) => ({
+				${relations.map(({ key, type, model, reference }) => ` ${key}: ${type}(${model}${!reference ? "" : `, {
+								fields: [${reference.field}],
+								references: [${reference.references}],
+							}`})`).join(",\n ")}
+			}))`;
+		if (relations.length > 0) relationsString += `\n${tableRelation}\n`;
+	}
+	code += `\n${relationsString}`;
 	return {
 		code: await prettier.format(code, { parser: "typescript" }),
 		fileName: filePath,
@@ -162,7 +221,7 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 	};
 };
 function generateImport({ databaseType, tables, options }) {
-	const rootImports = [];
+	const rootImports = ["relations"];
 	const coreImports = [];
 	let hasBigint = false;
 	let hasJson = false;
@@ -189,10 +248,7 @@ function generateImport({ databaseType, tables, options }) {
 		const hasFkToId = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.references?.field === "id"));
 		if (hasNonBigintNumber || (options.advanced?.database?.useNumberId || options.advanced?.database?.generateId === "serial") && hasFkToId) coreImports.push("integer");
 	} else coreImports.push("integer");
-	if (databaseType === "pg") {
-		if (useNumberId) coreImports.push("serial");
-		else if (useUUIDs) coreImports.push("uuid");
-	}
+	if (databaseType === "pg" && useUUIDs) coreImports.push("uuid");
 	if (hasJson) {
 		if (databaseType === "pg") coreImports.push("jsonb");
 		if (databaseType === "mysql") coreImports.push("json");
@@ -204,9 +260,6 @@ function generateImport({ databaseType, tables, options }) {
 	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`;
 }
-function getModelName(modelName, options) {
-	return options?.usePlural ? `${modelName}s` : modelName;
-}
 
 //#endregion
 //#region src/generators/kysely.ts
@@ -278,9 +331,17 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 				const useNumberId = options.advanced?.database?.useNumberId || options.advanced?.database?.generateId === "serial";
 				const useUUIDs = options.advanced?.database?.generateId === "uuid";
 				if (useNumberId) builder.model(modelName).field("id", "Int").attribute("id").attribute("default(autoincrement())");
-				else if (useUUIDs && provider === "postgresql") builder.model(modelName).field("id", "String").attribute("id").attribute("db.Uuid").attribute("default(dbgenerated(\"pg_catalog.gen_random_uuid()\"))");
+				else if (useUUIDs && provider === "postgresql") builder.model(modelName).field("id", "String").attribute("id").attribute("default(dbgenerated(\"pg_catalog.gen_random_uuid()\"))").attribute("db.Uuid");
 				else builder.model(modelName).field("id", "String").attribute("id");
 			}
+			const getModelName = initGetModelName({
+				schema: getAuthTables(options),
+				usePlural: adapter.options?.adapterConfig?.usePlural
+			});
+			const getFieldName = initGetFieldName({
+				schema: getAuthTables(options),
+				usePlural: false
+			});
 			for (const field in fields) {
 				const attr = fields[field];
 				const fieldName = attr.fieldName || field;
@@ -345,25 +406,35 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 				if (field === "updatedAt" && attr.onUpdate) fieldBuilder.attribute("updatedAt");
 				else if (attr.onUpdate) {}
 				if (attr.references) {
-					if (useUUIDs && provider === "postgresql") fieldBuilder.attribute(`db.Uuid`);
-					const referencedOriginalModelName = attr.references.model;
+					if (useUUIDs && provider === "postgresql" && attr.references?.field === "id") builder.model(modelName).field(fieldName).attribute(`db.Uuid`);
+					const referencedOriginalModelName = getModelName(attr.references.model);
 					const referencedCustomModelName = tables[referencedOriginalModelName]?.modelName || referencedOriginalModelName;
 					let action = "Cascade";
 					if (attr.references.onDelete === "no action") action = "NoAction";
 					else if (attr.references.onDelete === "set null") action = "SetNull";
 					else if (attr.references.onDelete === "set default") action = "SetDefault";
 					else if (attr.references.onDelete === "restrict") action = "Restrict";
-					const relationField = `relation(fields: [${fieldName}], references: [${attr.references.field}], onDelete: ${action})`;
+					const relationField = `relation(fields: [${getFieldName({
+						model: originalTableName,
+						field: fieldName
+					})}], references: [${getFieldName({
+						model: attr.references.model,
+						field: attr.references.field
+					})}], onDelete: ${action})`;
 					builder.model(modelName).field(referencedCustomModelName.toLowerCase(), `${capitalizeFirstLetter(referencedCustomModelName)}${!attr.required ? "?" : ""}`).attribute(relationField);
 				}
 				if (!attr.unique && !attr.references && provider === "mysql" && attr.type === "string") builder.model(modelName).field(fieldName).attribute("db.Text");
 			}
 			if (manyToManyRelations.has(modelName)) for (const relatedModel of manyToManyRelations.get(modelName)) {
-				const fieldName = `${relatedModel.toLowerCase()}s`;
+				const relatedTableName = Object.keys(tables).find((key) => capitalizeFirstLetter(tables[key]?.modelName || key) === relatedModel);
+				const relatedFields = relatedTableName ? tables[relatedTableName]?.fields : {};
+				const [_fieldKey, fkFieldAttr] = Object.entries(relatedFields || {}).find(([_fieldName, fieldAttr]) => fieldAttr.references && getModelName(fieldAttr.references.model) === getModelName(originalTableName)) || [];
+				const isUnique = fkFieldAttr?.unique === true;
+				const fieldName = isUnique ? `${relatedModel.toLowerCase()}` : `${relatedModel.toLowerCase()}s`;
 				if (!builder.findByType("field", {
 					name: fieldName,
 					within: prismaModel?.properties
-				})) builder.model(modelName).field(fieldName, `${relatedModel}[]`);
+				})) builder.model(modelName).field(fieldName, `${relatedModel}${isUnique ? "?" : "[]"}`);
 			}
 			const indexedFieldsForModel = indexedFields.get(modelName);
 			if (indexedFieldsForModel && indexedFieldsForModel.length > 0) for (const fieldName of indexedFieldsForModel) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-auth/cli",
-  "version": "1.4.0-beta.20",
+  "version": "1.4.0-beta.21",
   "type": "module",
   "description": "The CLI for Better Auth",
   "module": "dist/index.mjs",
@@ -34,7 +34,7 @@
     "tsx": "^4.20.6",
     "type-fest": "^5.2.0",
     "typescript": "^5.9.3",
-    "@better-auth/passkey": "1.4.0-beta.20"
+    "@better-auth/passkey": "1.4.0-beta.21"
   },
   "dependencies": {
     "@babel/core": "^7.28.4",
@@ -62,8 +62,8 @@
     "tinyexec": "^0.3.2",
     "yocto-spinner": "^0.2.3",
     "zod": "^4.1.12",
-    "better-auth": "1.4.0-beta.20",
-    "@better-auth/core": "1.4.0-beta.20"
+    "better-auth": "1.4.0-beta.21",
+    "@better-auth/core": "1.4.0-beta.21"
   },
   "files": [
     "dist"