create-prisma 0.1.3 → 0.1.4

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./create-fJECj1B0.mjs";
+import "./create-Dz9GFGFQ.mjs";
 import { createCreatePrismaCli } from "./index.mjs";
 
 //#region src/cli.ts

package/dist/{create-fJECj1B0.mjs → create-Dz9GFGFQ.mjs}

@@ -7,8 +7,10 @@ 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) {
@@ -41,19 +43,25 @@ function stripHbsExtension(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 relativeTemplatePath = path.relative(templateRoot, templateFilePath);
-		const relativeOutputPath = stripHbsExtension(relativeTemplatePath);
-		const outputPath = path.join(outputDir, relativeOutputPath);
-		const templateContent = await fs.readFile(templateFilePath, "utf8");
-		const outputContent = relativeTemplatePath.endsWith(".hbs") ? Handlebars.compile(templateContent, {
-			noEscape: true,
-			strict: true
-		})(context) : templateContent;
-		await fs.outputFile(outputPath, ensureTrailingNewline(outputContent), "utf8");
+		const relativeOutputPath = stripHbsExtension(path.relative(templateRoot, templateFilePath));
+		await renderTemplateFile({
+			templateFilePath,
+			outputPath: path.join(outputDir, relativeOutputPath),
+			context
+		});
 	}
 }
 
@@ -62,19 +70,19 @@ async function renderTemplateTree(opts) {
 function getCreateTemplateDir(template) {
 	return resolveTemplatesDir(`templates/create/${template}`);
 }
-function createTemplateContext$1(projectName, schemaPreset) {
+function createTemplateContext$1(projectName, schemaPreset, packageManager) {
 	return {
 		projectName,
 		schemaPreset,
-		useBasicSchema: schemaPreset === "basic"
+		packageManager
 	};
 }
 async function scaffoldCreateTemplate(opts) {
-	const { projectDir, projectName, template, schemaPreset } = opts;
+	const { projectDir, projectName, template, schemaPreset, packageManager } = opts;
 	await renderTemplateTree({
 		templateRoot: getCreateTemplateDir(template),
 		outputDir: projectDir,
-		context: createTemplateContext$1(projectName, schemaPreset)
+		context: createTemplateContext$1(projectName, schemaPreset, packageManager)
 	});
 }
 
@@ -112,13 +120,13 @@ const PrismaSetupOptionsSchema = z.object({
 	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.merge(PrismaSetupOptionsSchema);
+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.merge(CreateScaffoldOptionsSchema).merge(PrismaSetupOptionsSchema);
+const CreateCommandInputSchema = CommonCommandOptionsSchema.extend(CreateScaffoldOptionsSchema.shape).extend(PrismaSetupOptionsSchema.shape);
 
 //#endregion
 //#region src/utils/package-manager.ts
@@ -171,7 +179,7 @@ async function detectPackageManager(projectDir = process.cwd()) {
 	if (fromLockfile) return fromLockfile;
 	const fromUserAgent = parseUserAgent(process.env.npm_config_user_agent);
 	if (fromUserAgent) return fromUserAgent;
-	return "bun";
+	return "npm";
 }
 function getInstallCommand(packageManager) {
 	return `${packageManager} install`;
@@ -293,12 +301,7 @@ function createTemplateContext(provider, envVar, schemaPreset) {
 	return {
 		envVar,
 		provider,
-		schemaPreset,
-		usePgAdapter: provider === "postgresql" || provider === "cockroachdb",
-		useMariaDbAdapter: provider === "mysql",
-		useSqliteAdapter: provider === "sqlite",
-		useMssqlAdapter: provider === "sqlserver",
-		useBasicSchema: schemaPreset === "basic"
+		schemaPreset
 	};
 }
 async function scaffoldInitTemplates(projectDir, provider, envVar = "DATABASE_URL", schemaPreset = "empty") {
@@ -489,7 +492,7 @@ const dependencyVersionMap = {
 };
 
 //#endregion
-//#region src/db/config.ts
+//#region src/constants/db-packages.ts
 function getDbPackages(provider) {
 	switch (provider) {
 		case "postgresql":
@@ -591,6 +594,13 @@ async function installProjectDependencies(packageManager, projectDir = process.c
 	});
 }
 
+//#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";
@@ -627,7 +637,7 @@ async function promptForDatabaseProvider() {
 		]
 	});
 	if (isCancel(databaseProvider)) {
-		cancel("Cancelled.");
+		cancel("Operation cancelled.");
 		return;
 	}
 	return DatabaseProviderSchema.parse(databaseProvider);
@@ -659,7 +669,7 @@ async function promptForPackageManager(detectedPackageManager) {
 		]
 	});
 	if (isCancel(packageManager)) {
-		cancel("Cancelled.");
+		cancel("Operation cancelled.");
 		return;
 	}
 	return PackageManagerSchema.parse(packageManager);
@@ -670,7 +680,7 @@ async function promptForDependencyInstall(packageManager) {
 		initialValue: true
 	});
 	if (isCancel(shouldInstall)) {
-		cancel("Cancelled.");
+		cancel("Operation cancelled.");
 		return;
 	}
 	return Boolean(shouldInstall);
@@ -681,22 +691,11 @@ async function promptForPrismaPostgres() {
 		initialValue: true
 	});
 	if (isCancel(shouldUsePrismaPostgres)) {
-		cancel("Cancelled.");
+		cancel("Operation cancelled.");
 		return;
 	}
 	return Boolean(shouldUsePrismaPostgres);
 }
