auth 1.7.0-beta.2 → 1.7.0-beta.4

package/dist/index.mjs

@@ -10,22 +10,23 @@ import path, { join } from "node:path";
 import chalk from "chalk";
 import prompts from "prompts";
 import yoctoSpinner from "yocto-spinner";
+import { APIError, BetterAuthError } from "@better-auth/core/error";
+import { betterAuth } from "better-auth";
+import * as z from "zod";
+import babelPresetReact from "@babel/preset-react";
+import babelPresetTypeScript from "@babel/preset-typescript";
+import { loadConfig } from "c12";
+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 * as z from "zod";
+import { capitalizeFirstLetter, toSnakeCase } from "@better-auth/core/utils/string";
 import { initGetFieldName, initGetModelName } from "better-auth/adapters";
 import { getAuthTables } from "better-auth/db";
 import prettier, { format } from "prettier";
 import { getMigrations } from "better-auth/db/migration";
-import { capitalizeFirstLetter } from "@better-auth/core/utils/string";
 import { produceSchema } from "@mrleebo/prisma-ast";
 import Crypto from "node:crypto";
-import babelPresetReact from "@babel/preset-react";
-import babelPresetTypeScript from "@babel/preset-typescript";
-import { BetterAuthError } from "@better-auth/core/error";
-import { loadConfig } from "c12";
-import { createPathsMatcher, getTsconfig, parseTsconfig } from "get-tsconfig";
 import open from "open";
 import { env } from "@better-auth/core/env";
 import { log } from "@clack/prompts";
@@ -577,1139 +578,1237 @@ function showNextSteps(lines) {
 }
 const ai = new Command("ai").description("Interactive setup for Agent Auth — AI agent authentication").action(aiAction);
 //#endregion
