auth 1.7.0-beta.0 → 1.7.0-beta.10

package/README.md

@@ -1,7 +1,8 @@
 # Better Auth CLI
 
 Better Auth comes with a built-in CLI to help you manage the database schema
-needed for both core functionality and plugins.
+needed for both core functionality and plugins, and to create an initial admin user
+for projects using the Admin plugin.
 
 ### **Init**
 
@@ -34,6 +35,16 @@ tool.
 npx auth@latest migrate
 ```
 
+### **Create Admin**
+
+Create the first admin user for an app using the Admin plugin. The command
+uses your Better Auth config and prompts before creating an admin when users
+already exist. The created admin email is marked as verified by default.
+
+```bash title="terminal"
+npx auth@latest create-admin --email admin@example.com --name "Admin" --role admin
+```
+
 ### **Secret**
 
 The CLI also provides a way to generate a secret key for your Better Auth

package/dist/api.d.mts

@@ -26,7 +26,7 @@ declare const generateSchema: (opts: {
   adapter: DBAdapter$1;
   file?: string;
   options: BetterAuthOptions;
-}) => Promise<SchemaGeneratorResult> | Promise<{
+}) => Promise<SchemaGeneratorResult | {
   code: string;
   fileName: string;
   overwrite: boolean | undefined;

package/dist/api.mjs

@@ -1,16 +1,15 @@
 import { existsSync, readFileSync } from "node:fs";
+import { capitalizeFirstLetter, toSnakeCase } from "@better-auth/core/utils/string";
 import { initGetFieldName, initGetModelName } from "better-auth/adapters";
 import { getAuthTables } from "better-auth/db";
 import prettier from "prettier";
 import { getMigrations } from "better-auth/db/migration";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { capitalizeFirstLetter } from "@better-auth/core/utils/string";
 import { produceSchema } from "@mrleebo/prisma-ast";
 //#region src/generators/drizzle.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();
+	return camelCase ? str : toSnakeCase(str);
 }
 const generateDrizzleSchema = async ({ options, file, adapter }) => {
 	const tables = getAuthTables(options);
@@ -27,12 +26,22 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		schema: tables,
 		usePlural: adapter.options?.adapterConfig?.usePlural
 	});
+	const getSingularModelName = initGetModelName({
+		schema: tables,
+		usePlural: false
+	});
 	const getFieldName = initGetFieldName({
 		schema: tables,
 		usePlural: adapter.options?.adapterConfig?.usePlural
 	});
+	const isMigrationDisabled = (model) => Object.entries(tables).some(([tableKey, table]) => {
+		if (table.disableMigrations !== true) return false;
+		const customModelName = table.modelName || tableKey;
+		return model === tableKey || model === customModelName || model === getModelName(tableKey) || model === getModelName(customModelName);
+	});
 	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) {
@@ -52,9 +61,9 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 			}
 			const type = field.type;
 			if (typeof type !== "string") if (Array.isArray(type) && type.every((x) => typeof x === "string")) return {
-				sqlite: `text({ enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
+				sqlite: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
 				pg: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
-				mysql: `mysqlEnum([${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 = {
@@ -134,11 +143,16 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 				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 (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 !== false ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${attr.references ? `.references(()=> ${getModelName(attr.references.model)}.${getFieldName({
+			const referencesDisabledModel = attr.references && isMigrationDisabled(attr.references.model);
+			return `${fieldName}: ${type}${attr.required !== false ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${attr.references && !referencesDisabledModel ? `.references(()=> ${getModelName(attr.references.model)}.${getFieldName({
 				model: attr.references.model,
 				field: attr.references.field
 			})}, { onDelete: '${attr.references.onDelete || "cascade"}' })` : ""}`;
@@ -149,6 +163,7 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 	let relationsString = "";
 	for (const tableKey in tables) {
 		const table = tables[tableKey];
+		if (isMigrationDisabled(tableKey)) continue;
 		const modelName = getModelName(tableKey);
 		const oneRelations = [];
 		const manyRelations = [];
@@ -156,7 +171,8 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 		const foreignFields = Object.entries(table.fields).filter(([_, field]) => field.references);
 		for (const [fieldName, field] of foreignFields) {
 			const referencedModel = field.references.model;
-			const relationKey = getModelName(referencedModel);
+			if (isMigrationDisabled(referencedModel)) continue;
+			const relationKey = getSingularModelName(referencedModel);
 			const fieldRef = `${getModelName(tableKey)}.${getFieldName({
 				model: tableKey,
 				field: fieldName
@@ -176,7 +192,7 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
 				}
 			});
 		}
-		const otherModels = Object.entries(tables).filter(([modelName]) => modelName !== tableKey);
+		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));
@@ -337,6 +353,11 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 		schema: getAuthTables(options),
 		usePlural: false
 	});
+	const isMigrationDisabled = (model) => Object.entries(tables).some(([tableKey, table]) => {
+		if (table.disableMigrations !== true) return false;
+		const customModelName = table.modelName || tableKey;
+		return model === tableKey || model === customModelName || model === getModelName(tableKey) || model === getModelName(customModelName);
+	});
 	let schemaPrisma = "";
 	if (schemaPrismaExist) schemaPrisma = await fs.readFile(path.join(process.cwd(), filePath), "utf-8");
 	else schemaPrisma = getNewPrisma(provider, process.cwd());
@@ -355,11 +376,13 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 	});
 	const manyToManyRelations = /* @__PURE__ */ new Map();
 	for (const table in tables) {
+		if (isMigrationDisabled(table)) continue;
 		const fields = tables[table]?.fields;
 		for (const field in fields) {
 			const attr = fields[field];
 			if (attr.references) {
 				const referencedOriginalModel = attr.references.model;
+				if (isMigrationDisabled(referencedOriginalModel)) continue;
 				const referencedModelNameCap = capitalizeFirstLetter(getModelName(tables[referencedOriginalModel]?.modelName || referencedOriginalModel));
 				if (!manyToManyRelations.has(referencedModelNameCap)) manyToManyRelations.set(referencedModelNameCap, /* @__PURE__ */ new Set());
 				const currentModelNameCap = capitalizeFirstLetter(getModelName(tables[table]?.modelName || table));
@@ -382,6 +405,7 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 	}
 	const schema = produceSchema(schemaPrisma, (builder) => {
 		for (const table in tables) {
+			if (isMigrationDisabled(table)) continue;
 			const originalTableName = table;
 			const customModelName = tables[table]?.modelName || table;
 			const modelName = capitalizeFirstLetter(getModelName(customModelName));
@@ -405,6 +429,16 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 					return "Int[]";
 				}
 			}
+			function getFieldTypeParts(type) {
+				const isArray = type.endsWith("[]");
+				const typeWithoutArray = isArray ? type.slice(0, -2) : type;
+				const isOptional = typeWithoutArray.endsWith("?");
+				return {
+					fieldType: isOptional ? typeWithoutArray.slice(0, -1) : typeWithoutArray,
+					isArray,
+					isOptional
+				};
+			}
 			const prismaModel = builder.findByType("model", { name: modelName });
 			if (!prismaModel) if (provider === "mongodb") builder.model(modelName).field("id", "String").attribute("id").attribute(`map("_id")`);
 			else {
@@ -417,15 +451,9 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 			for (const field in fields) {
 				const attr = fields[field];
 				const fieldName = attr.fieldName || field;
-				if (prismaModel) {
-					if (builder.findByType("field", {
-						name: fieldName,
-						within: prismaModel.properties
-					})) continue;
-				}
 				const useUUIDs = options.advanced?.database?.generateId === "uuid";
 				const useNumberId = options.advanced?.database?.generateId === "serial";
-				const fieldBuilder = builder.model(modelName).field(fieldName, field === "id" && useNumberId ? getType({
+				const fieldType = field === "id" && useNumberId ? getType({
 					isBigint: false,
 					isOptional: false,
 					type: "number"
@@ -433,7 +461,27 @@ const generatePrismaSchema = async ({ adapter, options, file }) => {
 					isBigint: attr?.bigint || false,
 					isOptional: attr?.required === false,
 					type: attr.references?.field === "id" ? useNumberId ? "number" : "string" : attr.type
-				}));
+				});
+				if (prismaModel) {
+					const isAlreadyExist = builder.findByType("field", {
+						name: fieldName,
+						within: prismaModel.properties
+					});
+					if (isAlreadyExist) {
+						if (fieldType && typeof isAlreadyExist.fieldType === "string") {
+							const fieldTypeParts = getFieldTypeParts(fieldType);
+							const existingFieldTypeParts = getFieldTypeParts(isAlreadyExist.fieldType);
+							if ((existingFieldTypeParts.fieldType === "Int" || existingFieldTypeParts.fieldType === "BigInt") && (fieldTypeParts.fieldType === "Int" || fieldTypeParts.fieldType === "BigInt")) {
+								isAlreadyExist.fieldType = fieldTypeParts.fieldType;
+								isAlreadyExist.optional = fieldTypeParts.isOptional || void 0;
+								isAlreadyExist.array = fieldTypeParts.isArray || void 0;
+							}
+						}
+						continue;
+					}
+				}
+				if (!fieldType) throw new Error(`Unsupported Prisma field type for model "${modelName}", field "${fieldName}"${attr.type ? ` (source type: "${attr.type}")` : ""}.`);
+				const fieldBuilder = builder.model(modelName).field(fieldName, fieldType);
 				if (field === "id") {
 					fieldBuilder.attribute("id");
 					if (provider === "mongodb") fieldBuilder.attribute(`map("_id")`);
@@ -478,8 +526,9 @@ 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" && attr.references?.field === "id") builder.model(modelName).field(fieldName).attribute(`db.Uuid`);
 					const referencedOriginalModelName = getModelName(attr.references.model);
+					if (isMigrationDisabled(referencedOriginalModelName) || isMigrationDisabled(attr.references.model)) continue;
+					if (useUUIDs && provider === "postgresql" && attr.references?.field === "id") builder.model(modelName).field(fieldName).attribute(`db.Uuid`);
 					const referencedCustomModelName = tables[referencedOriginalModelName]?.modelName || referencedOriginalModelName;
 					let action = "Cascade";
 					if (attr.references.onDelete === "no action") action = "NoAction";
@@ -565,16 +614,16 @@ const adapters = {
 	drizzle: generateDrizzleSchema,
 	kysely: generateKyselySchema
 };
-const generateSchema = (opts) => {
+const generateSchema = async (opts) => {
 	const adapter = opts.adapter;
-	const generator = adapter.id in adapters ? adapters[adapter.id] : null;
-	if (generator) return generator(opts);
 	if (adapter.createSchema) return adapter.createSchema(opts.options, opts.file).then(({ code, path: fileName, overwrite }) => ({
 		code,
 		fileName,
 		overwrite
 	}));
-	throw new Error(`${adapter.id} is not supported. If it is a custom adapter, please request the maintainer to implement createSchema`);
+	const generator = adapters[adapter.id] ?? null;
+	if (generator) return await generator(opts);
+	throw new Error(`${adapter.id} is not supported. If it is a custom adapter, please request the maintainer to implement the "createSchema" method on the adapter.`);
 };
 //#endregion
 export { adapters, generateDrizzleSchema, generateKyselySchema, generatePrismaSchema, generateSchema };