-async function promptContinueWithDefaultPostgresUrl() {
-	const shouldContinue = await confirm({
-		message: "Continue with default local PostgreSQL DATABASE_URL instead?",
-		initialValue: true
-	});
-	if (isCancel(shouldContinue)) {
-		cancel("Cancelled.");
-		return;
-	}
-	return Boolean(shouldContinue);
-}
 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?`,
@@ -724,49 +723,23 @@ async function promptForPrismaFilesMode(existingFiles, canReuseExistingPrismaFil
 			label: "Cancel"
 		}]
 	});
-	if (isCancel(mode) || mode === "cancel") {
-		cancel("Cancelled.");
+	if (isCancel(mode)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	if (mode === "cancel") {
+		cancel("Operation cancelled.");
 		return;
 	}
 	if (mode !== "reuse" && mode !== "overwrite") {
-		cancel("Cancelled.");
+		cancel("Operation cancelled.");
 		return;
 	}
 	return mode;
 }
-function formatEnvStatus(status, envPath, envVarName, baseDir) {
-	const relativeEnvPath = path.relative(baseDir, envPath) || ".env";
-	switch (status) {
-		case "created": return `Created ${relativeEnvPath} with ${envVarName}`;
-		case "appended": return `Appended ${envVarName} to ${relativeEnvPath}`;
-		case "existing": return `Kept existing ${envVarName} in ${relativeEnvPath}`;
-		case "updated": return `Updated ${envVarName} in ${relativeEnvPath}`;
-		default: return `Updated ${relativeEnvPath}`;
-	}
-}
-function formatGitignoreStatus(status, gitignorePath, baseDir) {
-	const relativePath = path.relative(baseDir, gitignorePath) || ".gitignore";
-	switch (status) {
-		case "created": return `Created ${relativePath} with prisma/generated`;
-		case "appended": return `Added prisma/generated to ${relativePath}`;
-		case "existing": return `Kept existing prisma/generated ignore in ${relativePath}`;
-		default: return `Updated ${relativePath}`;
-	}
-}
 function formatCreatedPath(filePath, baseDir) {
 	return path.relative(baseDir, filePath);
 }
-function formatFileAction(action) {
-	switch (action) {
-		case "create": return "Created";
-		case "overwrite": return "Wrote";
-		case "reuse": return "Kept existing";
-		default: {
-			const exhaustiveCheck = action;
-			throw new Error(`Unsupported file action: ${String(exhaustiveCheck)}`);
-		}
-	}
-}
 function getCommandErrorMessage(error) {
 	if (error instanceof Error && "stderr" in error) {
 		const stderr = String(error.stderr ?? "").trim();
@@ -774,13 +747,13 @@ function getCommandErrorMessage(error) {
 	}
 	return error instanceof Error ? error.message : String(error);
 }
-async function runInitCommand(rawInput = {}, options = {}) {
+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("Create Prisma");
+	if (!options.skipIntro) intro(getCreatePrismaIntro());
 	let prismaFilesMode = "create";
 	const existingPrismaFiles = findExistingPrismaFiles(projectDir);
 	const canReuseExistingPrismaFiles = canReusePrismaFiles(projectDir);
@@ -793,134 +766,176 @@ async function runInitCommand(rawInput = {}, options = {}) {
 	const databaseProvider = input.provider ?? (useDefaults ? DEFAULT_DATABASE_PROVIDER : await promptForDatabaseProvider());
 	if (!databaseProvider) return;
 	const schemaPreset = input.schemaPreset ?? DEFAULT_SCHEMA_PRESET$1;
-	let databaseUrl = input.databaseUrl;
+	const databaseUrl = input.databaseUrl;
 	let shouldUsePrismaPostgres = false;
-	let claimUrl;
-	let prismaPostgresWarning;
 	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 finalPackageManager = input.packageManager ?? (useDefaults ? detectedPackageManager : await promptForPackageManager(detectedPackageManager));
-	if (!finalPackageManager) return;
-	const installCommand = getInstallCommand(finalPackageManager);
-	if (shouldUsePrismaPostgres) {
-		const createDbCommand = getCreateDbCommand(finalPackageManager);
-		const prismaPostgresSpinner = spinner();
-		prismaPostgresSpinner.start(`Provisioning Prisma Postgres with ${createDbCommand}...`);
-		try {
-			const prismaPostgresResult = await provisionPrismaPostgres(finalPackageManager);
-			databaseUrl = prismaPostgresResult.databaseUrl;
-			claimUrl = prismaPostgresResult.claimUrl;
-			prismaPostgresSpinner.stop("Prisma Postgres database provisioned.");
-		} catch (error) {
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			prismaPostgresSpinner.stop("Could not provision Prisma Postgres.");
-			prismaPostgresWarning = `Prisma Postgres provisioning failed: ${errorMessage}`;
-			const shouldContinue = useDefaults ? true : await promptContinueWithDefaultPostgresUrl();
-			if (shouldContinue === void 0) return;
-			if (!shouldContinue) {
-				cancel("Cancelled.");
-				return;
-			}
-		}
-	}
-	const dependencyWriteResult = await writePrismaDependencies(databaseProvider, projectDir);
-	const shouldInstall = input.install ?? (useDefaults ? DEFAULT_INSTALL : await promptForDependencyInstall(finalPackageManager));
+	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;
-	if (shouldInstall) if (verbose) {
+	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(finalPackageManager, projectDir, { verbose });
+			await installProjectDependencies(context.packageManager, projectDir, { verbose: context.verbose });
 			log.success("Dependencies installed.");
+			return true;
 		} catch (error) {
 			cancel(`Failed to run ${installCommand}: ${getCommandErrorMessage(error)}`);
-			return;
-		}
-	} else {
-		const installSpinner = spinner();
-		installSpinner.start(`Running ${installCommand}...`);
-		try {
-			await installProjectDependencies(finalPackageManager, projectDir, { verbose });
-			installSpinner.stop("Dependencies installed.");
-		} catch (error) {
-			installSpinner.stop("Could not install dependencies.");
-			cancel(`Failed to run ${installCommand}: ${getCommandErrorMessage(error)}`);
-			return;
+			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...");
-	let initResult;
 	try {
-		initResult = await initializePrismaFiles({
-			provider: databaseProvider,
-			databaseUrl,
-			claimUrl,
-			schemaPreset,
-			prismaFilesMode,
+		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;
 	}
-	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.");
-	let generateWarning;
-	let didGenerateClient = false;
-	if (shouldGenerate) {
-		const generateCommand = getPrismaCliCommand(finalPackageManager, ["generate"]);
-		if (verbose) log.step(`Running ${generateCommand}`);
-		const generateSpinner = verbose ? void 0 : spinner();
-		generateSpinner?.start("Generating Prisma Client...");
-		try {
-			const generateArgs = getPrismaCliArgs(finalPackageManager, ["generate"]);
-			await execa(generateArgs.command, generateArgs.args, {
-				cwd: projectDir,
-				stdio: verbose ? "inherit" : "pipe"
-			});
-			didGenerateClient = true;
-			if (verbose) log.success("Prisma Client generated.");
-			else generateSpinner?.stop("Prisma Client generated.");
-		} catch (error) {
-			if (verbose) log.warn("Could not generate Prisma Client.");
-			else generateSpinner?.stop("Could not generate Prisma Client.");
-			generateWarning = `Prisma generate failed: ${getCommandErrorMessage(error)}`;
-		}
+}
+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)}`
+		};
 	}