-//#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();
+//#region src/utils/add-cloudflare-modules.ts
+const createModule = () => {
+	return `data:text/javascript;charset=utf-8,${encodeURIComponent(`
+const createStub = (label) => {
+  const handler = {
+    get(_, prop) {
+      if (prop === "toString") return () => label;
+      if (prop === "valueOf") return () => label;
+      if (prop === Symbol.toPrimitive) return () => label;
+      if (prop === Symbol.toStringTag) return "Object";
+      if (prop === "then") return undefined;
+      return createStub(label + "." + String(prop));
+    },
+    apply(_, __, args) {
+      return createStub(label + "()")
+    },
+    construct() {
+      return createStub(label + "#instance");
+    },
+  };
+  const fn = () => createStub(label + "()");
+  return new Proxy(fn, handler);
+};
+
+class WorkerEntrypoint {
+  constructor(ctx, env) {
+    this.ctx = ctx;
+    this.env = env;
+  }
 }
-const generateDrizzleSchema = async ({ options, file, adapter }) => {
-	const tables = getAuthTables(options);
-	const filePath = file || "./auth-schema.ts";
-	const databaseType = adapter.options?.provider;
-	if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
-	const fileExist = existsSync(filePath);
-	let code = generateImport({
-		databaseType,
-		tables,
-		options
-	});
-	const getModelName = initGetModelName({
-		schema: tables,
-		usePlural: 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(tableKey);
-		const fields = table.fields;
-		function getType(name, field) {
-			if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
-			name = convertToSnakeCase(name, adapter.options?.camelCase);
-			if (field.references?.field === "id") {
-				const useNumberId = options.advanced?.database?.generateId === "serial";
-				const useUUIDs = options.advanced?.database?.generateId === "uuid";
-				if (useNumberId) if (databaseType === "pg") return `integer('${name}')`;
-				else if (databaseType === "mysql") return `int('${name}')`;
-				else return `integer('${name}')`;
-				if (useUUIDs && databaseType === "pg") return `uuid('${name}')`;
-				if (field.references.field) {
-					if (databaseType === "mysql") return `varchar('${name}', { length: 36 })`;
+
+class DurableObject {
+  constructor(state, env) {
+    this.state = state;
+    this.env = env;
+  }
+}
+
+class RpcTarget {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+const RpcStub = RpcTarget;
+
+const env = createStub("env");
+const caches = createStub("caches");
+const scheduler = createStub("scheduler");
+const executionCtx = createStub("executionCtx");
+
+export { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, caches, env, executionCtx, scheduler };
+
+const defaultExport = {
+  DurableObject,
+  RpcStub,
+  RpcTarget,
+  WorkerEntrypoint,
+  caches,
+  env,
+  executionCtx,
+  scheduler,
+};
+
+export default defaultExport;
+// jiti dirty hack: .unknown
+`)}`;
+};
+const CLOUDFLARE_STUB_MODULE = createModule();
+function addCloudflareModules(aliases, _cwd) {
+	if (!aliases["cloudflare:workers"]) aliases["cloudflare:workers"] = CLOUDFLARE_STUB_MODULE;
+	if (!aliases["cloudflare:test"]) aliases["cloudflare:test"] = CLOUDFLARE_STUB_MODULE;
+}
+//#endregion
+//#region src/utils/add-svelte-kit-env-modules.ts
+/**
+* Adds SvelteKit environment modules and path aliases
+* @param aliases - The aliases object to populate
+* @param cwd - Current working directory (optional, defaults to process.cwd())
+*/
+function addSvelteKitEnvModules(aliases, cwd) {
+	const workingDir = cwd || process.cwd();
+	aliases["$env/dynamic/private"] = createDataUriModule(createDynamicEnvModule());
+	aliases["$env/dynamic/public"] = createDataUriModule(createDynamicEnvModule());
+	aliases["$env/static/private"] = createDataUriModule(createStaticEnvModule(filterPrivateEnv("PUBLIC_", "")));
+	aliases["$env/static/public"] = createDataUriModule(createStaticEnvModule(filterPublicEnv("PUBLIC_", "")));
+	const svelteKitAliases = getSvelteKitPathAliases(workingDir);
+	Object.assign(aliases, svelteKitAliases);
+}
+function getSvelteKitPathAliases(cwd) {
+	const aliases = {};
+	const packageJsonPath = path.join(cwd, "package.json");
+	const svelteConfigPath = path.join(cwd, "svelte.config.js");
+	const svelteConfigTsPath = path.join(cwd, "svelte.config.ts");
+	let isSvelteKitProject = false;
+	if (fs.existsSync(packageJsonPath)) try {
+		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		isSvelteKitProject = !!{
+			...packageJson.dependencies,
+			...packageJson.devDependencies
+		}["@sveltejs/kit"];
+	} catch {}
+	if (!isSvelteKitProject) isSvelteKitProject = fs.existsSync(svelteConfigPath) || fs.existsSync(svelteConfigTsPath);
+	if (!isSvelteKitProject) return aliases;
+	const libPaths = [path.join(cwd, "src", "lib"), path.join(cwd, "lib")];
+	for (const libPath of libPaths) if (fs.existsSync(libPath)) {
+		aliases["$lib"] = libPath;
+		for (const subPath of [
+			"server",
+			"utils",
+			"components",
+			"stores"
+		]) {
+			const subDir = path.join(libPath, subPath);
+			if (fs.existsSync(subDir)) aliases[`$lib/${subPath}`] = subDir;
+		}
+		break;
+	}
+	aliases["$app/server"] = createDataUriModule(createAppServerModule());
+	const customAliases = getSvelteConfigAliases(cwd);
+	Object.assign(aliases, customAliases);
+	return aliases;
+}
+function getSvelteConfigAliases(cwd) {
+	const aliases = {};
+	const configPaths = [path.join(cwd, "svelte.config.js"), path.join(cwd, "svelte.config.ts")];
+	for (const configPath of configPaths) if (fs.existsSync(configPath)) {
+		try {
+			const aliasMatch = fs.readFileSync(configPath, "utf-8").match(/alias\s*:\s*\{([^}]+)\}/);
+			if (aliasMatch && aliasMatch[1]) {
+				const aliasMatches = aliasMatch[1].matchAll(/['"`](\$[^'"`]+)['"`]\s*:\s*['"`]([^'"`]+)['"`]/g);
+				for (const match of aliasMatches) {
+					const [, alias, target] = match;
+					if (alias && target) {
+						aliases[alias + "/*"] = path.resolve(cwd, target) + "/*";
+						aliases[alias] = path.resolve(cwd, target);
+					}
 				}
-				return `text('${name}')`;
 			}
-			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(", ")}] })`,
-				pg: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
-				mysql: `mysqlEnum([${type.map((x) => `'${x}'`).join(", ")}])`
-			}[databaseType];
-			else throw new TypeError(`Invalid field type for field ${name} in model ${modelName}`);
-			const dbTypeMap = {
-				string: {
-					sqlite: `text('${name}')`,
-					pg: `text('${name}')`,
-					mysql: field.unique ? `varchar('${name}', { length: 255 })` : field.references ? `varchar('${name}', { length: 36 })` : field.sortable ? `varchar('${name}', { length: 255 })` : field.index ? `varchar('${name}', { length: 255 })` : `text('${name}')`
-				},
-				boolean: {
-					sqlite: `integer('${name}', { mode: 'boolean' })`,
-					pg: `boolean('${name}')`,
-					mysql: `boolean('${name}')`
-				},
-				number: {
-					sqlite: `integer('${name}')`,
-					pg: field.bigint ? `bigint('${name}', { mode: 'number' })` : `integer('${name}')`,
-					mysql: field.bigint ? `bigint('${name}', { mode: 'number' })` : `int('${name}')`
-				},
-				date: {
-					sqlite: `integer('${name}', { mode: 'timestamp_ms' })`,
-					pg: `timestamp('${name}')`,
-					mysql: `timestamp('${name}', { fsp: 3 })`
-				},
-				"number[]": {
-					sqlite: `text('${name}', { mode: "json" })`,
-					pg: field.bigint ? `bigint('${name}', { mode: 'number' }).array()` : `integer('${name}').array()`,
-					mysql: `text('${name}', { mode: 'json' })`
-				},
-				"string[]": {
-					sqlite: `text('${name}', { mode: "json" })`,
-					pg: `text('${name}').array()`,
-					mysql: `text('${name}', { mode: "json" })`
-				},
-				json: {
-					sqlite: `text('${name}', { mode: "json" })`,
-					pg: `jsonb('${name}')`,
-					mysql: `json('${name}', { mode: "json" })`
-				}
-			}[type];
-			if (!dbTypeMap) throw new Error(`Unsupported field type '${field.type}' for field '${name}'.`);
-			return dbTypeMap[databaseType];
-		}
-		let id = "";
-		const useNumberId = options.advanced?.database?.generateId === "serial";
-		if (options.advanced?.database?.generateId === "uuid" && databaseType === "pg") id = `uuid("id").default(sql\`pg_catalog.gen_random_uuid()\`).primaryKey()`;
-		else if (useNumberId) if (databaseType === "pg") id = `integer("id").generatedByDefaultAsIdentity().primaryKey()`;
-		else if (databaseType === "sqlite") id = `integer("id", { mode: "number" }).primaryKey({ autoIncrement: true })`;
-		else id = `int("id").autoincrement().primaryKey()`;
-		else if (databaseType === "mysql") id = `varchar('id', { length: 36 }).primaryKey()`;
-		else if (databaseType === "pg") id = `text('id').primaryKey()`;
-		else id = `text('id').primaryKey()`;
-		const indexes = [];
-		const assignIndexes = (indexes) => {
-			if (!indexes.length) return "";
-			const code = [`, (table) => [`];
-			for (const index of indexes) code.push(`  ${index.type}("${index.name}").on(table.${index.on}),`);
-			code.push(`]`);
-			return code.join("\n");
-		};
-		const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
-					id: ${id},
-					${Object.keys(fields).map((field) => {
-			const attr = fields[field];
-			const fieldName = attr.fieldName || field;
-			let type = getType(fieldName, attr);
-			if (attr.index && !attr.unique) indexes.push({
-				type: "index",
-				name: `${modelName}_${fieldName}_idx`,
-				on: fieldName
-			});
-			else if (attr.index && attr.unique) indexes.push({
-				type: "uniqueIndex",
-				name: `${modelName}_${fieldName}_uidx`,
-				on: fieldName
-			});
-			if (attr.defaultValue !== null && typeof attr.defaultValue !== "undefined") if (typeof attr.defaultValue === "function") {
-				if (attr.type === "date" && attr.defaultValue.toString().includes("new Date()")) if (databaseType === "sqlite") type += `.default(sql\`(cast(unixepoch('subsecond') * 1000 as integer))\`)`;
-				else type += `.defaultNow()`;
-			} else if (typeof attr.defaultValue === "string") type += `.default("${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({
-				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 modelName = getModelName(tableKey);
-		const oneRelations = [];
-		const manyRelations = [];
-		const manyRelationsSet = /* @__PURE__ */ new Set();
-		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);
-			const fieldRef = `${getModelName(tableKey)}.${getFieldName({
-				model: tableKey,
-				field: fieldName
-			})}`;
-			const referenceRef = `${getModelName(referencedModel)}.${getFieldName({
-				model: referencedModel,
-				field: field.references.field || "id"
-			})}`;
-			oneRelations.push({
-				key: relationKey,
-				model: getModelName(referencedModel),
-				type: "one",
-				reference: {
-					field: fieldRef,
-					references: referenceRef,
-					fieldName
-				}
-			});
-		}
-		const otherModels = Object.entries(tables).filter(([modelName]) => modelName !== tableKey);
-		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);
-				manyRelations.push({
-					key: relationKey,
-					model: getModelName(modelName),
-					type: relationType
-				});
-			}
-		}
-		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}, {
-					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 ")}
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		}
-	}
-	code += `\n${relationsString}`;
-	return {
-		code: await prettier.format(code, { parser: "typescript" }),
-		fileName: filePath,
-		overwrite: fileExist
-	};
-};
-function generateImport({ databaseType, tables, options }) {
-	const rootImports = ["relations"];
-	const coreImports = [];
-	let hasBigint = false;
-	let hasJson = false;
-	for (const table of Object.values(tables)) {
-		for (const field of Object.values(table.fields)) {
-			if (field.bigint) hasBigint = true;
-			if (field.type === "json") hasJson = true;
-		}
-		if (hasJson && hasBigint) break;
-	}
-	const useNumberId = options.advanced?.database?.generateId === "serial";
-	const useUUIDs = options.advanced?.database?.generateId === "uuid";
-	coreImports.push(`${databaseType}Table`);
-	coreImports.push(databaseType === "mysql" ? "varchar, text" : databaseType === "pg" ? "text" : "text");
-	coreImports.push(hasBigint ? databaseType !== "sqlite" ? "bigint" : "" : "");
-	coreImports.push(databaseType !== "sqlite" ? "timestamp, boolean" : "");
-	if (databaseType === "mysql") {
-		const hasNonBigintNumber = Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint));
-		if (useNumberId || hasNonBigintNumber) coreImports.push("int");
-		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => typeof field.type !== "string" && Array.isArray(field.type) && field.type.every((x) => typeof x === "string")))) coreImports.push("mysqlEnum");
-	} else if (databaseType === "pg") {
-		if (useUUIDs) rootImports.push("sql");
-		const hasNonBigintNumber = Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint));
-		const hasFkToId = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.references?.field === "id"));
-		if (hasNonBigintNumber || options.advanced?.database?.generateId === "serial" && hasFkToId) coreImports.push("integer");
-	} else coreImports.push("integer");
-	if (databaseType === "pg" && useUUIDs) coreImports.push("uuid");
-	if (hasJson) {
-		if (databaseType === "pg") coreImports.push("jsonb");
-		if (databaseType === "mysql") coreImports.push("json");
-	}
-	if (databaseType === "sqlite" && Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.type === "date" && field.defaultValue && typeof field.defaultValue === "function" && field.defaultValue.toString().includes("new Date()")))) rootImports.push("sql");
-	const hasIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.index && !field.unique));
-	const hasUniqueIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.unique && field.index));
-	if (hasIndexes) coreImports.push("index");
-	if (hasUniqueIndexes) coreImports.push("uniqueIndex");
-	return `${rootImports.length > 0 ? `import { ${rootImports.join(", ")} } from "drizzle-orm";\n` : ""}import { ${coreImports.map((x) => x.trim()).filter((x) => x !== "").join(", ")} } from "drizzle-orm/${databaseType}-core";\n`;
-}
-//#endregion
-//#region src/generators/kysely.ts
-const generateKyselySchema = async ({ options, file }) => {
-	const { compileMigrations } = await getMigrations(options);
-	const migrations = await compileMigrations();
-	return {
-		code: migrations.trim() === ";" ? "" : migrations,
-		fileName: file || `./better-auth_migrations/${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}.sql`
-	};
-};
-//#endregion
-//#region src/utils/helper.ts
-async function tryCatch(promise) {
-	try {
-		return {
-			data: await promise,
-			error: null
-		};
-	} catch (error) {
-		return {
-			data: null,
-			error
-		};
+		} catch {}
+		break;
 	}
+	return aliases;
 }
-const generateSecretHash = () => {
-	return Crypto.randomBytes(16).toString("hex");
-};
-const spawnCommand = (cmd, cwd = process.cwd()) => new Promise((resolve, reject) => {
-	const child = spawn(cmd, {
-		cwd,
-		stdio: "inherit",
-		shell: true
-	});
-	child.on("close", (code, signal) => {
-		if (code !== 0 && code !== null) reject(/* @__PURE__ */ new Error(`Exited with code ${code}`));
-		else if (signal) reject(/* @__PURE__ */ new Error(`Killed with signal ${signal}`));
-		else resolve();
-	});
-	child.on("error", reject);
-});
-//#endregion
-//#region src/utils/get-package-info.ts
-function getPackageInfo(cwd) {
-	const packageJsonPath = cwd ? path.join(cwd, "package.json") : path.join("package.json");
-	return JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+function createAppServerModule() {
+	return `
+// $app/server stub for CLI compatibility
+export default {};
+// jiti dirty hack: .unknown
+`;
 }
-function getPrismaVersion(cwd) {
-	try {
-		const packageInfo = getPackageInfo(cwd);
-		const prismaVersion = packageInfo.dependencies?.prisma || packageInfo.devDependencies?.prisma || packageInfo.dependencies?.["@prisma/client"] || packageInfo.devDependencies?.["@prisma/client"];
-		if (!prismaVersion) return null;
-		const match = prismaVersion.match(/(\d+)/);
-		return match ? parseInt(match[1], 10) : null;
-	} catch {
-		return null;
-	}
+function createDataUriModule(module) {
+	return `data:text/javascript;charset=utf-8,${encodeURIComponent(module)}`;
 }
-/**
-* Checks if a package has a specific dependency.
-*
-* @param packageJson The package.json object
-* @param dependency The dependency to check for
-* @returns true if the package has the dependency
-*/
-function hasDependency(packageJson, dependency) {
-	let hasDependency = false;
-	if (packageJson.dependencies?.[dependency] || packageJson.devDependencies?.[dependency] || packageJson.peerDependencies?.[dependency] || packageJson.optionalDependencies?.[dependency]) hasDependency = true;
-	return hasDependency;
+function createStaticEnvModule(env) {
+	return `
+  ${Object.keys(env).filter((k) => validIdentifier.test(k) && !reserved.has(k)).map((k) => `export const ${k} = ${JSON.stringify(env[k])};`).join("\n")}
+  // jiti dirty hack: .unknown
+  `;
 }
-/**
-* Checks if a directory is a monorepo root by looking for common monorepo indicators.
-*
-* @param dir Directory to check
-* @returns true if the directory appears to be a monorepo root
+function createDynamicEnvModule() {
+	return `
+  export const env = process.env;
+  // jiti dirty hack: .unknown
+  `;
+}
+function filterPrivateEnv(publicPrefix, privatePrefix) {
+	return Object.fromEntries(Object.entries(process.env).filter(([k]) => k.startsWith(privatePrefix) && (publicPrefix === "" || !k.startsWith(publicPrefix))));
+}
+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([
+	"do",
+	"if",
+	"in",
+	"for",
+	"let",
+	"new",
+	"try",
+	"var",
+	"case",
+	"else",
+	"enum",
+	"eval",
+	"null",
+	"this",
+	"true",
+	"void",
+	"with",
+	"await",
+	"break",
+	"catch",
+	"class",
+	"const",
+	"false",
+	"super",
+	"throw",
+	"while",
+	"yield",
+	"delete",
+	"export",
+	"import",
+	"public",
+	"return",
+	"static",
+	"switch",
+	"typeof",
+	"default",
+	"extends",
+	"finally",
+	"package",
+	"private",
+	"continue",
+	"debugger",
+	"function",
+	"arguments",
+	"interface",
+	"protected",
+	"implements",
+	"instanceof"
+]);
+//#endregion
+//#region src/utils/get-config.ts
+let possiblePaths$1 = [
+	"auth.ts",
+	"auth.tsx",
+	"auth.js",
+	"auth.jsx",
+	"auth.server.js",
+	"auth.server.ts",
+	"auth/index.ts",
+	"auth/index.tsx",
+	"auth/index.js",
+	"auth/index.jsx",
+	"auth/index.server.js",
+	"auth/index.server.ts"
+];
+possiblePaths$1 = [
+	...possiblePaths$1,
+	...possiblePaths$1.map((it) => `lib/server/${it}`),
+	...possiblePaths$1.map((it) => `server/auth/${it}`),
+	...possiblePaths$1.map((it) => `server/${it}`),
+	...possiblePaths$1.map((it) => `auth/${it}`),
+	...possiblePaths$1.map((it) => `lib/${it}`),
+	...possiblePaths$1.map((it) => `utils/${it}`)
+];
+possiblePaths$1 = [
+	...possiblePaths$1,
+	...possiblePaths$1.map((it) => `src/${it}`),
+	...possiblePaths$1.map((it) => `app/${it}`)
+];
+/** Reads `references` from raw tsconfig JSON (stripped out by `parseTsconfig`). */
+function readRawTsconfigReferences(tsconfigPath) {
+	try {
+		const stripped = fs.readFileSync(tsconfigPath, "utf-8").replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? "" : m).replace(/,(?=\s*[}\]])/g, "");
+		return JSON.parse(stripped).references;
+	} catch {
+		return;
+	}
+}
+/** Recursively collects tsconfigs reachable via `references`. */
+function collectReferencedTsconfigs(tsconfigPath, visited = /* @__PURE__ */ new Set()) {
+	const result = [];
+	const refs = readRawTsconfigReferences(tsconfigPath);
+	if (!refs) return result;
+	const configDir = path.dirname(tsconfigPath);
+	for (const ref of refs) {
+		const resolvedRef = path.resolve(configDir, ref.path);
+		const refTsconfigPath = resolvedRef.endsWith(".json") ? resolvedRef : path.join(resolvedRef, "tsconfig.json");
+		if (visited.has(refTsconfigPath)) continue;
+		visited.add(refTsconfigPath);
+		try {
+			const refConfig = parseTsconfig(refTsconfigPath);
+			result.push({
+				path: refTsconfigPath,
+				config: refConfig
+			});
+		} catch {
+			continue;
+		}
+		result.push(...collectReferencedTsconfigs(refTsconfigPath, visited));
+	}
+	return result;
+}
+/**
+* Ordered `paths` matchers from the project tsconfig and any referenced
+* tsconfigs, following TypeScript canonical resolution semantics.
+* @see https://github.com/microsoft/TypeScript/blob/main/src/compiler/moduleNameResolver.ts
 */
-async function isMonorepoRoot(dir) {
-	const { data: files } = await tryCatch(fs$1.readdir(dir, "utf-8"));
-	if (!files) return false;
-	if (files.includes("pnpm-workspace.yaml")) return true;
-	if (files.includes("package.json")) {
-		const packageJsonPath = path.join(dir, "package.json");
-		const { data } = await tryCatch(fs$1.readFile(packageJsonPath, "utf-8"));
-		if (data) try {
-			const packageJson = JSON.parse(data);
-			if (packageJson.workspaces && (Array.isArray(packageJson.workspaces) || typeof packageJson.workspaces === "object")) return true;
-		} catch {}
+function collectPathsMatchers(cwd) {
+	const tsconfig = getTsconfig(cwd, fs.existsSync(path.join(cwd, "tsconfig.json")) ? "tsconfig.json" : "jsconfig.json");
+	if (!tsconfig) return [];
+	const matchers = [];
+	try {
+		const mainMatcher = createPathsMatcher(tsconfig);
+		if (mainMatcher) matchers.push(mainMatcher);
+		for (const refTsconfig of collectReferencedTsconfigs(tsconfig.path)) {
+			const refMatcher = createPathsMatcher(refTsconfig);
+			if (refMatcher) matchers.push(refMatcher);
+		}
+	} catch (error) {
+		console.error(error);
+		throw new BetterAuthError("Error parsing tsconfig.json");
 	}
-	return [
-		"lerna.json",
-		"turbo.json",
-		"nx.json",
-		"rush.json"
-	].some((indicator) => files.includes(indicator));
+	return matchers;
 }
 /**
-* Finds the monorepo root by walking up the directory tree.
-*
-* @param startDir Starting directory
-* @returns Path to monorepo root, or null if not found
+* Source file extensions jiti can load. Shared between the jiti `extensions`
+* option and `resolveCandidateFile` so both stay in sync.
 */
-async function findMonorepoRoot(startDir) {
-	let currentDir = path.resolve(startDir);
-	const root = path.parse(currentDir).root;
-	while (currentDir !== root) {
-		if (await isMonorepoRoot(currentDir)) return currentDir;
-		const parentDir = path.dirname(currentDir);
-		if (parentDir === currentDir) break;
-		currentDir = parentDir;
+const SOURCE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+];
+const SOURCE_EXTENSIONS_SET = new Set(SOURCE_EXTENSIONS);
+/** Probes a candidate as-is, with known extensions, and as a directory index. */
+function resolveCandidateFile(candidate) {
+	try {
+		if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+	} catch {}
+	if (SOURCE_EXTENSIONS_SET.has(path.extname(candidate))) return;
+	for (const ext of SOURCE_EXTENSIONS) {
+		const withExt = candidate + ext;
+		if (fs.existsSync(withExt)) return withExt;
+	}
+	for (const ext of SOURCE_EXTENSIONS) {
+		const asIndex = path.join(candidate, `index${ext}`);
+		if (fs.existsSync(asIndex)) return asIndex;
 	}
-	return null;
 }
-//#endregion
-//#region src/generators/prisma.ts
-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 getModelName = initGetModelName({
-		schema: getAuthTables(options),
-		usePlural: adapter.options?.adapterConfig?.usePlural
-	});
-	const getFieldName = initGetFieldName({
-		schema: getAuthTables(options),
-		usePlural: false
-	});
-	let schemaPrisma = "";
-	if (schemaPrismaExist) schemaPrisma = await fs$1.readFile(path.join(process.cwd(), filePath), "utf-8");
-	else schemaPrisma = getNewPrisma(provider, process.cwd());
-	const prismaVersion = getPrismaVersion(process.cwd());
-	if (prismaVersion && prismaVersion >= 7 && schemaPrismaExist) schemaPrisma = produceSchema(schemaPrisma, (builder) => {
-		const generator = builder.findByType("generator", { name: "client" });
-		if (generator && generator.properties) {
-			const providerProp = generator.properties.find((prop) => prop.type === "assignment" && prop.key === "provider");
-			if (providerProp && providerProp.value === "\"prisma-client-js\"") providerProp.value = "\"prisma-client\"";
-		}
-		const datasource = builder.findByType("datasource", { name: "db" });
-		if (datasource && datasource.properties) {
-			const urlIndex = datasource.properties.findIndex((prop) => prop.type === "assignment" && prop.key === "url");
-			if (urlIndex !== -1) datasource.properties.splice(urlIndex, 1);
-		}
-	});
-	const manyToManyRelations = /* @__PURE__ */ new Map();
-	for (const table in tables) {
-		const fields = tables[table]?.fields;
-		for (const field in fields) {
-			const attr = fields[field];
-			if (attr.references) {
-				const referencedOriginalModel = attr.references.model;
-				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));
-				manyToManyRelations.get(referencedModelNameCap).add(currentModelNameCap);
-			}
-		}
+function resolveWithMatchers(specifier, matchers) {
+	for (const matcher of matchers) for (const candidate of matcher(specifier)) {
+		const resolved = resolveCandidateFile(candidate);
+		if (resolved) return resolved;
 	}
-	const indexedFields = /* @__PURE__ */ new Map();
-	for (const table in tables) {
-		const fields = tables[table]?.fields;
-		const modelName = capitalizeFirstLetter(getModelName(tables[table]?.modelName || table));
-		indexedFields.set(modelName, []);
-		for (const field in fields) {
-			const attr = fields[field];
-			if (attr.index && !attr.unique) {
-				const fieldName = attr.fieldName || field;
-				indexedFields.get(modelName).push(fieldName);
+}
+/**
+* Callees whose first string argument is a module specifier. `jitiImport` is
+* 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([
+	"require",
+	"import",
+	"jitiImport"
+]);
+/**
+* Rewrites aliased specifiers at AST level. Required because jiti's `alias`
+* option only supports prefix matching and cannot express mid-path wildcards.
+*
+* Matchers always take precedence over native resolution, mirroring
+* TypeScript's own `paths` → `node_modules` order.
+*/
+function createRewriteImportPathsPlugin(matchers) {
+	return ({ types: t }) => {
+		const rewrite = (source) => {
+			if (!source) return;
+			const resolved = resolveWithMatchers(source.value, matchers);
+			if (resolved) source.value = resolved;
+		};
+		return { visitor: {
+			ImportDeclaration(p) {
+				rewrite(p.node.source);
+			},
+			ExportNamedDeclaration(p) {
+				rewrite(p.node.source);
+			},
+			ExportAllDeclaration(p) {
+				rewrite(p.node.source);
+			},
+			ImportExpression(p) {
+				if (t.isStringLiteral(p.node.source)) rewrite(p.node.source);
+			},
+			CallExpression(p) {
+				const { callee, arguments: args } = p.node;
+				const first = args[0];
+				if (!t.isStringLiteral(first)) return;
+				if (!(t.isIdentifier(callee) && LOADER_IDENTIFIERS.has(callee.name) || t.isImport(callee))) return;
+				rewrite(first);
+			}
+		} };
+	};
+}
+/** Virtual module aliases; real tsconfig paths go through the babel plugin. */
+function getVirtualModuleAliases() {
+	const result = {};
+	addSvelteKitEnvModules(result);
+	addCloudflareModules(result);
+	return result;
+}
+/**
+* .tsx files are not supported by Jiti.
+*/
+const jitiOptions = (cwd) => {
+	const matchers = collectPathsMatchers(cwd);
+	const plugins = matchers.length > 0 ? [createRewriteImportPathsPlugin(matchers)] : [];
+	return {
+		transformOptions: { babel: {
+			presets: [[babelPresetTypeScript, {
+				isTSX: true,
+				allExtensions: true
+			}], [babelPresetReact, { runtime: "automatic" }]],
+			plugins
+		} },
+		extensions: [...SOURCE_EXTENSIONS],
+		alias: getVirtualModuleAliases()
+	};
+};
+/**
+* Picks the auth instance from the loaded module, supporting `export const auth`,
+* `export default auth`, and `export default { auth }`. Falls back to the raw
+* module as a defensive default.
+*/
+const resolveAuthModule = (mod) => {
+	const m = mod;
+	return m?.auth ?? m?.default?.auth ?? m?.default ?? 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 }) {
+	const fail = (message, error) => {
+		if (shouldThrowOnError) throw error instanceof Error ? error : new Error(message);
+		const log = `[#better-auth]: ${message}`;
+		if (error) console.error(log, error);
+		else console.error(log);
+		process.exit(1);
+	};
+	const load = (configFile) => loadConfig({
+		configFile,
+		dotenv: { fileName: [".env", ".env.local"] },
+		jitiOptions: jitiOptions(cwd),
+		resolveModule: resolveAuthModule,
+		cwd
+	});
+	try {
+		if (configPath) {
+			const resolvedPath = existsSync(configPath) ? configPath : path.join(cwd, configPath);
+			const { config } = await load(resolvedPath);
+			const options = config?.options;
+			if (!options) return fail(`Couldn't read your auth config in ${resolvedPath}. Make sure to default export your auth instance or to export as a variable named auth.`);
+			return options;
+		}
+		for (const possiblePath of possiblePaths$1) {
+			let config;
+			try {
+				({config} = await load(possiblePath));
+			} catch (e) {
+				if (isServerOnlyError(e)) return fail(SERVER_ONLY_HINT);
+				return fail("Couldn't read your auth config.", e);
 			}
+			if (Object.keys(config).length === 0) continue;
+			if (!config.options) return fail("Couldn't read your auth config. Make sure to default export your auth instance or to export as a variable named auth.");
+			return config.options;
 		}
+		return null;
+	} catch (e) {
+		if (isServerOnlyError(e)) return fail(SERVER_ONLY_HINT);
+		return fail("Couldn't read your auth config.", e);
 	}
-	const schema = produceSchema(schemaPrisma, (builder) => {
-		for (const table in tables) {
-			const originalTableName = table;
-			const customModelName = tables[table]?.modelName || table;
-			const modelName = capitalizeFirstLetter(getModelName(customModelName));
-			const fields = tables[table]?.fields;
-			function getType({ isBigint, isOptional, type }) {
-				if (type === "string") 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";
-				if (type === "date") return isOptional ? "DateTime?" : "DateTime";
-				if (type === "json") {
-					if (provider === "sqlite" || provider === "mysql") return isOptional ? "String?" : "String";
-					return isOptional ? "Json?" : "Json";
-				}
-				if (type === "string[]") {
-					if (provider === "sqlite" || provider === "mysql") return isOptional ? "String?" : "String";
-					return "String[]";
-				}
-				if (type === "number[]") {
-					if (provider === "sqlite" || provider === "mysql") return "String";
-					return "Int[]";
-				}
+}
+//#endregion
+//#region src/commands/create-admin.ts
+function exitWithError(message) {
+	console.error(chalk.red(`Error: ${message}`));
+	process.exit(1);
+}
+function parseData(data) {
+	if (!data) return void 0;
+	try {
+		const parsed = JSON.parse(data);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) exitWithError("--data must be a JSON object.");
+		return parsed;
+	} catch (error) {
+		if (error instanceof SyntaxError) exitWithError("--data must be valid JSON.");
+		throw error;
+	}
+}
+async function resolveRequiredInput(options) {
+	let { email, password } = options;
+	if (!email) email = (await prompts({
+		type: "text",
+		name: "email",
+		message: "Admin email"
+	})).email;
+	if (!password) password = (await prompts({
+		type: "password",
+		name: "password",
+		message: "Admin password"
+	})).password;
+	if (!email) exitWithError("Admin email is required.");
+	if (!password) exitWithError("Admin password is required.");
+	return {
+		email,
+		password
+	};
+}
+/** @internal */
+async function createAdminAction(opts) {
+	const options = z.object({
+		cwd: z.string(),
+		config: z.string().optional(),
+		email: z.string().optional(),
+		password: z.string().optional(),
+		name: z.string().default("Admin"),
+		role: z.string().default("admin"),
+		data: z.string().optional(),
+		emailVerified: z.boolean().default(true),
+		force: z.boolean().optional(),
+		y: z.boolean().optional(),
+		yes: z.boolean().optional()
+	}).parse(opts);
+	const cwd = path.resolve(options.cwd);
+	if (!existsSync(cwd)) exitWithError(`The directory "${cwd}" does not exist.`);
+	if (options.y) {
+		console.warn("WARNING: --y is deprecated. Consider -y or --yes");
+		options.yes = true;
+	}
+	const config = await getConfig({
+		cwd,
+		configPath: options.config
+	});
+	if (!config) exitWithError("No configuration file found. Add an `auth.ts` file to your project or pass the path to the configuration file using the `--config` flag.");
+	if (!config.database) exitWithError("No database is configured. Add a persistent database before creating an admin user.");
+	const auth = betterAuth(config);
+	const createUser = auth.api.createUser;
+	if (typeof createUser !== "function") exitWithError("The admin plugin is required. Add `admin()` to your Better Auth plugins before running this command.");
+	const { email, password } = await resolveRequiredInput(options);
+	if (!z.email().safeParse(email).success) exitWithError("Invalid email address.");
+	const data = {
+		...parseData(options.data),
+		emailVerified: options.emailVerified
+	};
+	try {
+		const totalUsers = await (await auth.$context).internalAdapter.countTotalUsers();
+		if (totalUsers > 0 && !options.force && !options.yes) {
+			if (!(await prompts({
+				type: "confirm",
+				name: "confirmed",
+				message: `Found ${totalUsers} existing user${totalUsers === 1 ? "" : "s"}. Create an admin user anyway?`,
+				initial: false
+			})).confirmed) {
+				console.log("Create admin cancelled.");
+				process.exit(0);
+				return;
 			}
-			const prismaModel = builder.findByType("model", { name: modelName });
-			if (!prismaModel) if (provider === "mongodb") builder.model(modelName).field("id", "String").attribute("id").attribute(`map("_id")`);
-			else {
+		}
+	} catch (error) {
+		exitWithError(`Failed to inspect existing users. Make sure your database is reachable and your Better Auth schema is migrated before running this command.${error instanceof Error ? `\n${error.message}` : ""}`);
+	}
+	try {
+		const result = await createUser({ body: {
+			email,
+			password,
+			name: options.name,
+			role: options.role,
+			data
+		} });
+		console.log(chalk.green("Admin user created successfully."));
+		if (result.user?.id) console.log(`User ID: ${result.user.id}`);
+		console.log(`Email: ${result.user?.email ?? email.toLowerCase()}`);
+		console.log(`Role: ${result.user?.role ?? options.role}`);
+		process.exit(0);
+	} catch (error) {
+		if (error instanceof APIError) exitWithError(error.message);
+		if (error instanceof Error) exitWithError(error.message);
+		exitWithError("Failed to create admin user.");
+	}
+}
+const createAdmin = new Command("create-admin").description("Create an initial admin user").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("--config <config>", "the path to the configuration file. defaults to the first configuration file found.").option("--email <email>", "the email address for the admin user").option("--password <password>", "the password for the admin user").option("--name <name>", "the name for the admin user", "Admin").option("--role <role>", "the role to assign to the user", "admin").option("--data <json>", "additional user fields as a JSON object").option("--no-email-verified", "create the admin user with an unverified email").option("--force", "create an admin user even when users already exist", false).option("-y, --yes", "automatically confirm creating an admin when users already exist", false).option("--y", "(deprecated) same as --yes", false).action(createAdminAction);
+//#endregion
+//#region src/generators/drizzle.ts
+function convertToSnakeCase(str, camelCase) {
+	return camelCase ? str : toSnakeCase(str);
+}
+const generateDrizzleSchema = async ({ options, file, adapter }) => {
+	const tables = getAuthTables(options);
+	const filePath = file || "./auth-schema.ts";
+	const databaseType = adapter.options?.provider;
+	if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
+	const fileExist = existsSync(filePath);
+	let code = generateImport({
+		databaseType,
+		tables,
+		options
+	});
+	const getModelName = initGetModelName({
+		schema: tables,
+		usePlural: 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(tableKey);
+		const fields = table.fields;
+		function getType(name, field) {
+			if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
+			name = convertToSnakeCase(name, adapter.options?.camelCase);
+			if (field.references?.field === "id") {
 				const 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("default(dbgenerated(\"pg_catalog.gen_random_uuid()\"))").attribute("db.Uuid");
-				else builder.model(modelName).field("id", "String").attribute("id");
+				if (useNumberId) if (databaseType === "pg") return `integer('${name}')`;
+				else if (databaseType === "mysql") return `int('${name}')`;
+				else return `integer('${name}')`;
+				if (useUUIDs && databaseType === "pg") return `uuid('${name}')`;
+				if (field.references.field) {
+					if (databaseType === "mysql") return `varchar('${name}', { length: 36 })`;
+				}
+				return `text('${name}')`;
 			}
-			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 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(", ")}] })`,
+				pg: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
+				mysql: `mysqlEnum([${type.map((x) => `'${x}'`).join(", ")}])`
+			}[databaseType];
+			else throw new TypeError(`Invalid field type for field ${name} in model ${modelName}`);
+			const dbTypeMap = {
+				string: {
+					sqlite: `text('${name}')`,
+					pg: `text('${name}')`,
+					mysql: field.unique ? `varchar('${name}', { length: 255 })` : field.references ? `varchar('${name}', { length: 36 })` : field.sortable ? `varchar('${name}', { length: 255 })` : field.index ? `varchar('${name}', { length: 255 })` : `text('${name}')`
+				},
+				boolean: {
+					sqlite: `integer('${name}', { mode: 'boolean' })`,
+					pg: `boolean('${name}')`,
+					mysql: `boolean('${name}')`
+				},
+				number: {
+					sqlite: `integer('${name}')`,
+					pg: field.bigint ? `bigint('${name}', { mode: 'number' })` : `integer('${name}')`,
+					mysql: field.bigint ? `bigint('${name}', { mode: 'number' })` : `int('${name}')`
+				},
+				date: {
+					sqlite: `integer('${name}', { mode: 'timestamp_ms' })`,
+					pg: `timestamp('${name}')`,
+					mysql: `timestamp('${name}', { fsp: 3 })`
+				},
+				"number[]": {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: field.bigint ? `bigint('${name}', { mode: 'number' }).array()` : `integer('${name}').array()`,
+					mysql: `text('${name}', { mode: 'json' })`
+				},
+				"string[]": {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: `text('${name}').array()`,
+					mysql: `text('${name}', { mode: "json" })`
+				},
+				json: {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: `jsonb('${name}')`,
+					mysql: `json('${name}', { mode: "json" })`
 				}
-				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({
-					isBigint: false,
-					isOptional: false,
-					type: "number"
-				}) : getType({
-					isBigint: attr?.bigint || false,
-					isOptional: attr?.required === false,
-					type: attr.references?.field === "id" ? useNumberId ? "number" : "string" : attr.type
-				}));
-				if (field === "id") {
-					fieldBuilder.attribute("id");
-					if (provider === "mongodb") fieldBuilder.attribute(`map("_id")`);
-				}
-				if (attr.unique) builder.model(modelName).blockAttribute(`unique([${fieldName}])`);
-				if (attr.defaultValue !== void 0) {
-					if (Array.isArray(attr.defaultValue)) {
-						if (attr.type === "json") {
-							if (Object.prototype.toString.call(attr.defaultValue[0]) === "[object Object]") {
-								fieldBuilder.attribute(`default("${JSON.stringify(attr.defaultValue).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}")`);
-								continue;
-							}
-							const jsonArray = [];
-							for (const value of attr.defaultValue) jsonArray.push(value);
-							fieldBuilder.attribute(`default("${JSON.stringify(jsonArray).replace(/"/g, "\\\"")}")`);
-							continue;
-						}
-						if (attr.defaultValue.length === 0) {
-							fieldBuilder.attribute(`default([])`);
-							continue;
-						} else if (typeof attr.defaultValue[0] === "string" && attr.type === "string[]") {
-							const valueArray = [];
-							for (const value of attr.defaultValue) valueArray.push(JSON.stringify(value));
-							fieldBuilder.attribute(`default([${valueArray}])`);
-						} else if (typeof attr.defaultValue[0] === "number") {
-							const valueArray = [];
-							for (const value of attr.defaultValue) valueArray.push(`${value}`);
-							fieldBuilder.attribute(`default([${valueArray}])`);
-						}
-					} else if (typeof attr.defaultValue === "object" && !Array.isArray(attr.defaultValue) && attr.defaultValue !== null) {
-						if (Object.entries(attr.defaultValue).length === 0) {
-							fieldBuilder.attribute(`default("{}")`);
-							continue;
-						}
-						fieldBuilder.attribute(`default("${JSON.stringify(attr.defaultValue).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}")`);
-					}
-					if (field === "createdAt") fieldBuilder.attribute("default(now())");
-					else if (typeof attr.defaultValue === "string" && provider !== "mysql") fieldBuilder.attribute(`default("${attr.defaultValue}")`);
-					else if (typeof attr.defaultValue === "boolean" || typeof attr.defaultValue === "number") fieldBuilder.attribute(`default(${attr.defaultValue})`);
-					else if (typeof attr.defaultValue === "function") {}
-				}
-				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);
-					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: [${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 === false ? "?" : ""}`).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 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 || adapter.options?.usePlural === true ? `${relatedModel.toLowerCase()}` : `${relatedModel.toLowerCase()}s`;
-				if (!builder.findByType("field", {
-					name: fieldName,
-					within: prismaModel?.properties
-				})) builder.model(modelName).field(fieldName, `${relatedModel}${isUnique ? "?" : "[]"}`);
+			}[type];
+			if (!dbTypeMap) throw new Error(`Unsupported field type '${field.type}' for field '${name}'.`);
+			return dbTypeMap[databaseType];
+		}
+		let id = "";
+		const useNumberId = options.advanced?.database?.generateId === "serial";
+		if (options.advanced?.database?.generateId === "uuid" && databaseType === "pg") id = `uuid("id").default(sql\`pg_catalog.gen_random_uuid()\`).primaryKey()`;
+		else if (useNumberId) if (databaseType === "pg") id = `integer("id").generatedByDefaultAsIdentity().primaryKey()`;
+		else if (databaseType === "sqlite") id = `integer("id", { mode: "number" }).primaryKey({ autoIncrement: true })`;
+		else id = `int("id").autoincrement().primaryKey()`;
+		else if (databaseType === "mysql") id = `varchar('id', { length: 36 }).primaryKey()`;
+		else if (databaseType === "pg") id = `text('id').primaryKey()`;
+		else id = `text('id').primaryKey()`;
+		const indexes = [];
+		const assignIndexes = (indexes) => {
+			if (!indexes.length) return "";
+			const code = [`, (table) => [`];
+			for (const index of indexes) code.push(`  ${index.type}("${index.name}").on(table.${index.on}),`);
+			code.push(`]`);
+			return code.join("\n");
+		};
+		const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
+					id: ${id},
+					${Object.keys(fields).map((field) => {
+			const attr = fields[field];
+			const fieldName = attr.fieldName || field;
+			let type = getType(fieldName, attr);
+			if (attr.index && !attr.unique) indexes.push({
+				type: "index",
+				name: `${modelName}_${fieldName}_idx`,
+				on: fieldName
+			});
+			else if (attr.index && attr.unique) indexes.push({
+				type: "uniqueIndex",
+				name: `${modelName}_${fieldName}_uidx`,
+				on: fieldName
+			});
+			if (attr.defaultValue !== null && typeof attr.defaultValue !== "undefined") if (typeof attr.defaultValue === "function") {
+				if (attr.type === "date" && attr.defaultValue.toString().includes("new Date()")) if (databaseType === "sqlite") type += `.default(sql\`(cast(unixepoch('subsecond') * 1000 as integer))\`)`;
+				else type += `.defaultNow()`;
+			} else if (typeof attr.defaultValue === "string") type += `.default("${attr.defaultValue}")`;
+			else type += `.default(${attr.defaultValue})`;
+			if (attr.onUpdate && attr.type === "date") {
+				if (typeof attr.onUpdate === "function") type += `.$onUpdate(${attr.onUpdate})`;
 			}
-			const indexedFieldsForModel = indexedFields.get(modelName);
-			if (indexedFieldsForModel && indexedFieldsForModel.length > 0) for (const fieldName of indexedFieldsForModel) {
-				if (prismaModel) {
-					if (prismaModel.properties.some((v) => v.type === "attribute" && v.name === "index" && JSON.stringify(v.args[0]?.value).includes(fieldName))) continue;
-				}
-				const field = Object.entries(fields).find(([key, attr]) => (attr.fieldName || key) === fieldName)?.[1];
-				let indexField = fieldName;
-				if (provider === "mysql" && field && field.type === "string") {
-					const useNumberId = options.advanced?.database?.generateId === "serial";
-					const useUUIDs = options.advanced?.database?.generateId === "uuid";
-					if (field.references?.field === "id" && (useNumberId || useUUIDs)) indexField = `${fieldName}`;
-					else indexField = `${fieldName}(length: 191)`;
+			return `${fieldName}: ${type}${attr.required !== false ? ".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 modelName = getModelName(tableKey);
+		const oneRelations = [];
+		const manyRelations = [];
+		const manyRelationsSet = /* @__PURE__ */ new Set();
+		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);
+			const fieldRef = `${getModelName(tableKey)}.${getFieldName({
+				model: tableKey,
+				field: fieldName
+			})}`;
+			const referenceRef = `${getModelName(referencedModel)}.${getFieldName({
+				model: referencedModel,
+				field: field.references.field || "id"
+			})}`;
+			oneRelations.push({
+				key: relationKey,
+				model: getModelName(referencedModel),
+				type: "one",
+				reference: {
+					field: fieldRef,
+					references: referenceRef,
+					fieldName
 				}
-				builder.model(modelName).blockAttribute(`index([${indexField}])`);
-			}
-			const hasAttribute = builder.findByType("attribute", {
-				name: "map",
-				within: prismaModel?.properties
 			});
-			const hasChanged = customModelName !== originalTableName;
-			if (!hasAttribute) builder.model(modelName).blockAttribute("map", `${getModelName(hasChanged ? customModelName : originalTableName)}`);
 		}
-	});
-	const schemaChanged = schema.trim() !== schemaPrisma.trim();
+		const otherModels = Object.entries(tables).filter(([modelName]) => modelName !== tableKey);
+		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);
+				manyRelations.push({
+					key: relationKey,
+					model: getModelName(modelName),
+					type: relationType
+				});
+			}
+		}
+		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}, {
+					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 ")}
+			}))`;
+			relationsString += `\n${tableRelation}\n`;
+		}
+	}
+	code += `\n${relationsString}`;
 	return {
-		code: schemaChanged ? schema : "",
+		code: await prettier.format(code, { parser: "typescript" }),
 		fileName: filePath,
-		overwrite: schemaPrismaExist && schemaChanged
+		overwrite: fileExist
 	};
 };
-const getNewPrisma = (provider, cwd) => {
-	const prismaVersion = getPrismaVersion(cwd);
-	const isV7 = prismaVersion && prismaVersion >= 7;
-	const clientProvider = isV7 ? "prisma-client" : "prisma-client-js";
-	if (isV7) return `generator client {
-    provider = "${clientProvider}"
-  }
-
-  datasource db {
-    provider = "${provider}"
-  }`;
-	return `generator client {
-    provider = "${clientProvider}"
-  }
-
-  datasource db {
-    provider = "${provider}"
-    url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
-  }`;
-};
-//#endregion
-//#region src/generators/index.ts
-const adapters = {
-	prisma: generatePrismaSchema,
-	drizzle: generateDrizzleSchema,
-	kysely: generateKyselySchema
-};
-const generateSchema = (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`);
-};
-//#endregion
-//#region src/utils/add-cloudflare-modules.ts
-const createModule = () => {
-	return `data:text/javascript;charset=utf-8,${encodeURIComponent(`
-const createStub = (label) => {
-  const handler = {
-    get(_, prop) {
-      if (prop === "toString") return () => label;
-      if (prop === "valueOf") return () => label;
-      if (prop === Symbol.toPrimitive) return () => label;
-      if (prop === Symbol.toStringTag) return "Object";
-      if (prop === "then") return undefined;
-      return createStub(label + "." + String(prop));
-    },
-    apply(_, __, args) {
-      return createStub(label + "()")
-    },
-    construct() {
-      return createStub(label + "#instance");
-    },
-  };
-  const fn = () => createStub(label + "()");
-  return new Proxy(fn, handler);
-};
-
-class WorkerEntrypoint {
-  constructor(ctx, env) {
-    this.ctx = ctx;
-    this.env = env;
-  }
-}
-
-class DurableObject {
-  constructor(state, env) {
-    this.state = state;
-    this.env = env;
-  }
-}
-
-class RpcTarget {
-  constructor(value) {
-    this.value = value;
-  }
-}
-
-const RpcStub = RpcTarget;
-
-const env = createStub("env");
-const caches = createStub("caches");
-const scheduler = createStub("scheduler");
-const executionCtx = createStub("executionCtx");
-
-export { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, caches, env, executionCtx, scheduler };
-
-const defaultExport = {
-  DurableObject,
-  RpcStub,
-  RpcTarget,
-  WorkerEntrypoint,
-  caches,
-  env,
-  executionCtx,
-  scheduler,
-};
-
-export default defaultExport;
-// jiti dirty hack: .unknown
-`)}`;
-};
-const CLOUDFLARE_STUB_MODULE = createModule();
-function addCloudflareModules(aliases, _cwd) {
-	if (!aliases["cloudflare:workers"]) aliases["cloudflare:workers"] = CLOUDFLARE_STUB_MODULE;
-	if (!aliases["cloudflare:test"]) aliases["cloudflare:test"] = CLOUDFLARE_STUB_MODULE;
-}
-//#endregion
-//#region src/utils/add-svelte-kit-env-modules.ts
-/**
-* Adds SvelteKit environment modules and path aliases
-* @param aliases - The aliases object to populate
-* @param cwd - Current working directory (optional, defaults to process.cwd())
-*/
-function addSvelteKitEnvModules(aliases, cwd) {
-	const workingDir = cwd || process.cwd();
-	aliases["$env/dynamic/private"] = createDataUriModule(createDynamicEnvModule());
-	aliases["$env/dynamic/public"] = createDataUriModule(createDynamicEnvModule());
-	aliases["$env/static/private"] = createDataUriModule(createStaticEnvModule(filterPrivateEnv("PUBLIC_", "")));
-	aliases["$env/static/public"] = createDataUriModule(createStaticEnvModule(filterPublicEnv("PUBLIC_", "")));
-	const svelteKitAliases = getSvelteKitPathAliases(workingDir);
-	Object.assign(aliases, svelteKitAliases);
-}
-function getSvelteKitPathAliases(cwd) {
-	const aliases = {};
-	const packageJsonPath = path.join(cwd, "package.json");
-	const svelteConfigPath = path.join(cwd, "svelte.config.js");
-	const svelteConfigTsPath = path.join(cwd, "svelte.config.ts");
-	let isSvelteKitProject = false;
-	if (fs.existsSync(packageJsonPath)) try {
-		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-		isSvelteKitProject = !!{
-			...packageJson.dependencies,
-			...packageJson.devDependencies
-		}["@sveltejs/kit"];
-	} catch {}
-	if (!isSvelteKitProject) isSvelteKitProject = fs.existsSync(svelteConfigPath) || fs.existsSync(svelteConfigTsPath);
-	if (!isSvelteKitProject) return aliases;
-	const libPaths = [path.join(cwd, "src", "lib"), path.join(cwd, "lib")];
-	for (const libPath of libPaths) if (fs.existsSync(libPath)) {
-		aliases["$lib"] = libPath;
-		for (const subPath of [
-			"server",
-			"utils",
-			"components",
-			"stores"
-		]) {
-			const subDir = path.join(libPath, subPath);
-			if (fs.existsSync(subDir)) aliases[`$lib/${subPath}`] = subDir;
+function generateImport({ databaseType, tables, options }) {
+	const rootImports = ["relations"];
+	const coreImports = [];
+	let hasBigint = false;
+	let hasJson = false;
+	for (const table of Object.values(tables)) {
+		for (const field of Object.values(table.fields)) {
+			if (field.bigint) hasBigint = true;
+			if (field.type === "json") hasJson = true;
 		}
-		break;
-	}
-	aliases["$app/server"] = createDataUriModule(createAppServerModule());
-	const customAliases = getSvelteConfigAliases(cwd);
-	Object.assign(aliases, customAliases);
-	return aliases;
-}
-function getSvelteConfigAliases(cwd) {
-	const aliases = {};
-	const configPaths = [path.join(cwd, "svelte.config.js"), path.join(cwd, "svelte.config.ts")];
-	for (const configPath of configPaths) if (fs.existsSync(configPath)) {
-		try {
-			const aliasMatch = fs.readFileSync(configPath, "utf-8").match(/alias\s*:\s*\{([^}]+)\}/);
-			if (aliasMatch && aliasMatch[1]) {
-				const aliasMatches = aliasMatch[1].matchAll(/['"`](\$[^'"`]+)['"`]\s*:\s*['"`]([^'"`]+)['"`]/g);
-				for (const match of aliasMatches) {
-					const [, alias, target] = match;
-					if (alias && target) {
-						aliases[alias + "/*"] = path.resolve(cwd, target) + "/*";
-						aliases[alias] = path.resolve(cwd, target);
-					}
-				}
-			}
-		} catch {}
-		break;
-	}
-	return aliases;
-}
-function createAppServerModule() {
-	return `
-// $app/server stub for CLI compatibility
-export default {};
-// jiti dirty hack: .unknown
-`;
-}
-function createDataUriModule(module) {
-	return `data:text/javascript;charset=utf-8,${encodeURIComponent(module)}`;
-}
-function createStaticEnvModule(env) {
-	return `
-  ${Object.keys(env).filter((k) => validIdentifier.test(k) && !reserved.has(k)).map((k) => `export const ${k} = ${JSON.stringify(env[k])};`).join("\n")}
-  // jiti dirty hack: .unknown
-  `;
-}
-function createDynamicEnvModule() {
-	return `
-  export const env = process.env;
-  // jiti dirty hack: .unknown
-  `;
-}
-function filterPrivateEnv(publicPrefix, privatePrefix) {
-	return Object.fromEntries(Object.entries(process.env).filter(([k]) => k.startsWith(privatePrefix) && (publicPrefix === "" || !k.startsWith(publicPrefix))));
-}
-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([
-	"do",
-	"if",
-	"in",
-	"for",
-	"let",
-	"new",
-	"try",
-	"var",
-	"case",
-	"else",
-	"enum",
-	"eval",
-	"null",
-	"this",
-	"true",
-	"void",
-	"with",
-	"await",
-	"break",
-	"catch",
-	"class",
-	"const",
-	"false",
-	"super",
-	"throw",
-	"while",
-	"yield",
-	"delete",
-	"export",
-	"import",
-	"public",
-	"return",
-	"static",
-	"switch",
-	"typeof",
-	"default",
-	"extends",
-	"finally",
-	"package",
-	"private",
-	"continue",
-	"debugger",
-	"function",
-	"arguments",
-	"interface",
-	"protected",
-	"implements",
-	"instanceof"
-]);
-//#endregion
-//#region src/utils/get-config.ts
-let possiblePaths$1 = [
-	"auth.ts",
-	"auth.tsx",
-	"auth.js",
-	"auth.jsx",
-	"auth.server.js",
-	"auth.server.ts",
-	"auth/index.ts",
-	"auth/index.tsx",
-	"auth/index.js",
-	"auth/index.jsx",
-	"auth/index.server.js",
-	"auth/index.server.ts"
-];
-possiblePaths$1 = [
-	...possiblePaths$1,
-	...possiblePaths$1.map((it) => `lib/server/${it}`),
-	...possiblePaths$1.map((it) => `server/auth/${it}`),
-	...possiblePaths$1.map((it) => `server/${it}`),
-	...possiblePaths$1.map((it) => `auth/${it}`),
-	...possiblePaths$1.map((it) => `lib/${it}`),
-	...possiblePaths$1.map((it) => `utils/${it}`)
-];
-possiblePaths$1 = [
-	...possiblePaths$1,
-	...possiblePaths$1.map((it) => `src/${it}`),
-	...possiblePaths$1.map((it) => `app/${it}`)
-];
-/** Reads `references` from raw tsconfig JSON (stripped out by `parseTsconfig`). */
-function readRawTsconfigReferences(tsconfigPath) {
-	try {
-		const stripped = fs.readFileSync(tsconfigPath, "utf-8").replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? "" : m).replace(/,(?=\s*[}\]])/g, "");
-		return JSON.parse(stripped).references;
-	} catch {
-		return;
+		if (hasJson && hasBigint) break;
 	}
-}
-/** Recursively collects tsconfigs reachable via `references`. */
-function collectReferencedTsconfigs(tsconfigPath, visited = /* @__PURE__ */ new Set()) {
-	const result = [];
-	const refs = readRawTsconfigReferences(tsconfigPath);
-	if (!refs) return result;
-	const configDir = path.dirname(tsconfigPath);
-	for (const ref of refs) {
-		const resolvedRef = path.resolve(configDir, ref.path);
-		const refTsconfigPath = resolvedRef.endsWith(".json") ? resolvedRef : path.join(resolvedRef, "tsconfig.json");
-		if (visited.has(refTsconfigPath)) continue;
-		visited.add(refTsconfigPath);
-		try {
-			const refConfig = parseTsconfig(refTsconfigPath);
-			result.push({
-				path: refTsconfigPath,
-				config: refConfig
-			});
-		} catch {
-			continue;
-		}
-		result.push(...collectReferencedTsconfigs(refTsconfigPath, visited));
+	const useNumberId = options.advanced?.database?.generateId === "serial";
+	const useUUIDs = options.advanced?.database?.generateId === "uuid";
+	coreImports.push(`${databaseType}Table`);
+	coreImports.push(databaseType === "mysql" ? "varchar, text" : databaseType === "pg" ? "text" : "text");
+	coreImports.push(hasBigint ? databaseType !== "sqlite" ? "bigint" : "" : "");
+	coreImports.push(databaseType !== "sqlite" ? "timestamp, boolean" : "");
+	if (databaseType === "mysql") {
+		const hasNonBigintNumber = Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint));
+		if (useNumberId || hasNonBigintNumber) coreImports.push("int");
+		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => typeof field.type !== "string" && Array.isArray(field.type) && field.type.every((x) => typeof x === "string")))) coreImports.push("mysqlEnum");
+	} else if (databaseType === "pg") {
+		if (useUUIDs) rootImports.push("sql");
+		const hasNonBigintNumber = Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint));
+		const hasFkToId = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.references?.field === "id"));
+		if (hasNonBigintNumber || options.advanced?.database?.generateId === "serial" && hasFkToId) coreImports.push("integer");
+	} else coreImports.push("integer");
+	if (databaseType === "pg" && useUUIDs) coreImports.push("uuid");
+	if (hasJson) {
+		if (databaseType === "pg") coreImports.push("jsonb");
+		if (databaseType === "mysql") coreImports.push("json");
 	}
-	return result;
+	if (databaseType === "sqlite" && Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.type === "date" && field.defaultValue && typeof field.defaultValue === "function" && field.defaultValue.toString().includes("new Date()")))) rootImports.push("sql");
+	const hasIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.index && !field.unique));
+	const hasUniqueIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.unique && field.index));
+	if (hasIndexes) coreImports.push("index");
+	if (hasUniqueIndexes) coreImports.push("uniqueIndex");
+	return `${rootImports.length > 0 ? `import { ${rootImports.join(", ")} } from "drizzle-orm";\n` : ""}import { ${coreImports.map((x) => x.trim()).filter((x) => x !== "").join(", ")} } from "drizzle-orm/${databaseType}-core";\n`;
 }
