create-prisma 0.0.0 → 0.1.4

package/dist/create-Dz9GFGFQ.mjs

@@ -0,0 +1,1090 @@
+#!/usr/bin/env node
+import { cancel, confirm, intro, isCancel, log, outro, select, spinner, text } from "@clack/prompts";
+import fs from "fs-extra";
+import path from "node:path";
+import Handlebars from "handlebars";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { execa } from "execa";
+import { styleText } from "node:util";
+
+//#region src/templates/shared.ts
+Handlebars.registerHelper("eq", (left, right) => left === right);
+function findPackageRoot(startDir) {
+	let currentDir = startDir;
+	while (true) {
+		if (existsSync(path.join(currentDir, "package.json"))) return currentDir;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	throw new Error(`Unable to locate package root from: ${startDir}`);
+}
+function resolveTemplatesDir(relativeTemplatesDir) {
+	const currentFilePath = fileURLToPath(import.meta.url);
+	const packageRoot = findPackageRoot(path.dirname(currentFilePath));
+	const templatePath = path.join(packageRoot, relativeTemplatesDir);
+	if (!existsSync(templatePath)) throw new Error(`Template directory not found at: ${templatePath}`);
+	return templatePath;
+}
+async function getTemplateFilesRecursively(dir) {
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+	return (await Promise.all(entries.map(async (entry) => {
+		const entryPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) return getTemplateFilesRecursively(entryPath);
+		if (!entry.isFile()) return [];
+		return [entryPath];
+	}))).flat();
+}
+function stripHbsExtension(filePath) {
+	return filePath.endsWith(".hbs") ? filePath.slice(0, -4) : filePath;
+}
+function ensureTrailingNewline(content) {
+	return content.endsWith("\n") ? content : `${content}\n`;
+}
+async function renderTemplateFile(opts) {
+	const { templateFilePath, outputPath, context } = opts;
+	const templateContent = await fs.readFile(templateFilePath, "utf8");
+	const outputContent = templateFilePath.endsWith(".hbs") ? Handlebars.compile(templateContent, {
+		noEscape: true,
+		strict: true
+	})(context) : templateContent;
+	await fs.outputFile(outputPath, ensureTrailingNewline(outputContent), "utf8");
+}
+async function renderTemplateTree(opts) {
+	const { templateRoot, outputDir, context } = opts;
+	const templateFiles = await getTemplateFilesRecursively(templateRoot);
+	for (const templateFilePath of templateFiles) {
+		const relativeOutputPath = stripHbsExtension(path.relative(templateRoot, templateFilePath));
+		await renderTemplateFile({
+			templateFilePath,
+			outputPath: path.join(outputDir, relativeOutputPath),
+			context
+		});
+	}
+}
+
+//#endregion
+//#region src/templates/render-create-template.ts
+function getCreateTemplateDir(template) {
+	return resolveTemplatesDir(`templates/create/${template}`);
+}
+function createTemplateContext$1(projectName, schemaPreset, packageManager) {
+	return {
+		projectName,
+		schemaPreset,
+		packageManager
+	};
+}
+async function scaffoldCreateTemplate(opts) {
+	const { projectDir, projectName, template, schemaPreset, packageManager } = opts;
+	await renderTemplateTree({
+		templateRoot: getCreateTemplateDir(template),
+		outputDir: projectDir,
+		context: createTemplateContext$1(projectName, schemaPreset, packageManager)
+	});
+}
+
+//#endregion
+//#region src/types.ts
+const databaseProviders = [
+	"postgresql",
+	"mysql",
+	"sqlite",
+	"sqlserver",
+	"cockroachdb"
+];
+const packageManagers = [
+	"npm",
+	"pnpm",
+	"bun"
+];
+const schemaPresets = ["empty", "basic"];
+const createTemplates = ["hono", "next"];
+const DatabaseProviderSchema = z.enum(databaseProviders);
+const PackageManagerSchema = z.enum(packageManagers);
+const SchemaPresetSchema = z.enum(schemaPresets);
+const CreateTemplateSchema = z.enum(createTemplates);
+const DatabaseUrlSchema = z.string().trim().min(1, "Please enter a valid database URL");
+const CommonCommandOptionsSchema = z.object({
+	yes: z.boolean().optional().describe("Skip prompts and accept default choices"),
+	verbose: z.boolean().optional().describe("Show verbose command output during setup")
+});
+const PrismaSetupOptionsSchema = z.object({
+	provider: DatabaseProviderSchema.optional().describe("Database provider"),
+	packageManager: PackageManagerSchema.optional().describe("Package manager used for dependency installation"),
+	prismaPostgres: z.boolean().optional().describe("Provision Prisma Postgres with create-db when provider is postgresql"),
+	databaseUrl: DatabaseUrlSchema.optional().describe("DATABASE_URL value"),
+	install: z.boolean().optional().describe("Install dependencies with selected package manager"),
+	generate: z.boolean().optional().describe("Generate Prisma Client after scaffolding"),
+	schemaPreset: SchemaPresetSchema.optional().describe("Schema preset to scaffold in prisma/schema.prisma")
+});
+const InitCommandInputSchema = CommonCommandOptionsSchema.extend(PrismaSetupOptionsSchema.shape);
+const CreateScaffoldOptionsSchema = z.object({
+	name: z.string().trim().min(1, "Please enter a valid project name").optional().describe("Project name / directory"),
+	template: CreateTemplateSchema.optional().describe("Project template"),
+	force: z.boolean().optional().describe("Allow scaffolding into a non-empty target directory")
+});
+const CreateCommandInputSchema = CommonCommandOptionsSchema.extend(CreateScaffoldOptionsSchema.shape).extend(PrismaSetupOptionsSchema.shape);
+
+//#endregion
+//#region src/utils/package-manager.ts
+function parseUserAgent(userAgent) {
+	if (userAgent?.startsWith("pnpm")) return "pnpm";
+	if (userAgent?.startsWith("bun")) return "bun";
+	if (userAgent?.startsWith("npm")) return "npm";
+	return null;
+}
+function parsePackageManagerField(packageManagerField) {
+	if (typeof packageManagerField !== "string" || packageManagerField.length === 0) return null;
+	const managerName = packageManagerField.split("@")[0];
+	const parsed = PackageManagerSchema.safeParse(managerName);
+	return parsed.success ? parsed.data : null;
+}
+async function detectFromPackageJson(projectDir) {
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (!await fs.pathExists(packageJsonPath)) return null;
+	return parsePackageManagerField((await fs.readJson(packageJsonPath)).packageManager);
+}
+async function detectFromLockfile(projectDir) {
+	for (const check of [
+		{
+			manager: "pnpm",
+			lockfile: "pnpm-lock.yaml"
+		},
+		{
+			manager: "bun",
+			lockfile: "bun.lockb"
+		},
+		{
+			manager: "bun",
+			lockfile: "bun.lock"
+		},
+		{
+			manager: "npm",
+			lockfile: "package-lock.json"
+		},
+		{
+			manager: "npm",
+			lockfile: "npm-shrinkwrap.json"
+		}
+	]) if (await fs.pathExists(path.join(projectDir, check.lockfile))) return check.manager;
+	return null;
+}
+async function detectPackageManager(projectDir = process.cwd()) {
+	const fromPackageJson = await detectFromPackageJson(projectDir);
+	if (fromPackageJson) return fromPackageJson;
+	const fromLockfile = await detectFromLockfile(projectDir);
+	if (fromLockfile) return fromLockfile;
+	const fromUserAgent = parseUserAgent(process.env.npm_config_user_agent);
+	if (fromUserAgent) return fromUserAgent;
+	return "npm";
+}
+function getInstallCommand(packageManager) {
+	return `${packageManager} install`;
+}
+function getRunScriptCommand(packageManager, scriptName) {
+	switch (packageManager) {
+		case "bun": return `bun run ${scriptName}`;
+		case "pnpm": return `pnpm run ${scriptName}`;
+		default: return `npm run ${scriptName}`;
+	}
+}
+function getInstallArgs(packageManager) {
+	return {
+		command: packageManager,
+		args: ["install"]
+	};
+}
+function getPackageExecutor(packageManager) {
+	switch (packageManager) {
+		case "pnpm": return {
+			command: "pnpm",
+			args: ["dlx"]
+		};
+		case "bun": return {
+			command: "bunx",
+			args: []
+		};
+		default: return {
+			command: "npx",
+			args: []
+		};
+	}
+}
+function getPackageExecutionArgs(packageManager, commandArgs) {
+	const executor = getPackageExecutor(packageManager);
+	return {
+		command: executor.command,
+		args: [...executor.args, ...commandArgs]
+	};
+}
+function getPackageExecutionCommand(packageManager, commandArgs) {
+	const execution = getPackageExecutionArgs(packageManager, commandArgs);
+	return [execution.command, ...execution.args].join(" ");
+}
+function getPrismaCliArgs(packageManager, prismaArgs) {
+	if (packageManager === "bun") return getPackageExecutionArgs(packageManager, [
+		"--bun",
+		"prisma",
+		...prismaArgs
+	]);
+	return getPackageExecutionArgs(packageManager, ["prisma", ...prismaArgs]);
+}
+function getPrismaCliCommand(packageManager, prismaArgs) {
+	const execution = getPrismaCliArgs(packageManager, prismaArgs);
+	return [execution.command, ...execution.args].join(" ");
+}
+
+//#endregion
+//#region src/tasks/prisma-postgres.ts
+const PRISMA_POSTGRES_TEMPORARY_NOTICE = "Prisma Postgres is temporary for 24 hours. Claim this database before it expires using CLAIM_URL.";
+const CREATE_DB_COMMAND_ARGS = ["create-db@latest", "--json"];
+function parseCreateDbJson(rawOutput) {
+	const trimmed = rawOutput.trim();
+	if (!trimmed) throw new Error("create-db returned empty output.");
+	const jsonCandidates = [trimmed];
+	const firstBrace = trimmed.indexOf("{");
+	const lastBrace = trimmed.lastIndexOf("}");
+	if (firstBrace !== -1 && lastBrace > firstBrace) jsonCandidates.push(trimmed.slice(firstBrace, lastBrace + 1));
+	for (const candidate of jsonCandidates) try {
+		return JSON.parse(candidate);
+	} catch {}
+	throw new Error(`Unable to parse create-db JSON output: ${trimmed}`);
+}
+function pickConnectionString(payload) {
+	if (typeof payload.connectionString === "string" && payload.connectionString.length > 0) return payload.connectionString;
+	if (typeof payload.databaseUrl === "string" && payload.databaseUrl.length > 0) return payload.databaseUrl;
+}
+function extractErrorMessage(payload, fallback) {
+	if (typeof payload.message === "string" && payload.message.length > 0) return payload.message;
+	if (typeof payload.error === "string" && payload.error.length > 0) return payload.error;
+	return fallback;
+}
+async function provisionPrismaPostgres(packageManager, projectDir = process.cwd()) {
+	const command = getPackageExecutionArgs(packageManager, [...CREATE_DB_COMMAND_ARGS]);
+	const commandString = getCreateDbCommand(packageManager);
+	let stdout;
+	try {
+		stdout = (await execa(command.command, command.args, {
+			cwd: projectDir,
+			stdio: "pipe"
+		})).stdout;
+	} catch (error) {
+		if (error instanceof Error && "stderr" in error) {
+			const stderr = String(error.stderr ?? "").trim();
+			const message = stderr.length > 0 ? stderr : error.message;
+			throw new Error(`Failed to run ${commandString}: ${message}`);
+		}
+		throw error;
+	}
+	const payload = parseCreateDbJson(stdout);
+	if (payload.success === false) throw new Error(extractErrorMessage(payload, "create-db reported failure."));
+	const databaseUrl = pickConnectionString(payload);
+	if (!databaseUrl) throw new Error("create-db did not return a connection string.");
+	return {
+		databaseUrl,
+		claimUrl: typeof payload.claimUrl === "string" && payload.claimUrl.length > 0 ? payload.claimUrl : typeof payload.claimURL === "string" && payload.claimURL.length > 0 ? payload.claimURL : void 0
+	};
+}
+function getCreateDbCommand(packageManager) {
+	return getPackageExecutionCommand(packageManager, [...CREATE_DB_COMMAND_ARGS]);
+}
+
+//#endregion
+//#region src/templates/render-init-templates.ts
+function getInitTemplatesDir() {
+	return resolveTemplatesDir("templates/init");
+}
+function createTemplateContext(provider, envVar, schemaPreset) {
+	return {
+		envVar,
+		provider,
+		schemaPreset
+	};
+}
+async function scaffoldInitTemplates(projectDir, provider, envVar = "DATABASE_URL", schemaPreset = "empty") {
+	await renderTemplateTree({
+		templateRoot: getInitTemplatesDir(),
+		outputDir: projectDir,
+		context: createTemplateContext(provider, envVar, schemaPreset)
+	});
+	return {
+		schemaPath: path.join(projectDir, "prisma/schema.prisma"),
+		configPath: path.join(projectDir, "prisma.config.ts"),
+		singletonPath: path.join(projectDir, "prisma/index.ts")
+	};
+}
+
+//#endregion
+//#region src/tasks/init-prisma.ts
+const prismaManagedFiles = [
+	"schema.prisma",
+	"prisma/schema.prisma",
+	"prisma/index.ts",
+	"prisma.config.ts"
+];
+const prismaTemplateFiles = [
+	"prisma/schema.prisma",
+	"prisma/index.ts",
+	"prisma.config.ts"
+];
+var PrismaAlreadyInitializedError = class extends Error {
+	existingFiles;
+	constructor(existingFiles) {
+		super(`This project already appears to be Prisma-initialized: ${existingFiles.join(", ")}`);
+		this.name = "PrismaAlreadyInitializedError";
+		this.existingFiles = existingFiles;
+	}
+};
+function findExistingPrismaFiles(projectDir = process.cwd()) {
+	return prismaManagedFiles.map((relativePath) => path.join(projectDir, relativePath)).filter((absolutePath) => fs.existsSync(absolutePath));
+}
+function canReusePrismaFiles(projectDir = process.cwd()) {
+	return prismaTemplateFiles.every((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
+}
+function getDefaultDatabaseUrl(provider) {
+	switch (provider) {
+		case "postgresql": return "postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public";
+		case "cockroachdb": return "postgresql://johndoe:randompassword@localhost:26257/mydb?schema=public";
+		case "mysql": return "mysql://johndoe:randompassword@localhost:3306/mydb";
+		case "sqlite": return "file:./dev.db";
+		case "sqlserver": return "sqlserver://localhost:1433;database=mydb;user=SA;password=randompassword;";
+		default: {
+			const exhaustiveCheck = provider;
+			throw new Error(`Unsupported provider: ${String(exhaustiveCheck)}`);
+		}
+	}
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasEnvVar(content, envVarName) {
+	const escapedName = escapeRegExp(envVarName);
+	return new RegExp(`(^|\\n)\\s*${escapedName}\\s*=`).test(content);
+}
+function hasEnvComment(content, comment) {
+	const escapedComment = escapeRegExp(comment);
+	return new RegExp(`(^|\\n)\\s*#\\s*${escapedComment}\\s*(?=\\n|$)`).test(content);
+}
+async function ensureEnvVarInEnv(projectDir, envVarName, envVarValue, opts) {
+	const envPath = path.join(projectDir, ".env");
+	const envLine = `${envVarName}="${envVarValue}"`;
+	if (!await fs.pathExists(envPath)) {
+		await fs.writeFile(envPath, `${envLine}\n`, "utf8");
+		return {
+			envPath,
+			status: "created"
+		};
+	}
+	const existingContent = await fs.readFile(envPath, "utf8");
+	if (hasEnvVar(existingContent, envVarName)) {
+		if (opts.mode === "keep-existing") return {
+			envPath,
+			status: "existing"
+		};
+		const escapedName = escapeRegExp(envVarName);
+		const lineRegex = new RegExp(`(^|\\n)\\s*${escapedName}\\s*=.*(?=\\n|$)`, "m");
+		const updatedContent = existingContent.replace(lineRegex, `$1${envLine}`);
+		if (updatedContent === existingContent) return {
+			envPath,
+			status: "existing"
+		};
+		await fs.writeFile(envPath, updatedContent, "utf8");
+		return {
+			envPath,
+			status: "updated"
+		};
+	}
+	const insertion = `${existingContent.endsWith("\n") ? "" : "\n"}${opts.comment ? `\n# ${opts.comment}\n` : "\n"}${envLine}\n`;
+	await fs.appendFile(envPath, insertion, "utf8");
+	return {
+		envPath,
+		status: "appended"
+	};
+}
+async function ensureEnvComment(projectDir, comment) {
+	const envPath = path.join(projectDir, ".env");
+	const commentLine = `# ${comment}`;
+	if (!await fs.pathExists(envPath)) {
+		await fs.writeFile(envPath, `${commentLine}\n`, "utf8");
+		return;
+	}
+	const existingContent = await fs.readFile(envPath, "utf8");
+	if (hasEnvComment(existingContent, comment)) return;
+	const separator = existingContent.endsWith("\n") ? "" : "\n";
+	await fs.appendFile(envPath, `${separator}${commentLine}\n`, "utf8");
+}
+function hasGitignoreEntry(content, entry) {
+	const escapedEntry = escapeRegExp(entry);
+	const escapedWithLeadingSlash = escapeRegExp(`/${entry}`);
+	return new RegExp(`(^|\\n)\\s*(?:${escapedEntry}|${escapedWithLeadingSlash})\\s*(?=\\n|$)`).test(content);
+}
+async function ensureGitignoreEntry(projectDir, entry) {
+	const gitignorePath = path.join(projectDir, ".gitignore");
+	if (!await fs.pathExists(gitignorePath)) {
+		await fs.writeFile(gitignorePath, `${entry}\n`, "utf8");
+		return {
+			gitignorePath,
+			status: "created"
+		};
+	}
+	const existingContent = await fs.readFile(gitignorePath, "utf8");
+	if (hasGitignoreEntry(existingContent, entry)) return {
+		gitignorePath,
+		status: "existing"
+	};
+	const separator = existingContent.endsWith("\n") ? "" : "\n";
+	await fs.appendFile(gitignorePath, `${separator}${entry}\n`, "utf8");
+	return {
+		gitignorePath,
+		status: "appended"
+	};
+}
+async function initializePrismaFiles(options) {
+	const projectDir = options.projectDir ?? process.cwd();
+	const prismaFilesMode = options.prismaFilesMode ?? "create";
+	const existingPrismaFiles = findExistingPrismaFiles(projectDir);
+	if (prismaFilesMode === "create" && existingPrismaFiles.length > 0) throw new PrismaAlreadyInitializedError(existingPrismaFiles);
+	if (prismaFilesMode === "reuse" && existingPrismaFiles.length === 0) throw new Error("Cannot reuse Prisma files because no existing Prisma files were found.");
+	if (prismaFilesMode === "reuse" && !canReusePrismaFiles(projectDir)) throw new Error("Cannot reuse Prisma files because required files are missing.");
+	const schemaPath = path.join(projectDir, "prisma/schema.prisma");
+	const configPath = path.join(projectDir, "prisma.config.ts");
+	const singletonPath = path.join(projectDir, "prisma/index.ts");
+	if (prismaFilesMode !== "reuse") await scaffoldInitTemplates(projectDir, options.provider, "DATABASE_URL", options.schemaPreset ?? "empty");
+	const envResult = await ensureEnvVarInEnv(projectDir, "DATABASE_URL", options.databaseUrl ?? getDefaultDatabaseUrl(options.provider), {
+		mode: options.databaseUrl ? "upsert" : "keep-existing",
+		comment: "Added by create-prisma init"
+	});
+	let claimEnvStatus;
+	if (options.claimUrl) {
+		claimEnvStatus = (await ensureEnvVarInEnv(projectDir, "CLAIM_URL", options.claimUrl, {
+			mode: "upsert",
+			comment: PRISMA_POSTGRES_TEMPORARY_NOTICE
+		})).status;
+		await ensureEnvComment(projectDir, PRISMA_POSTGRES_TEMPORARY_NOTICE);
+	}
+	const gitignoreResult = await ensureGitignoreEntry(projectDir, "prisma/generated");
+	return {
+		schemaPath,
+		configPath,
+		singletonPath,
+		prismaFilesMode,
+		envPath: envResult.envPath,
+		envStatus: envResult.status,
+		gitignorePath: gitignoreResult.gitignorePath,
+		gitignoreStatus: gitignoreResult.status,
+		claimEnvStatus
+	};
+}
+
+//#endregion
+//#region src/constants/dependencies.ts
+const dependencyVersionMap = {
+	"@prisma/client": "^7.4.0",
+	"@prisma/adapter-pg": "^7.4.0",
+	"@prisma/adapter-mariadb": "^7.4.0",
+	"@prisma/adapter-better-sqlite3": "^7.4.0",
+	"@prisma/adapter-mssql": "^7.4.0",
+	dotenv: "^17.2.3",
+	prisma: "^7.4.0"
+};
+
+//#endregion
+//#region src/constants/db-packages.ts
+function getDbPackages(provider) {
+	switch (provider) {
+		case "postgresql":
+		case "cockroachdb": return { adapterPackage: "@prisma/adapter-pg" };
+		case "mysql": return { adapterPackage: "@prisma/adapter-mariadb" };
+		case "sqlite": return { adapterPackage: "@prisma/adapter-better-sqlite3" };
+		case "sqlserver": return { adapterPackage: "@prisma/adapter-mssql" };
+		default: {
+			const exhaustiveCheck = provider;
+			throw new Error(`Unsupported database provider: ${String(exhaustiveCheck)}`);
+		}
+	}
+}
+
+//#endregion
+//#region src/tasks/install.ts
+const prismaScriptMap = {
+	"db:generate": "prisma generate",
+	"db:push": "prisma db push",
+	"db:migrate": "prisma migrate dev"
+};
+function getVersion(packageName) {
+	return dependencyVersionMap[packageName];
+}
+function unique(items) {
+	return [...new Set(items)];
+}
+function sortRecord(record) {
+	return Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
+}
+async function addPackageDependency(opts) {
+	const { dependencies = [], devDependencies = [], customDependencies = {}, customDevDependencies = {}, scripts = {}, scriptMode = "upsert", projectDir } = opts;
+	const addedScripts = [];
+	const existingScripts = [];
+	const pkgJsonPath = path.join(projectDir, "package.json");
+	if (!await fs.pathExists(pkgJsonPath)) throw new Error(`No package.json found in ${projectDir}. Run this command inside an existing JavaScript/TypeScript project.`);
+	const pkgJson = await fs.readJson(pkgJsonPath);
+	if (!pkgJson.dependencies) pkgJson.dependencies = {};
+	if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
+	if (!pkgJson.scripts) pkgJson.scripts = {};
+	for (const pkgName of unique(dependencies)) {
+		const version = getVersion(pkgName);
+		if (version) pkgJson.dependencies[pkgName] = version;
+		else console.warn(`Warning: Dependency ${pkgName} not found in version map.`);
+	}
+	for (const pkgName of unique(devDependencies)) {
+		const version = getVersion(pkgName);
+		if (version) pkgJson.devDependencies[pkgName] = version;
+		else console.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
+	}
+	for (const [pkgName, version] of Object.entries(customDependencies)) pkgJson.dependencies[pkgName] = version;
+	for (const [pkgName, version] of Object.entries(customDevDependencies)) pkgJson.devDependencies[pkgName] = version;
+	for (const [scriptName, command] of Object.entries(scripts)) {
+		if (scriptMode === "if-missing") {
+			if (typeof pkgJson.scripts[scriptName] !== "string" || pkgJson.scripts[scriptName].trim().length === 0) {
+				pkgJson.scripts[scriptName] = command;
+				addedScripts.push(scriptName);
+			} else existingScripts.push(scriptName);
+			continue;
+		}
+		if (pkgJson.scripts[scriptName] === command) existingScripts.push(scriptName);
+		else addedScripts.push(scriptName);
+		pkgJson.scripts[scriptName] = command;
+	}
+	pkgJson.dependencies = sortRecord(pkgJson.dependencies);
+	pkgJson.devDependencies = sortRecord(pkgJson.devDependencies);
+	await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+	return {
+		addedScripts,
+		existingScripts
+	};
+}
+async function writePrismaDependencies(provider, projectDir = process.cwd()) {
+	const dependencies = ["@prisma/client", "dotenv"];
+	const devDependencies = ["prisma"];
+	const { adapterPackage } = getDbPackages(provider);
+	dependencies.push(adapterPackage);
+	const scriptWriteResult = await addPackageDependency({
+		dependencies,
+		devDependencies,
+		scripts: prismaScriptMap,
+		scriptMode: "if-missing",
+		projectDir
+	});
+	return {
+		dependencies,
+		devDependencies,
+		scripts: Object.keys(prismaScriptMap),
+		addedScripts: scriptWriteResult.addedScripts,
+		existingScripts: scriptWriteResult.existingScripts
+	};
+}
+async function installProjectDependencies(packageManager, projectDir = process.cwd(), options = {}) {
+	const verbose = options.verbose === true;
+	const installCommand = getInstallArgs(packageManager);
+	await execa(installCommand.command, installCommand.args, {
+		cwd: projectDir,
+		stdio: verbose ? "inherit" : "pipe"
+	});
+}
+
+//#endregion
+//#region src/ui/branding.ts
+const prismaTitle = `${styleText(["bold", "cyan"], "Create")} ${styleText(["bold", "magenta"], "Prisma")}`;
+function getCreatePrismaIntro() {
+	return prismaTitle;
+}
+
+//#endregion
+//#region src/commands/init.ts
+const DEFAULT_DATABASE_PROVIDER = "postgresql";
+const DEFAULT_SCHEMA_PRESET$1 = "empty";
+const DEFAULT_PRISMA_POSTGRES = true;
+const DEFAULT_INSTALL = true;
+const DEFAULT_GENERATE = true;
+async function promptForDatabaseProvider() {
+	const databaseProvider = await select({
+		message: "Select your database",
+		initialValue: DEFAULT_DATABASE_PROVIDER,
+		options: [
+			{
+				value: "postgresql",
+				label: "PostgreSQL",
+				hint: "Default"
+			},
+			{
+				value: "mysql",
+				label: "MySQL"
+			},
+			{
+				value: "sqlite",
+				label: "SQLite"
+			},
+			{
+				value: "sqlserver",
+				label: "SQL Server"
+			},
+			{
+				value: "cockroachdb",
+				label: "CockroachDB"
+			}
+		]
+	});
+	if (isCancel(databaseProvider)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return DatabaseProviderSchema.parse(databaseProvider);
+}
+function getPackageManagerHint(option, detected) {
+	if (option === detected) return "Detected";
+	if (option === "bun") return "Fast runtime + package manager";
+}
+async function promptForPackageManager(detectedPackageManager) {
+	const packageManager = await select({
+		message: "Choose package manager",
+		initialValue: detectedPackageManager,
+		options: [
+			{
+				value: "npm",
+				label: "npm",
+				hint: getPackageManagerHint("npm", detectedPackageManager)
+			},
+			{
+				value: "pnpm",
+				label: "pnpm",
+				hint: getPackageManagerHint("pnpm", detectedPackageManager)
+			},
+			{
+				value: "bun",
+				label: "bun",
+				hint: getPackageManagerHint("bun", detectedPackageManager)
+			}
+		]
+	});
+	if (isCancel(packageManager)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return PackageManagerSchema.parse(packageManager);
+}
+async function promptForDependencyInstall(packageManager) {
+	const shouldInstall = await confirm({
+		message: `Install dependencies now with ${getInstallCommand(packageManager)}?`,
+		initialValue: true
+	});
+	if (isCancel(shouldInstall)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return Boolean(shouldInstall);
+}
+async function promptForPrismaPostgres() {
+	const shouldUsePrismaPostgres = await confirm({
+		message: "Use Prisma Postgres and auto-generate DATABASE_URL with create-db?",
+		initialValue: true
+	});
+	if (isCancel(shouldUsePrismaPostgres)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return Boolean(shouldUsePrismaPostgres);
+}
+async function promptForPrismaFilesMode(existingFiles, canReuseExistingPrismaFiles, baseDir) {
+	const mode = await select({
+		message: `Prisma already exists (${existingFiles.map((filePath) => formatCreatedPath(filePath, baseDir)).join(", ")}). How should we continue?`,
+		initialValue: canReuseExistingPrismaFiles ? "reuse" : "overwrite",
+		options: canReuseExistingPrismaFiles ? [
+			{
+				value: "reuse",
+				label: "Keep existing Prisma files",
+				hint: "Recommended"
+			},
+			{
+				value: "overwrite",
+				label: "Overwrite Prisma files"
+			},
+			{
+				value: "cancel",
+				label: "Cancel"
+			}
+		] : [{
+			value: "overwrite",
+			label: "Repair and overwrite Prisma files",
+			hint: "Recommended"
+		}, {
+			value: "cancel",
+			label: "Cancel"
+		}]
+	});
+	if (isCancel(mode)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	if (mode === "cancel") {
+		cancel("Operation cancelled.");
+		return;
+	}
+	if (mode !== "reuse" && mode !== "overwrite") {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return mode;
+}
+function formatCreatedPath(filePath, baseDir) {
+	return path.relative(baseDir, filePath);
+}
+function getCommandErrorMessage(error) {
+	if (error instanceof Error && "stderr" in error) {
+		const stderr = String(error.stderr ?? "").trim();
+		if (stderr.length > 0) return stderr;
+	}
+	return error instanceof Error ? error.message : String(error);
+}
+async function collectInitContext(rawInput = {}, options = {}) {
+	const projectDir = path.resolve(options.projectDir ?? process.cwd());
+	const input = InitCommandInputSchema.parse(rawInput);
+	const useDefaults = input.yes === true;
+	const verbose = input.verbose === true;
+	const shouldGenerate = input.generate ?? DEFAULT_GENERATE;
+	if (!options.skipIntro) intro(getCreatePrismaIntro());
+	let prismaFilesMode = "create";
+	const existingPrismaFiles = findExistingPrismaFiles(projectDir);
+	const canReuseExistingPrismaFiles = canReusePrismaFiles(projectDir);
+	if (existingPrismaFiles.length > 0) if (useDefaults) prismaFilesMode = canReuseExistingPrismaFiles ? "reuse" : "overwrite";
+	else {
+		const selectedMode = await promptForPrismaFilesMode(existingPrismaFiles, canReuseExistingPrismaFiles, projectDir);
+		if (!selectedMode) return;
+		prismaFilesMode = selectedMode;
+	}
+	const databaseProvider = input.provider ?? (useDefaults ? DEFAULT_DATABASE_PROVIDER : await promptForDatabaseProvider());
+	if (!databaseProvider) return;
+	const schemaPreset = input.schemaPreset ?? DEFAULT_SCHEMA_PRESET$1;
+	const databaseUrl = input.databaseUrl;
+	let shouldUsePrismaPostgres = false;
+	if (databaseProvider === "postgresql" && !databaseUrl) {
+		const prismaPostgresChoice = input.prismaPostgres ?? (useDefaults ? DEFAULT_PRISMA_POSTGRES : await promptForPrismaPostgres());
+		if (prismaPostgresChoice === void 0) return;
+		shouldUsePrismaPostgres = prismaPostgresChoice;
+	}
+	const detectedPackageManager = await detectPackageManager(projectDir);
+	const packageManager = input.packageManager ?? (useDefaults ? detectedPackageManager : await promptForPackageManager(detectedPackageManager));
+	if (!packageManager) return;
+	const shouldInstall = input.install ?? (useDefaults ? DEFAULT_INSTALL : await promptForDependencyInstall(packageManager));
+	if (shouldInstall === void 0) return;
+	return {
+		projectDir,
+		verbose,
+		shouldGenerate,
+		prismaFilesMode,
+		databaseProvider,
+		schemaPreset,
+		databaseUrl,
+		shouldUsePrismaPostgres,
+		packageManager,
+		shouldInstall
+	};
+}
+async function provisionPrismaPostgresIfNeeded(context, projectDir) {
+	if (!context.shouldUsePrismaPostgres) return { databaseUrl: context.databaseUrl };
+	const createDbCommand = getCreateDbCommand(context.packageManager);
+	const prismaPostgresSpinner = spinner();
+	prismaPostgresSpinner.start(`Provisioning Prisma Postgres with ${createDbCommand}...`);
+	try {
+		const prismaPostgresResult = await provisionPrismaPostgres(context.packageManager, projectDir);
+		prismaPostgresSpinner.stop("Prisma Postgres database provisioned.");
+		return {
+			databaseUrl: prismaPostgresResult.databaseUrl,
+			claimUrl: prismaPostgresResult.claimUrl
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		prismaPostgresSpinner.stop("Could not provision Prisma Postgres.");
+		return {
+			databaseUrl: context.databaseUrl,
+			warning: `Prisma Postgres provisioning failed: ${errorMessage}`
+		};
+	}
+}
+async function writeDependenciesForContext(context, projectDir) {
+	try {
+		return await writePrismaDependencies(context.databaseProvider, projectDir);
+	} catch (error) {
+		cancel(getCommandErrorMessage(error));
+		return;
+	}
+}
+async function installDependenciesForContext(context, projectDir) {
+	if (!context.shouldInstall) return true;
+	const installCommand = getInstallCommand(context.packageManager);
+	if (context.verbose) {
+		log.step(`Running ${installCommand}`);
+		try {
+			await installProjectDependencies(context.packageManager, projectDir, { verbose: context.verbose });
+			log.success("Dependencies installed.");
+			return true;
+		} catch (error) {
+			cancel(`Failed to run ${installCommand}: ${getCommandErrorMessage(error)}`);
+			return false;
+		}
+	}
+	const installSpinner = spinner();
+	installSpinner.start(`Running ${installCommand}...`);
+	try {
+		await installProjectDependencies(context.packageManager, projectDir, { verbose: context.verbose });
+		installSpinner.stop("Dependencies installed.");
+		return true;
+	} catch (error) {
+		installSpinner.stop("Could not install dependencies.");
+		cancel(`Failed to run ${installCommand}: ${getCommandErrorMessage(error)}`);
+		return false;
+	}
+}
+async function initializePrismaFilesForContext(context, projectDir, provisionResult) {
+	const initSpinner = spinner();
+	initSpinner.start("Preparing Prisma files...");
+	try {
+		const initResult = await initializePrismaFiles({
+			provider: context.databaseProvider,
+			databaseUrl: provisionResult.databaseUrl,
+			claimUrl: provisionResult.claimUrl,
+			schemaPreset: context.schemaPreset,
+			prismaFilesMode: context.prismaFilesMode,
+			projectDir
+		});
+		if (initResult.prismaFilesMode === "overwrite") initSpinner.stop("Prisma files updated.");
+		else if (initResult.prismaFilesMode === "reuse") initSpinner.stop("Using existing Prisma files.");
+		else initSpinner.stop("Prisma files ready.");
+		return initResult;
+	} catch (error) {
+		initSpinner.stop("Could not prepare Prisma files.");
+		cancel(getCommandErrorMessage(error));
+		return;
+	}
+}
+async function generatePrismaClientForContext(context, projectDir) {
+	if (!context.shouldGenerate) return { didGenerateClient: false };
+	const generateCommand = getPrismaCliCommand(context.packageManager, ["generate"]);
+	if (context.verbose) log.step(`Running ${generateCommand}`);
+	const generateSpinner = context.verbose ? void 0 : spinner();
+	generateSpinner?.start("Generating Prisma Client...");
+	try {
+		const generateArgs = getPrismaCliArgs(context.packageManager, ["generate"]);
+		await execa(generateArgs.command, generateArgs.args, {
+			cwd: projectDir,
+			stdio: context.verbose ? "inherit" : "pipe"
+		});
+		if (context.verbose) log.success("Prisma Client generated.");
+		else generateSpinner?.stop("Prisma Client generated.");
+		return { didGenerateClient: true };
+	} catch (error) {
+		if (context.verbose) log.warn("Could not generate Prisma Client.");
+		else generateSpinner?.stop("Could not generate Prisma Client.");
+		return {
+			didGenerateClient: false,
+			warning: `Prisma generate failed: ${getCommandErrorMessage(error)}`
+		};
+	}
+}
+function buildWarningLines(provisionWarning, generateWarning) {
+	const warningLines = [];
+	if (provisionWarning) warningLines.push(`- ${provisionWarning}`);
+	if (generateWarning) warningLines.push(`- ${generateWarning}`);
+	return warningLines;
+}
+function buildNextStepsForContext(opts) {
+	const { context, options, didGenerateClient } = opts;
+	const nextSteps = [...options.prependNextSteps ?? []];
+	if (!context.shouldInstall) nextSteps.push(`- ${getInstallCommand(context.packageManager)}`);
+	if (!didGenerateClient || !context.shouldGenerate) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:generate")}`);
+	nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:migrate")}`);
+	if (options.includeDevNextStep) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "dev")}`);
+	return nextSteps;
+}
+async function executeInitContext(context, options = {}) {
+	const projectDir = path.resolve(options.projectDir ?? context.projectDir);
+	const provisionResult = await provisionPrismaPostgresIfNeeded(context, projectDir);
+	if (!provisionResult) return;
+	if (!await writeDependenciesForContext(context, projectDir)) return;
+	if (!await installDependenciesForContext(context, projectDir)) return;
+	if (!await initializePrismaFilesForContext(context, projectDir, provisionResult)) return;
+	const generateResult = await generatePrismaClientForContext(context, projectDir);
+	const warningLines = buildWarningLines(provisionResult.warning, generateResult.warning);
+	const nextSteps = buildNextStepsForContext({
+		context,
+		options,
+		didGenerateClient: generateResult.didGenerateClient
+	});
+	outro(`Setup complete.${warningLines.length > 0 ? `\n\n${warningLines.join("\n")}` : ""}
+
+Next steps:
+${nextSteps.join("\n")}`);
+	return { packageManager: context.packageManager };
+}
+async function runInitCommand(rawInput = {}, options = {}) {
+	try {
+		const context = await collectInitContext(rawInput, options);
+		if (!context) return;
+		return executeInitContext(context, options);
+	} catch (error) {
+		cancel(`Init command failed: ${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+}
+
+//#endregion
+//#region src/commands/create.ts
+const DEFAULT_PROJECT_NAME = "my-app";
+const DEFAULT_TEMPLATE = "hono";
+const DEFAULT_SCHEMA_PRESET = "basic";
+function toPackageName(projectName) {
+	return projectName.toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^-+/, "").replace(/-+$/, "") || "app";
+}
+function formatPathForDisplay(filePath) {
+	return path.relative(process.cwd(), filePath) || ".";
+}
+function validateProjectName(value) {
+	const trimmed = String(value ?? "").trim();
+	if (trimmed.length === 0) return "Please enter a project name.";
+	if (trimmed === "." || trimmed === "..") return "Project name cannot be '.' or '..'.";
+	if (path.isAbsolute(trimmed)) return "Use a relative project name instead of an absolute path.";
+}
+async function promptForProjectName() {
+	const projectName = await text({
+		message: "Project name",
+		placeholder: DEFAULT_PROJECT_NAME,
+		initialValue: DEFAULT_PROJECT_NAME,
+		validate: validateProjectName
+	});
+	if (isCancel(projectName)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return String(projectName).trim();
+}
+async function promptForCreateTemplate() {
+	const template = await select({
+		message: "Select template",
+		initialValue: DEFAULT_TEMPLATE,
+		options: [{
+			value: "hono",
+			label: "Hono",
+			hint: "Bun + TypeScript API starter"
+		}, {
+			value: "next",
+			label: "Next.js",
+			hint: "App Router + TypeScript starter"
+		}]
+	});
+	if (isCancel(template)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return CreateTemplateSchema.parse(template);
+}
+async function inspectTargetPath(targetPath) {
+	if (!await fs.pathExists(targetPath)) return {
+		exists: false,
+		isDirectory: true,
+		isEmptyDirectory: true
+	};
+	if (!(await fs.stat(targetPath)).isDirectory()) return {
+		exists: true,
+		isDirectory: false,
+		isEmptyDirectory: false
+	};
+	return {
+		exists: true,
+		isDirectory: true,
+		isEmptyDirectory: (await fs.readdir(targetPath)).length === 0
+	};
+}
+async function runCreateCommand(rawInput = {}) {
+	try {
+		const input = CreateCommandInputSchema.parse(rawInput);
+		intro(getCreatePrismaIntro());
+		const context = await collectCreateContext(input);
+		if (!context) return;
+		await executeCreateContext(context);
+	} catch (error) {
+		cancel(`Create command failed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+async function collectCreateContext(input) {
+	const useDefaults = input.yes === true;
+	const force = input.force === true;
+	const projectName = input.name ?? (useDefaults ? DEFAULT_PROJECT_NAME : await promptForProjectName());
+	if (!projectName) return;
+	const template = input.template ?? (useDefaults ? DEFAULT_TEMPLATE : await promptForCreateTemplate());
+	if (!template) return;
+	const schemaPreset = input.schemaPreset ?? DEFAULT_SCHEMA_PRESET;
+	const targetDirectory = path.resolve(process.cwd(), projectName);
+	const targetPathState = await inspectTargetPath(targetDirectory);
+	if (targetPathState.exists && !targetPathState.isDirectory) {
+		cancel(`Target path ${formatPathForDisplay(targetDirectory)} already exists and is not a directory. Choose a different project name.`);
+		return;
+	}
+	if (targetPathState.exists && !targetPathState.isEmptyDirectory && !force) {
+		cancel(`Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`);
+		return;
+	}
+	const initContext = await collectInitContext({
+		yes: input.yes,
+		verbose: input.verbose,
+		provider: input.provider,
+		packageManager: input.packageManager,
+		prismaPostgres: input.prismaPostgres,
+		databaseUrl: input.databaseUrl,
+		install: input.install,
+		generate: input.generate,
+		schemaPreset
+	}, {
+		skipIntro: true,
+		projectDir: targetDirectory
+	});
+	if (!initContext) return;
+	return {
+		targetDirectory,
+		targetPathState,
+		force,
+		template,
+		schemaPreset,
+		projectPackageName: toPackageName(path.basename(targetDirectory)),
+		initContext
+	};
+}
+async function executeCreateContext(context) {
+	const scaffoldSpinner = spinner();
+	scaffoldSpinner.start(`Scaffolding ${context.template} project...`);
+	try {
+		await scaffoldCreateTemplate({
+			projectDir: context.targetDirectory,
+			projectName: context.projectPackageName,
+			template: context.template,
+			schemaPreset: context.schemaPreset,
+			packageManager: context.initContext.packageManager
+		});
+		scaffoldSpinner.stop("Project files scaffolded.");
+	} catch (error) {
+		scaffoldSpinner.stop("Could not scaffold project files.");
+		cancel(error instanceof Error ? error.message : String(error));
+		return;
+	}
+	if (context.targetPathState.exists && !context.targetPathState.isEmptyDirectory && context.force) log.warn(`Used --force in non-empty directory ${formatPathForDisplay(context.targetDirectory)}.`);
+	const cdStep = `- cd ${formatPathForDisplay(context.targetDirectory)}`;
+	await executeInitContext(context.initContext, {
+		skipIntro: true,
+		prependNextSteps: [cdStep],
+		projectDir: context.targetDirectory,
+		includeDevNextStep: true
+	});
+}
+
+//#endregion
+export { DatabaseProviderSchema as a, PackageManagerSchema as c, CreateTemplateSchema as i, SchemaPresetSchema as l, runInitCommand as n, DatabaseUrlSchema as o, CreateCommandInputSchema as r, InitCommandInputSchema as s, runCreateCommand as t };