-	const fileActionLabel = formatFileAction(initResult.prismaFilesMode);
-	const summaryLines = [
-		`- ${fileActionLabel} ${formatCreatedPath(initResult.schemaPath, projectDir)}`,
-		`- ${fileActionLabel} ${formatCreatedPath(initResult.configPath, projectDir)}`,
-		`- ${fileActionLabel} ${formatCreatedPath(initResult.singletonPath, projectDir)}`
-	];
-	if (initResult.envStatus !== "existing") summaryLines.push(`- ${formatEnvStatus(initResult.envStatus, initResult.envPath, "DATABASE_URL", projectDir)}`);
-	if (initResult.claimEnvStatus) summaryLines.push(`- ${formatEnvStatus(initResult.claimEnvStatus, initResult.envPath, "CLAIM_URL", projectDir)}`);
-	if (initResult.gitignoreStatus !== "existing") summaryLines.push(`- ${formatGitignoreStatus(initResult.gitignoreStatus, initResult.gitignorePath, projectDir)}`);
-	if (dependencyWriteResult.addedScripts.length > 0) summaryLines.push(`- Added package.json scripts: ${dependencyWriteResult.addedScripts.join(", ")}`);
-	else if (dependencyWriteResult.scripts.length > 0) summaryLines.push(`- Kept existing package.json scripts: ${dependencyWriteResult.scripts.join(", ")}`);
-	if (!shouldInstall) summaryLines.push(`- Skipped ${installCommand}.`);
-	else summaryLines.push(`- Installed dependencies with ${installCommand}.`);
-	if (!shouldGenerate) summaryLines.push("- Skipped Prisma Client generation.");
-	else if (didGenerateClient) summaryLines.push("- Prisma Client generated.");
-	const postgresLines = [];
-	if (prismaPostgresWarning) postgresLines.push(`- ${prismaPostgresWarning}`);
-	if (generateWarning) postgresLines.push(`- ${generateWarning}`);
+}
+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 (!shouldInstall) nextSteps.push(`- ${installCommand}`);
-	if (!didGenerateClient || !shouldGenerate) nextSteps.push(`- ${getRunScriptCommand(finalPackageManager, "db:generate")}`);
-	nextSteps.push(`- ${getRunScriptCommand(finalPackageManager, "db:migrate")}`);
-	outro(`Setup complete.
-${summaryLines.join("\n")}
-${postgresLines.length > 0 ? `\n${postgresLines.join("\n")}` : ""}
+	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
@@ -934,17 +949,21 @@ function toPackageName(projectName) {
 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: (value) => {
-			return String(value ?? "").trim().length > 0 ? void 0 : "Please enter a valid project name.";
-		}
+		validate: validateProjectName
 	});
 	if (isCancel(projectName)) {
-		cancel("Cancelled.");
+		cancel("Operation cancelled.");
 		return;
 	}
 	return String(projectName).trim();
@@ -964,17 +983,40 @@ async function promptForCreateTemplate() {
 		}]
 	});
 	if (isCancel(template)) {
-		cancel("Cancelled.");
+		cancel("Operation cancelled.");
 		return;
 	}
 	return CreateTemplateSchema.parse(template);
 }
-async function isDirectoryEmpty(directoryPath) {
-	if (!await fs.pathExists(directoryPath)) return true;
-	return (await fs.readdir(directoryPath)).length === 0;
+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 = {}) {
-	const input = CreateCommandInputSchema.parse(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());
@@ -983,29 +1025,16 @@ async function runCreateCommand(rawInput = {}) {
 	if (!template) return;
 	const schemaPreset = input.schemaPreset ?? DEFAULT_SCHEMA_PRESET;
 	const targetDirectory = path.resolve(process.cwd(), projectName);
-	const targetExists = await fs.pathExists(targetDirectory);
-	const targetIsEmpty = await isDirectoryEmpty(targetDirectory);
-	if (targetExists && !targetIsEmpty && !force) {
-		cancel(`Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`);
+	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;
 	}
-	const scaffoldSpinner = spinner();
-	scaffoldSpinner.start(`Scaffolding ${template} project...`);
-	try {
-		await scaffoldCreateTemplate({
-			projectDir: targetDirectory,
-			projectName: toPackageName(path.basename(targetDirectory)),
-			template,
-			schemaPreset
-		});
-		scaffoldSpinner.stop("Project files scaffolded.");
-	} catch (error) {
-		scaffoldSpinner.stop("Could not scaffold project files.");
-		cancel(error instanceof Error ? error.message : String(error));
+	if (targetPathState.exists && !targetPathState.isEmptyDirectory && !force) {
+		cancel(`Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`);
 		return;
 	}
-	if (targetExists && !targetIsEmpty && force) log.warn(`Used --force in non-empty directory ${formatPathForDisplay(targetDirectory)}.`);
-	await runInitCommand({
+	const initContext = await collectInitContext({
 		yes: input.yes,
 		verbose: input.verbose,
 		provider: input.provider,
@@ -1017,9 +1046,44 @@ async function runCreateCommand(rawInput = {}) {
 		schemaPreset
 	}, {
 		skipIntro: true,
-		prependNextSteps: [`- cd ${formatPathForDisplay(targetDirectory)}`],
 		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

package/dist/index.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { a as DatabaseProviderSchema, c as PackageManagerSchema, i as CreateTemplateSchema, l as SchemaPresetSchema, n as runInitCommand, o as DatabaseUrlSchema, r as CreateCommandInputSchema, s as InitCommandInputSchema, t as runCreateCommand } from "./create-fJECj1B0.mjs";
+import { a as DatabaseProviderSchema, c as PackageManagerSchema, i as CreateTemplateSchema, l as SchemaPresetSchema, n as runInitCommand, o as DatabaseUrlSchema, r as CreateCommandInputSchema, s as InitCommandInputSchema, t as runCreateCommand } from "./create-Dz9GFGFQ.mjs";
 import { os } from "@orpc/server";
 import { createCli } from "trpc-cli";
 
 //#region src/index.ts
-const CLI_VERSION = "0.1.3";
+const CLI_VERSION = "0.1.4";
 const router = os.router({
 	create: os.meta({
 		description: "Create a new project with Prisma setup",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Create and initialize Prisma 7 projects with first-party templates and great DX.",
   "repository": {
     "type": "git",

package/templates/create/hono/README.md.hbs

@@ -4,25 +4,63 @@ Generated by `create-prisma` with the Hono template.
 
 ## Scripts
 
+{{#if (eq packageManager "bun")}}
 - `bun run dev` - start local dev server
 - `bun run build` - typecheck and compile
 - `bun run start` - run compiled server from `dist/`
+{{else}}
+{{#if (eq packageManager "pnpm")}}
+- `pnpm dev` - start local dev server
+- `pnpm build` - typecheck and compile
+- `pnpm start` - run compiled server from `dist/`
+{{else}}
+{{#if (eq packageManager "npm")}}
+- `npm run dev` - start local dev server
+- `npm run build` - typecheck and compile
+- `npm run start` - run compiled server from `dist/`
+{{else}}
+- `npm run dev` or `pnpm dev` or `bun run dev` - start local dev server
+- `npm run build` or `pnpm build` or `bun run build` - typecheck and compile
+- `npm run start` or `pnpm start` or `bun run start` - run compiled server from `dist/`
+{{/if}}
+{{/if}}
+{{/if}}
 
 ## Prisma
 
 1. Make sure dependencies are installed.
 2. Generate Prisma Client:
 
-```bash
-bunx --bun prisma generate
-```
+{{#if (eq packageManager "bun")}}
+`bun run db:generate`
+{{else}}
+{{#if (eq packageManager "pnpm")}}
+`pnpm db:generate`
+{{else}}
+{{#if (eq packageManager "npm")}}
+`npm run db:generate`
+{{else}}
+`npm run db:generate` or `pnpm db:generate` or `bun run db:generate`
+{{/if}}
+{{/if}}
+{{/if}}
 
 3. Run your first migration:
 
-```bash
-bunx --bun prisma migrate dev
-```
-{{#if useBasicSchema}}
+{{#if (eq packageManager "bun")}}
+`bun run db:migrate`
+{{else}}
+{{#if (eq packageManager "pnpm")}}
+`pnpm db:migrate`
+{{else}}
+{{#if (eq packageManager "npm")}}
+`npm run db:migrate`
+{{else}}
+`npm run db:migrate` or `pnpm db:migrate` or `bun run db:migrate`
+{{/if}}
+{{/if}}
+{{/if}}
+{{#if (eq schemaPreset "basic")}}
 
 The template includes a basic `User` model and a sample `GET /users` endpoint.
 {{/if}}

package/templates/create/hono/package.json.hbs

@@ -5,7 +5,7 @@
   "scripts": {
     "dev": "tsx watch src/index.ts",
     "build": "tsc",
-    "start": "node dist/src/index.js"
+    "start": "tsx dist/src/index.js"
   },
   "dependencies": {
     "@hono/node-server": "^1.19.9",

package/templates/create/hono/src/index.ts.hbs

@@ -1,6 +1,6 @@
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
-{{#if useBasicSchema}}
+{{#if (eq schemaPreset "basic")}}
 import { prisma } from "../prisma";
 {{/if}}
 
@@ -11,7 +11,7 @@ app.get("/", (c) => {
     message: "hello from create-prisma + hono",
   });
 });
-{{#if useBasicSchema}}
+{{#if (eq schemaPreset "basic")}}
 
 app.get("/users", async (c) => {
   const users = await prisma.user.findMany({

package/templates/create/next/README.md.hbs

@@ -4,9 +4,27 @@ Generated by `create-prisma` with the Next.js template.
 
 ## Scripts
 
+{{#if (eq packageManager "bun")}}
+- `bun dev` - start local dev server
+- `bun run build` - production build
+- `bun run start` - run production server
+{{else}}
+{{#if (eq packageManager "pnpm")}}
+- `pnpm dev` - start local dev server
+- `pnpm build` - production build
+- `pnpm start` - run production server
+{{else}}
+{{#if (eq packageManager "npm")}}
+- `npm run dev` - start local dev server
+- `npm run build` - production build
+- `npm run start` - run production server
+{{else}}
 - `npm run dev` or `pnpm dev` or `bun dev` - start local dev server
 - `npm run build` or `pnpm build` or `bun run build` - production build
 - `npm run start` or `pnpm start` or `bun run start` - run production server
+{{/if}}
+{{/if}}
+{{/if}}
 
 ## Prisma
 
@@ -21,7 +39,7 @@ Database helper scripts are added to `package.json`:
 - `db:generate`
 - `db:push`
 - `db:migrate`
-{{#if useBasicSchema}}
+{{#if (eq schemaPreset "basic")}}
 
 The starter page reads from a basic `User` model so you can verify queries quickly.
 {{/if}}

package/templates/create/next/app/page.tsx.hbs

@@ -1,25 +1,31 @@
-{{#if useBasicSchema}}
+{{#if (eq schemaPreset "basic")}}
 import { prisma } from "../prisma";
 {{/if}}
 
 export default async function Home() {
-{{#if useBasicSchema}}
-  const users = await prisma.user.findMany({
-    take: 10,
-    orderBy: {
-      createdAt: "desc",
-    },
-  });
+{{#if (eq schemaPreset "basic")}}
+  const users = await prisma.user
+    .findMany({
+      take: 10,
+      orderBy: {
+        createdAt: "desc",
+      },
+    })
+    .catch(() => undefined);
 {{/if}}
 
   return (
     <main>
       <h1>create-prisma + next</h1>
       <p>Project is ready with Next.js App Router and Prisma 7.</p>
-{{#if useBasicSchema}}
+{{#if (eq schemaPreset "basic")}}
       <h2>Users</h2>
-      {users.length === 0 ? (
-        <p>No users yet. Run the <code>db:migrate</code> script, then create one.</p>
+      {!users ? (
+        <p>
+          Could not query users yet. Run the <code>db:migrate</code> script, then refresh.
+        </p>
+      ) : users.length === 0 ? (
+        <p>No users yet.</p>
       ) : (
         <ul>
           {users.map((user) => (

package/templates/init/prisma/index.ts.hbs

@@ -1,15 +1,18 @@
 import "dotenv/config";
 import { PrismaClient } from "./generated/client";
-{{#if usePgAdapter}}
+{{#if (eq provider "postgresql")}}
 import { PrismaPg } from "@prisma/adapter-pg";
 {{/if}}
-{{#if useMariaDbAdapter}}
+{{#if (eq provider "cockroachdb")}}
+import { PrismaPg } from "@prisma/adapter-pg";
+{{/if}}
+{{#if (eq provider "mysql")}}
 import { PrismaMariaDb } from "@prisma/adapter-mariadb";
 {{/if}}
-{{#if useSqliteAdapter}}
+{{#if (eq provider "sqlite")}}
 import { PrismaBetterSqlite3 } from "@prisma/adapter-better-sqlite3";
 {{/if}}
-{{#if useMssqlAdapter}}
+{{#if (eq provider "sqlserver")}}
 import { PrismaMssql } from "@prisma/adapter-mssql";
 {{/if}}
 
@@ -17,20 +20,25 @@ declare global {
   var prisma: PrismaClient | undefined;
 }
 
-{{#if usePgAdapter}}
+{{#if (eq provider "postgresql")}}
+const adapter = new PrismaPg({
+  connectionString: process.env.{{envVar}} ?? "",
+});
+{{/if}}
+{{#if (eq provider "cockroachdb")}}
 const adapter = new PrismaPg({
   connectionString: process.env.{{envVar}} ?? "",
 });
 {{/if}}
-{{#if useMariaDbAdapter}}
+{{#if (eq provider "mysql")}}
 const adapter = new PrismaMariaDb(process.env.{{envVar}} ?? "");
 {{/if}}
-{{#if useSqliteAdapter}}
+{{#if (eq provider "sqlite")}}
 const adapter = new PrismaBetterSqlite3({
   url: process.env.{{envVar}} ?? "file:./dev.db",
 });
 {{/if}}
-{{#if useMssqlAdapter}}
+{{#if (eq provider "sqlserver")}}
 const adapter = new PrismaMssql(process.env.{{envVar}} ?? "");
 {{/if}}
 

package/templates/init/prisma/schema.prisma.hbs

@@ -6,7 +6,7 @@ generator client {
 datasource db {
   provider = "{{provider}}"
 }
-{{#if useBasicSchema}}
+{{#if (eq schemaPreset "basic")}}
 
 model User {
   id        String   @id @default(cuid())