-/**
-* Ordered `paths` matchers from the project tsconfig and any referenced
-* tsconfigs, following TypeScript canonical resolution semantics.
-* @see https://github.com/microsoft/TypeScript/blob/main/src/compiler/moduleNameResolver.ts
-*/
-function collectPathsMatchers(cwd) {
-	const tsconfig = getTsconfig(cwd, fs.existsSync(path.join(cwd, "tsconfig.json")) ? "tsconfig.json" : "jsconfig.json");
-	if (!tsconfig) return [];
-	const matchers = [];
+//#endregion
+//#region src/generators/kysely.ts
+const generateKyselySchema = async ({ options, file }) => {
+	const { compileMigrations } = await getMigrations(options);
+	const migrations = await compileMigrations();
+	return {
+		code: migrations.trim() === ";" ? "" : migrations,
+		fileName: file || `./better-auth_migrations/${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}.sql`
+	};
+};
+//#endregion
+//#region src/utils/helper.ts
+async function tryCatch(promise) {
 	try {
-		const mainMatcher = createPathsMatcher(tsconfig);
-		if (mainMatcher) matchers.push(mainMatcher);
-		for (const refTsconfig of collectReferencedTsconfigs(tsconfig.path)) {
-			const refMatcher = createPathsMatcher(refTsconfig);
-			if (refMatcher) matchers.push(refMatcher);
-		}
+		return {
+			data: await promise,
+			error: null
+		};
 	} catch (error) {
-		console.error(error);
-		throw new BetterAuthError("Error parsing tsconfig.json");
+		return {
+			data: null,
+			error
+		};
 	}
-	return matchers;
 }
-/**
-* Source file extensions jiti can load. Shared between the jiti `extensions`
-* option and `resolveCandidateFile` so both stay in sync.
-*/
-const SOURCE_EXTENSIONS = [
-	".ts",
-	".tsx",
-	".mts",
-	".cts",
-	".js",
-	".jsx",
-	".mjs",
-	".cjs"
-];
-const SOURCE_EXTENSIONS_SET = new Set(SOURCE_EXTENSIONS);
-/** Probes a candidate as-is, with known extensions, and as a directory index. */
-function resolveCandidateFile(candidate) {
-	try {
-		if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
-	} catch {}
-	if (SOURCE_EXTENSIONS_SET.has(path.extname(candidate))) return;
-	for (const ext of SOURCE_EXTENSIONS) {
-		const withExt = candidate + ext;
-		if (fs.existsSync(withExt)) return withExt;
-	}
-	for (const ext of SOURCE_EXTENSIONS) {
-		const asIndex = path.join(candidate, `index${ext}`);
-		if (fs.existsSync(asIndex)) return asIndex;
-	}
+const generateSecretHash = () => {
+	return Crypto.randomBytes(16).toString("hex");
+};
+const spawnCommand = (cmd, cwd = process.cwd()) => new Promise((resolve, reject) => {
+	const child = spawn(cmd, {
+		cwd,
+		stdio: "inherit",
+		shell: true
+	});
+	child.on("close", (code, signal) => {
+		if (code !== 0 && code !== null) reject(/* @__PURE__ */ new Error(`Exited with code ${code}`));
+		else if (signal) reject(/* @__PURE__ */ new Error(`Killed with signal ${signal}`));
+		else resolve();
+	});
+	child.on("error", reject);
+});
+//#endregion
+//#region src/utils/get-package-info.ts
+function getPackageInfo(cwd) {
+	const packageJsonPath = cwd ? path.join(cwd, "package.json") : path.join("package.json");
+	return JSON.parse(readFileSync(packageJsonPath, "utf-8"));
 }
-function resolveWithMatchers(specifier, matchers) {
-	for (const matcher of matchers) for (const candidate of matcher(specifier)) {
-		const resolved = resolveCandidateFile(candidate);
-		if (resolved) return resolved;
+function getPrismaVersion(cwd) {
+	try {
+		const packageInfo = getPackageInfo(cwd);
+		const prismaVersion = packageInfo.dependencies?.prisma || packageInfo.devDependencies?.prisma || packageInfo.dependencies?.["@prisma/client"] || packageInfo.devDependencies?.["@prisma/client"];
+		if (!prismaVersion) return null;
+		const match = prismaVersion.match(/(\d+)/);
+		return match ? parseInt(match[1], 10) : null;
+	} catch {
+		return null;
 	}
 }
 /**
-* Callees whose first string argument is a module specifier. `jitiImport` is
-* 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).
+* Checks if a package has a specific dependency.
+*
+* @param packageJson The package.json object
+* @param dependency The dependency to check for
+* @returns true if the package has the dependency
 */
-const LOADER_IDENTIFIERS = new Set([
-	"require",
-	"import",
-	"jitiImport"
-]);
+function hasDependency(packageJson, dependency) {
+	let hasDependency = false;
+	if (packageJson.dependencies?.[dependency] || packageJson.devDependencies?.[dependency] || packageJson.peerDependencies?.[dependency] || packageJson.optionalDependencies?.[dependency]) hasDependency = true;
+	return hasDependency;
+}
 /**
-* Rewrites aliased specifiers at AST level. Required because jiti's `alias`
-* option only supports prefix matching and cannot express mid-path wildcards.
+* Checks if a directory is a monorepo root by looking for common monorepo indicators.
 *
-* Matchers always take precedence over native resolution, mirroring
-* TypeScript's own `paths` → `node_modules` order.
+* @param dir Directory to check
+* @returns true if the directory appears to be a monorepo root
 */
-function createRewriteImportPathsPlugin(matchers) {
-	return ({ types: t }) => {
-		const rewrite = (source) => {
-			if (!source) return;
-			const resolved = resolveWithMatchers(source.value, matchers);
-			if (resolved) source.value = resolved;
-		};
-		return { visitor: {
-			ImportDeclaration(p) {
-				rewrite(p.node.source);
-			},
-			ExportNamedDeclaration(p) {
-				rewrite(p.node.source);
-			},
-			ExportAllDeclaration(p) {
-				rewrite(p.node.source);
-			},
-			ImportExpression(p) {
-				if (t.isStringLiteral(p.node.source)) rewrite(p.node.source);
-			},
-			CallExpression(p) {
-				const { callee, arguments: args } = p.node;
-				const first = args[0];
-				if (!t.isStringLiteral(first)) return;
-				if (!(t.isIdentifier(callee) && LOADER_IDENTIFIERS.has(callee.name) || t.isImport(callee))) return;
-				rewrite(first);
-			}
-		} };
-	};
-}
-/** Virtual module aliases; real tsconfig paths go through the babel plugin. */
-function getVirtualModuleAliases() {
-	const result = {};
-	addSvelteKitEnvModules(result);
-	addCloudflareModules(result);
-	return result;
+async function isMonorepoRoot(dir) {
+	const { data: files } = await tryCatch(fs$1.readdir(dir, "utf-8"));
+	if (!files) return false;
+	if (files.includes("pnpm-workspace.yaml")) return true;
+	if (files.includes("package.json")) {
+		const packageJsonPath = path.join(dir, "package.json");
+		const { data } = await tryCatch(fs$1.readFile(packageJsonPath, "utf-8"));
+		if (data) try {
+			const packageJson = JSON.parse(data);
+			if (packageJson.workspaces && (Array.isArray(packageJson.workspaces) || typeof packageJson.workspaces === "object")) return true;
+		} catch {}
+	}
+	return [
+		"lerna.json",
+		"turbo.json",
+		"nx.json",
+		"rush.json"
+	].some((indicator) => files.includes(indicator));
 }
 /**
-* .tsx files are not supported by Jiti.
+* Finds the monorepo root by walking up the directory tree.
+*
+* @param startDir Starting directory
+* @returns Path to monorepo root, or null if not found
 */
-const jitiOptions = (cwd) => {
-	const matchers = collectPathsMatchers(cwd);
-	const plugins = matchers.length > 0 ? [createRewriteImportPathsPlugin(matchers)] : [];
-	return {
-		transformOptions: { babel: {
-			presets: [[babelPresetTypeScript, {
-				isTSX: true,
-				allExtensions: true
-			}], [babelPresetReact, { runtime: "automatic" }]],
-			plugins
-		} },
-		extensions: [...SOURCE_EXTENSIONS],
-		alias: getVirtualModuleAliases()
-	};
-};
-const isDefaultExport = (object) => {
-	return typeof object === "object" && object !== null && !Array.isArray(object) && Object.keys(object).length > 0 && "options" in object;
-};
-async function getConfig({ cwd, configPath, shouldThrowOnError = false }) {
-	try {
-		let configFile = null;
-		if (configPath) {
-			let resolvedPath = path.join(cwd, configPath);
-			if (existsSync(configPath)) resolvedPath = configPath;
-			const { config } = await loadConfig({
-				configFile: resolvedPath,
-				dotenv: { fileName: [".env", ".env.local"] },
-				jitiOptions: jitiOptions(cwd),
-				cwd
-			});
-			if (!("auth" in config) && !isDefaultExport(config)) {
-				if (shouldThrowOnError) throw new Error(`Couldn't read your auth config in ${resolvedPath}. Make sure to default export your auth instance or to export as a variable named auth.`);
-				console.error(`[#better-auth]: Couldn't read your auth config in ${resolvedPath}. Make sure to default export your auth instance or to export as a variable named auth.`);
-				process.exit(1);
+async function findMonorepoRoot(startDir) {
+	let currentDir = path.resolve(startDir);
+	const root = path.parse(currentDir).root;
+	while (currentDir !== root) {
+		if (await isMonorepoRoot(currentDir)) return currentDir;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	return null;
+}
+//#endregion
+//#region src/generators/prisma.ts
+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 getModelName = initGetModelName({
+		schema: getAuthTables(options),
+		usePlural: adapter.options?.adapterConfig?.usePlural
+	});
+	const getFieldName = initGetFieldName({
+		schema: getAuthTables(options),
+		usePlural: false
+	});
+	let schemaPrisma = "";
+	if (schemaPrismaExist) schemaPrisma = await fs$1.readFile(path.join(process.cwd(), filePath), "utf-8");
+	else schemaPrisma = getNewPrisma(provider, process.cwd());
+	const prismaVersion = getPrismaVersion(process.cwd());
+	if (prismaVersion && prismaVersion >= 7 && schemaPrismaExist) schemaPrisma = produceSchema(schemaPrisma, (builder) => {
+		const generator = builder.findByType("generator", { name: "client" });
+		if (generator && generator.properties) {
+			const providerProp = generator.properties.find((prop) => prop.type === "assignment" && prop.key === "provider");
+			if (providerProp && providerProp.value === "\"prisma-client-js\"") providerProp.value = "\"prisma-client\"";
+		}
+		const datasource = builder.findByType("datasource", { name: "db" });
+		if (datasource && datasource.properties) {
+			const urlIndex = datasource.properties.findIndex((prop) => prop.type === "assignment" && prop.key === "url");
+			if (urlIndex !== -1) datasource.properties.splice(urlIndex, 1);
+		}
+	});
+	const manyToManyRelations = /* @__PURE__ */ new Map();
+	for (const table in tables) {
+		const fields = tables[table]?.fields;
+		for (const field in fields) {
+			const attr = fields[field];
+			if (attr.references) {
+				const referencedOriginalModel = attr.references.model;
+				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));
+				manyToManyRelations.get(referencedModelNameCap).add(currentModelNameCap);
 			}
-			configFile = "auth" in config ? config.auth?.options : config.options;
 		}
-		if (!configFile) for (const possiblePath of possiblePaths$1) try {
-			const { config } = await loadConfig({
-				configFile: possiblePath,
-				dotenv: { fileName: [".env", ".env.local"] },
-				jitiOptions: jitiOptions(cwd),
-				cwd
-			});
-			if (Object.keys(config).length > 0) {
-				configFile = config.auth?.options || config.default?.options || null;
-				if (!configFile) {
-					if (shouldThrowOnError) throw new Error("Couldn't read your auth config. Make sure to default export your auth instance or to export as a variable named auth.");
-					console.error("[#better-auth]: Couldn't read your auth config.");
-					console.log("");
-					console.log("[#better-auth]: Make sure to default export your auth instance or to export as a variable named auth.");
-					process.exit(1);
+	}
+	const indexedFields = /* @__PURE__ */ new Map();
+	for (const table in tables) {
+		const fields = tables[table]?.fields;
+		const modelName = capitalizeFirstLetter(getModelName(tables[table]?.modelName || table));
+		indexedFields.set(modelName, []);
+		for (const field in fields) {
+			const attr = fields[field];
+			if (attr.index && !attr.unique) {
+				const fieldName = attr.fieldName || field;
+				indexedFields.get(modelName).push(fieldName);
+			}
+		}
+	}
+	const schema = produceSchema(schemaPrisma, (builder) => {
+		for (const table in tables) {
+			const originalTableName = table;
+			const customModelName = tables[table]?.modelName || table;
+			const modelName = capitalizeFirstLetter(getModelName(customModelName));
+			const fields = tables[table]?.fields;
+			function getType({ isBigint, isOptional, type }) {
+				if (type === "string") 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";
+				if (type === "date") return isOptional ? "DateTime?" : "DateTime";
+				if (type === "json") {
+					if (provider === "sqlite" || provider === "mysql") return isOptional ? "String?" : "String";
+					return isOptional ? "Json?" : "Json";
+				}
+				if (type === "string[]") {
+					if (provider === "sqlite" || provider === "mysql") return isOptional ? "String?" : "String";
+					return "String[]";
+				}
+				if (type === "number[]") {
+					if (provider === "sqlite" || provider === "mysql") return "String";
+					return "Int[]";
 				}
-				break;
 			}
-		} catch (e) {
-			if (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes("This module cannot be imported from a Client Component module")) {
-				if (shouldThrowOnError) throw new Error(`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.`);
-				console.error(`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.`);
-				process.exit(1);
+			const prismaModel = builder.findByType("model", { name: modelName });
+			if (!prismaModel) if (provider === "mongodb") builder.model(modelName).field("id", "String").attribute("id").attribute(`map("_id")`);
+			else {
+				const 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("default(dbgenerated(\"pg_catalog.gen_random_uuid()\"))").attribute("db.Uuid");
+				else builder.model(modelName).field("id", "String").attribute("id");
 			}
-			if (shouldThrowOnError) throw e;
-			console.error("[#better-auth]: Couldn't read your auth config.", e);
-			process.exit(1);
-		}
-		return configFile;
-	} catch (e) {
-		if (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes("This module cannot be imported from a Client Component module")) {
-			if (shouldThrowOnError) throw new Error(`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.`);
-			console.error(`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.`);
-			process.exit(1);
+			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({
+					isBigint: false,
+					isOptional: false,
+					type: "number"
+				}) : getType({
+					isBigint: attr?.bigint || false,
+					isOptional: attr?.required === false,
+					type: attr.references?.field === "id" ? useNumberId ? "number" : "string" : attr.type
+				}));
+				if (field === "id") {
+					fieldBuilder.attribute("id");
+					if (provider === "mongodb") fieldBuilder.attribute(`map("_id")`);
+				}
+				if (attr.unique) builder.model(modelName).blockAttribute(`unique([${fieldName}])`);
+				if (attr.defaultValue !== void 0) {
+					if (Array.isArray(attr.defaultValue)) {
+						if (attr.type === "json") {
+							if (Object.prototype.toString.call(attr.defaultValue[0]) === "[object Object]") {
+								fieldBuilder.attribute(`default("${JSON.stringify(attr.defaultValue).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}")`);
+								continue;
+							}
+							const jsonArray = [];
+							for (const value of attr.defaultValue) jsonArray.push(value);
+							fieldBuilder.attribute(`default("${JSON.stringify(jsonArray).replace(/"/g, "\\\"")}")`);
+							continue;
+						}
+						if (attr.defaultValue.length === 0) {
+							fieldBuilder.attribute(`default([])`);
+							continue;
+						} else if (typeof attr.defaultValue[0] === "string" && attr.type === "string[]") {
+							const valueArray = [];
+							for (const value of attr.defaultValue) valueArray.push(JSON.stringify(value));
+							fieldBuilder.attribute(`default([${valueArray}])`);
+						} else if (typeof attr.defaultValue[0] === "number") {
+							const valueArray = [];
+							for (const value of attr.defaultValue) valueArray.push(`${value}`);
+							fieldBuilder.attribute(`default([${valueArray}])`);
+						}
+					} else if (typeof attr.defaultValue === "object" && !Array.isArray(attr.defaultValue) && attr.defaultValue !== null) {
+						if (Object.entries(attr.defaultValue).length === 0) {
+							fieldBuilder.attribute(`default("{}")`);
+							continue;
+						}
+						fieldBuilder.attribute(`default("${JSON.stringify(attr.defaultValue).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}")`);
+					}
+					if (field === "createdAt") fieldBuilder.attribute("default(now())");
+					else if (typeof attr.defaultValue === "string" && provider !== "mysql") fieldBuilder.attribute(`default("${attr.defaultValue}")`);
+					else if (typeof attr.defaultValue === "boolean" || typeof attr.defaultValue === "number") fieldBuilder.attribute(`default(${attr.defaultValue})`);
+					else if (typeof attr.defaultValue === "function") {}
+				}
+				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);
+					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: [${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 === false ? "?" : ""}`).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 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 || adapter.options?.usePlural === true ? `${relatedModel.toLowerCase()}` : `${relatedModel.toLowerCase()}s`;
+				if (!builder.findByType("field", {
+					name: fieldName,
+					within: prismaModel?.properties
+				})) builder.model(modelName).field(fieldName, `${relatedModel}${isUnique ? "?" : "[]"}`);
+			}
+			const indexedFieldsForModel = indexedFields.get(modelName);
+			if (indexedFieldsForModel && indexedFieldsForModel.length > 0) for (const fieldName of indexedFieldsForModel) {
+				if (prismaModel) {
+					if (prismaModel.properties.some((v) => v.type === "attribute" && v.name === "index" && JSON.stringify(v.args[0]?.value).includes(fieldName))) continue;
+				}
+				const field = Object.entries(fields).find(([key, attr]) => (attr.fieldName || key) === fieldName)?.[1];
+				let indexField = fieldName;
+				if (provider === "mysql" && field && field.type === "string") {
+					const useNumberId = options.advanced?.database?.generateId === "serial";
+					const useUUIDs = options.advanced?.database?.generateId === "uuid";
+					if (field.references?.field === "id" && (useNumberId || useUUIDs)) indexField = `${fieldName}`;
+					else indexField = `${fieldName}(length: 191)`;
+				}
+				builder.model(modelName).blockAttribute(`index([${indexField}])`);
+			}
+			const hasAttribute = builder.findByType("attribute", {
+				name: "map",
+				within: prismaModel?.properties
+			});
+			const hasChanged = customModelName !== originalTableName;
+			if (!hasAttribute) builder.model(modelName).blockAttribute("map", `${getModelName(hasChanged ? customModelName : originalTableName)}`);
 		}
-		if (shouldThrowOnError) throw e;
-		console.error("Couldn't read your auth config.", e);
-		process.exit(1);
-	}
-}
+	});
+	const schemaChanged = schema.trim() !== schemaPrisma.trim();
+	return {
+		code: schemaChanged ? schema : "",
+		fileName: filePath,
+		overwrite: schemaPrismaExist && schemaChanged
+	};
+};
+const getNewPrisma = (provider, cwd) => {
+	const prismaVersion = getPrismaVersion(cwd);
+	const isV7 = prismaVersion && prismaVersion >= 7;
+	const clientProvider = isV7 ? "prisma-client" : "prisma-client-js";
+	if (isV7) return `generator client {
+    provider = "${clientProvider}"
+  }
+
+  datasource db {
+    provider = "${provider}"
+  }`;
+	return `generator client {
+    provider = "${clientProvider}"
+  }
+
+  datasource db {
+    provider = "${provider}"
+    url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
+  }`;
+};
+//#endregion
+//#region src/generators/index.ts
+const adapters = {
+	prisma: generatePrismaSchema,
+	drizzle: generateDrizzleSchema,
+	kysely: generateKyselySchema
+};
+const generateSchema = (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`);
+};
 //#endregion
 //#region src/commands/generate.ts
 function createMockAdapter$1(adapterId, dialect) {
@@ -1746,6 +1845,9 @@ function createMockAdapter$1(adapterId, dialect) {
 		deleteMany: async () => {
 			throw new Error("Mock adapter methods should not be called");
 		},
+		consumeOne: async () => {
+			throw new Error("Mock adapter methods should not be called");
+		},
 		transaction: async (callback) => {
 			throw new Error("Mock adapter methods should not be called");
 		},
@@ -5277,12 +5379,9 @@ const databasesConfig = [
 			imports: [createImport({ name: "createPool" })],
 			isNamedImport: false
 		}],
-		preCode: `const dialect = createPool({ host: "localhost", user: "root", password: "password", database: "database", timezone: "Z" })`,
+		preCode: `const database = createPool({ host: "localhost", user: "root", password: "password", database: "database", timezone: "Z" })`,
 		code({ additionalOptions }) {
-			return kyselyCode({
-				provider: "mysql",
-				additionalOptions
-			});
+			return `database`;
 		},
 		dependencies: ["mysql2"]
 	},
@@ -5293,12 +5392,9 @@ const databasesConfig = [
 			imports: [createImport({ name: "Pool" })],
 			isNamedImport: false
 		}],
-		preCode: `const dialect = new Pool({ connectionString: "postgresql://postgres:password@localhost:5432/database" })`,
+		preCode: `const database = new Pool({ connectionString: "postgresql://postgres:password@localhost:5432/database" })`,
 		code({ additionalOptions }) {
-			return kyselyCode({
-				provider: "postgresql",
-				additionalOptions
-			});
+			return `database`;
 		},
 		dependencies: ["pg"],
 		devDependencies: ["@types/pg"]
@@ -6664,7 +6760,7 @@ const initActionOptionsSchema = z.object({
 //#region src/commands/login.ts
 async function loginAction() {
 	try {
-		await spawnCommand("npx @better-auth/cli@latest login");
+		await spawnCommand("npx auth@latest login");
 	} catch (error) {
 		log.error(error.message || "An unknown error occurred");
 		process.exit(1);
@@ -6674,7 +6770,7 @@ async function loginAction() {
 const login = new Command("login").description("Login to Better Auth Infrastructure").action(loginAction);
 async function logoutAction() {
 	try {
-		await spawnCommand("npx @better-auth/cli@latest logout");
+		await spawnCommand("npx auth@latest logout");
 	} catch (error) {
 		log.error(error.message || "An unknown error occurred");
 		process.exit(1);
@@ -7076,7 +7172,7 @@ async function main() {
 		packageInfo = await getPackageInfo();
 		cliVersion = packageInfo.version || "1.1.2";
 	} catch {}
-	program.addCommand(ai).addCommand(init).addCommand(migrate).addCommand(generate).addCommand(generateSecret).addCommand(info).addCommand(login).addCommand(logout).addCommand(mcp).addCommand(upgrade).version(cliVersion).description("Better Auth CLI").action(() => program.help());
+	program.addCommand(ai).addCommand(createAdmin).addCommand(init).addCommand(migrate).addCommand(generate).addCommand(generateSecret).addCommand(info).addCommand(login).addCommand(logout).addCommand(mcp).addCommand(upgrade).version(cliVersion).description("Better Auth CLI").action(() => program.help());
 	program.parse();
 }
 main().catch((error) => {