create-prisma 0.3.2 → 0.4.1-pr.33.62.1

package/dist/{create-DOr8R2_6.mjs → create-CDlZ32XO.mjs}

@@ -12,17 +12,55 @@ import os from "node:os";
 import { PostHog } from "posthog-node";
 import { styleText } from "node:util";
 
+//#region src/utils/runtime.ts
+function usesNodeStyleRuntime(packageManager) {
+	return packageManager !== void 0 && packageManager !== "bun" && packageManager !== "deno";
+}
+function requiresDotenvConfigImport(packageManager) {
+	return usesNodeStyleRuntime(packageManager);
+}
+
+//#endregion
 //#region src/constants/dependencies.ts
 const dependencyVersionMap = {
+	"@elysiajs/node": "^1.4.5",
 	"@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",
+	"@types/node": "^24.3.0",
 	dotenv: "^17.2.3",
 	"node-gyp": "^11.5.0",
-	prisma: "^7.4.0"
+	prisma: "^7.4.0",
+	tsx: "^4.21.0"
 };
+function getWorkspaceDependencyVersion(packageManager) {
+	return packageManager === "npm" ? "*" : "workspace:*";
+}
+function getCreateTemplateDependencies(template, packageManager) {
+	const targets = [];
+	if (template === "hono" || template === "elysia" || template === "nest") {
+		const runtimeDevDependencies = usesNodeStyleRuntime(packageManager) ? ["tsx"] : [];
+		if (template === "elysia" && packageManager !== "deno") targets.push({
+			packageJsonPath: "package.json",
+			dependencies: ["@elysiajs/node"],
+			devDependencies: ["@types/node", ...runtimeDevDependencies]
+		});
+		else if (runtimeDevDependencies.length > 0) targets.push({
+			packageJsonPath: "package.json",
+			dependencies: [],
+			devDependencies: runtimeDevDependencies
+		});
+	}
+	if (template === "turborepo") targets.push({
+		packageJsonPath: "apps/api/package.json",
+		dependencies: [],
+		devDependencies: ["tsx"],
+		customDependencies: { "@repo/db": getWorkspaceDependencyVersion(packageManager) }
+	});
+	return targets;
+}
 
 //#endregion
 //#region src/types.ts
@@ -43,6 +81,8 @@ const packageManagers = [
 const schemaPresets = ["empty", "basic"];
 const createTemplates = [
 	"hono",
+	"elysia",
+	"nest",
 	"next",
 	"svelte",
 	"astro",
@@ -181,10 +221,17 @@ function getPackageManagerManifestValue(packageManager) {
 	return packageManagerManifestValues[packageManager];
 }
 function getDenoPrismaSpecifier() {
-	return `npm:prisma@${dependencyVersionMap.prisma.replace(/^[^0-9]*/, "")}`;
+	return `npm:prisma@${dependencyVersionMap.prisma}`;
+}
+function getDenoAllowedScriptSpecifiers() {
+	return [
+		`npm:prisma@${dependencyVersionMap.prisma}`,
+		`npm:@prisma/client@${dependencyVersionMap["@prisma/client"]}`,
+		`npm:@prisma/engines@${dependencyVersionMap.prisma}`
+	].join(",");
 }
 function getInstallCommand(packageManager) {
-	if (packageManager === "deno") return "deno install --allow-scripts";
+	if (packageManager === "deno") return `deno install --allow-scripts=${getDenoAllowedScriptSpecifiers()}`;
 	return `${packageManager} install`;
 }
 function getRunScriptCommand(packageManager, scriptName) {
@@ -196,10 +243,46 @@ function getRunScriptCommand(packageManager, scriptName) {
 		default: return `npm run ${scriptName}`;
 	}
 }
+function joinCommandParts(parts) {
+	return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
+}
+function getRuntimeScriptCommand(packageManager, kind, options) {
+	const { sourceEntrypoint, builtEntrypoint, denoFlags = [] } = options;
+	if (packageManager === "deno") switch (kind) {
+		case "dev": return joinCommandParts([
+			"deno",
+			"run",
+			"-A",
+			"--env-file=.env",
+			...denoFlags,
+			"--watch",
+			sourceEntrypoint
+		]);
+		case "build": return `deno check ${sourceEntrypoint}`;
+		case "start": return joinCommandParts([
+			"deno",
+			"run",
+			"-A",
+			"--env-file=.env",
+			...denoFlags,
+			sourceEntrypoint
+		]);
+	}
+	if (packageManager === "bun") switch (kind) {
+		case "dev": return `bun --watch ${sourceEntrypoint}`;
+		case "build": return "tsc --noEmit";
+		case "start": return `bun ${sourceEntrypoint}`;
+	}
+	switch (kind) {
+		case "dev": return `tsx watch ${sourceEntrypoint}`;
+		case "build": return "tsc";
+		case "start": return builtEntrypoint ? `node ${builtEntrypoint}` : `tsx ${sourceEntrypoint}`;
+	}
+}
 function getInstallArgs(packageManager) {
 	if (packageManager === "deno") return {
 		command: "deno",
-		args: ["install", "--allow-scripts"]
+		args: ["install", `--allow-scripts=${getDenoAllowedScriptSpecifiers()}`]
 	};
 	return {
 		command: packageManager,
@@ -254,6 +337,7 @@ function getPrismaCliArgs(packageManager, prismaArgs) {
 		args: [
 			"run",
 			"-A",
+			"--env-file=.env",
 			getDenoPrismaSpecifier(),
 			...prismaArgs
 		]
@@ -267,10 +351,26 @@ function getPrismaCliCommand(packageManager, prismaArgs) {
 
 //#endregion
 //#region src/templates/shared.ts
+function getOptionalHashString(hash, key) {
+	const value = hash[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function getOptionalHashStringList(hash, key) {
+	return getOptionalHashString(hash, key)?.split(" ") ?? [];
+}
 Handlebars.registerHelper("eq", (left, right) => left === right);
-Handlebars.registerHelper("installCommand", (packageManager) => packageManager ? getInstallCommand(packageManager) : "");
 Handlebars.registerHelper("runScriptCommand", (packageManager, scriptName) => packageManager ? getRunScriptCommand(packageManager, scriptName) : "");
 Handlebars.registerHelper("packageManagerManifestValue", (packageManager) => getPackageManagerManifestValue(packageManager) ?? "");
+Handlebars.registerHelper("requiresDotenvConfigImport", (packageManager) => requiresDotenvConfigImport(packageManager));
+Handlebars.registerHelper("runtimeScript", (packageManager, kind, sourceEntrypoint, builtEntrypoint, options) => {
+	if (!packageManager) return "";
+	const hash = options.hash;
+	return getRuntimeScriptCommand(packageManager, kind, {
+		sourceEntrypoint,
+		builtEntrypoint,
+		denoFlags: getOptionalHashStringList(hash, "denoFlags")
+	});
+});
 function findPackageRoot(startDir) {
 	let currentDir = startDir;
 	while (true) {
@@ -353,10 +453,10 @@ async function scaffoldCreateTemplate(opts) {
 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" };
+		case "cockroachdb": return "@prisma/adapter-pg";
+		case "mysql": return "@prisma/adapter-mariadb";
+		case "sqlite": return "@prisma/adapter-better-sqlite3";
+		case "sqlserver": return "@prisma/adapter-mssql";
 		default: {
 			const exhaustiveCheck = provider;
 			throw new Error(`Unsupported database provider: ${String(exhaustiveCheck)}`);
@@ -370,10 +470,19 @@ function getPrismaScriptMap(packageManager) {
 	if (packageManager === "deno") {
 		const prismaSpecifier = getDenoPrismaSpecifier();
 		return {
-			"db:generate": `deno run -A ${prismaSpecifier} generate`,
-			"db:push": `deno run -A ${prismaSpecifier} db push`,
-			"db:migrate": `deno run -A ${prismaSpecifier} migrate dev`,
-			"db:seed": `deno run -A ${prismaSpecifier} db seed`
+			"db:generate": `deno run -A --env-file=.env ${prismaSpecifier} generate`,
+			"db:push": `deno run -A --env-file=.env ${prismaSpecifier} db push`,
+			"db:migrate": `deno run -A --env-file=.env ${prismaSpecifier} migrate dev`,
+			"db:seed": `deno run -A --env-file=.env ${prismaSpecifier} db seed`
+		};
+	}
+	if (packageManager === "bun") {
+		const prismaCli = "bun --env-file=.env ./node_modules/.bin/prisma";
+		return {
+			"db:generate": `${prismaCli} generate`,
+			"db:push": `${prismaCli} db push`,
+			"db:migrate": `${prismaCli} migrate dev`,
+			"db:seed": `${prismaCli} db seed`
 		};
 	}
 	return {
@@ -392,10 +501,27 @@ function unique(items) {
 function sortRecord(record) {
 	return Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
 }
+async function projectContainsText(projectDir, text) {
+	const directories = [projectDir];
+	while (directories.length > 0) {
+		const currentDirectory = directories.pop();
+		if (!currentDirectory) continue;
+		const entries = await fs.readdir(currentDirectory, { withFileTypes: true });
+		for (const entry of entries) {
+			if (entry.name === "node_modules" || entry.name === ".git") continue;
+			const entryPath = path.join(currentDirectory, entry.name);
+			if (entry.isDirectory()) {
+				directories.push(entryPath);
+				continue;
+			}
+			if (!entry.isFile() || !/\.(c|m)?[jt]sx?$/.test(entry.name)) continue;
+			if ((await fs.readFile(entryPath, "utf8")).includes(text)) return true;
+		}
+	}
+	return false;
+}
 async function addPackageDependency(opts) {
-	const { dependencies = [], devDependencies = [], customDependencies = {}, customDevDependencies = {}, scripts = {}, scriptMode = "upsert", projectDir } = opts;
-	const addedScripts = [];
-	const existingScripts = [];
+	const { dependencies = [], devDependencies = [], customDependencies = {}, scripts = {}, scriptMode, projectDir } = opts;
 	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);
@@ -413,48 +539,43 @@ async function addPackageDependency(opts) {
 		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);
+			if (typeof pkgJson.scripts[scriptName] !== "string" || pkgJson.scripts[scriptName].trim().length === 0) pkgJson.scripts[scriptName] = command;
 			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, packageManager, projectDir = process.cwd()) {
-	const dependencies = ["@prisma/client", "dotenv"];
+	const dependencies = ["@prisma/client"];
 	const devDependencies = ["prisma"];
-	const { adapterPackage } = getDbPackages(provider);
-	dependencies.push(adapterPackage);
+	dependencies.push(getDbPackages(provider));
+	if (requiresDotenvConfigImport(packageManager) || await projectContainsText(projectDir, "dotenv/config")) dependencies.push("dotenv");
 	if (provider === "sqlite" && packageManager === "deno") devDependencies.push("node-gyp");
-	const prismaScriptMap = getPrismaScriptMap(packageManager);
-	const scriptWriteResult = await addPackageDependency({
+	await addPackageDependency({
 		dependencies,
 		devDependencies,
-		scripts: prismaScriptMap,
+		scripts: getPrismaScriptMap(packageManager),
 		scriptMode: "if-missing",
 		projectDir
 	});
-	return {
-		dependencies,
-		devDependencies,
-		scripts: Object.keys(prismaScriptMap),
-		addedScripts: scriptWriteResult.addedScripts,
-		existingScripts: scriptWriteResult.existingScripts
-	};
+}
+async function writeCreateTemplateDependencies(opts) {
+	const { template, packageManager, projectDir = process.cwd() } = opts;
+	const targets = getCreateTemplateDependencies(template, packageManager);
+	for (const dependencyTarget of targets) {
+		const targetDirectory = path.join(projectDir, path.dirname(dependencyTarget.packageJsonPath));
+		await addPackageDependency({
+			dependencies: dependencyTarget.dependencies,
+			devDependencies: dependencyTarget.devDependencies,
+			customDependencies: dependencyTarget.customDependencies,
+			projectDir: targetDirectory
+		});
+	}
 }
 async function installProjectDependencies(packageManager, projectDir = process.cwd(), options = {}) {
 	const verbose = options.verbose === true;
@@ -716,36 +837,20 @@ async function ensureEnvVarInEnv(projectDir, envVarName, envVarValue, opts) {
 	if (!await fs.pathExists(envPath)) {
 		const content = opts.comment ? `# ${opts.comment}\n${envLine}\n` : `${envLine}\n`;
 		await fs.writeFile(envPath, content, "utf8");
-		return {
-			envPath,
-			status: "created"
-		};
+		return;
 	}
 	const existingContent = await fs.readFile(envPath, "utf8");
 	if (hasEnvVar(existingContent, envVarName)) {
-		if (opts.mode === "keep-existing") return {
-			envPath,
-			status: "existing"
-		};
+		if (opts.mode === "keep-existing") return;
 		const escapedName = escapeRegExp(envVarName);
 		const lineRegex = new RegExp(`(^|\\n)\\s*${escapedName}\\s*=.*(?=\\n|$)`, "gm");
 		const updatedContent = existingContent.replace(lineRegex, `$1${envLine}`);
-		if (updatedContent === existingContent) return {
-			envPath,
-			status: "existing"
-		};
+		if (updatedContent === existingContent) return;
 		await fs.writeFile(envPath, updatedContent, "utf8");
-		return {
-			envPath,
-			status: "updated"
-		};
+		return;
 	}
 	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");
@@ -770,22 +875,12 @@ 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"
-		};
+		return;
 	}
 	const existingContent = await fs.readFile(gitignorePath, "utf8");
-	if (hasGitignoreEntry(existingContent, entry)) return {
-		gitignorePath,
-		status: "existing"
-	};
+	if (hasGitignoreEntry(existingContent, entry)) return;
 	const separator = existingContent.endsWith("\n") ? "" : "\n";
 	await fs.appendFile(gitignorePath, `${separator}${entry}\n`, "utf8");
-	return {
-		gitignorePath,
-		status: "appended"
-	};
 }
 async function ensureRequiredPrismaFiles(projectDir) {
 	const missingFiles = [];
@@ -805,34 +900,20 @@ async function ensureRequiredPrismaFiles(projectDir) {
 async function finalizePrismaFiles(options) {
 	const projectDir = options.projectDir ?? process.cwd();
 	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
-	const schemaPath = path.join(prismaProjectDir, "prisma/schema.prisma");
-	const configPath = path.join(prismaProjectDir, "prisma.config.ts");
 	await ensureRequiredPrismaFiles(projectDir);
-	const singletonPath = await fs.pathExists(path.join(prismaProjectDir, "src/lib/prisma.ts")) ? path.join(prismaProjectDir, "src/lib/prisma.ts") : await fs.pathExists(path.join(prismaProjectDir, "src/lib/prisma.server.ts")) ? path.join(prismaProjectDir, "src/lib/prisma.server.ts") : await fs.pathExists(path.join(prismaProjectDir, "src/lib/server/prisma.ts")) ? path.join(prismaProjectDir, "src/lib/server/prisma.ts") : await fs.pathExists(path.join(prismaProjectDir, "server/utils/prisma.ts")) ? path.join(prismaProjectDir, "server/utils/prisma.ts") : path.join(prismaProjectDir, "src/client.ts");
 	const generatedDir = await fs.pathExists(path.join(prismaProjectDir, "server/utils/prisma.ts")) ? "server/generated" : "src/generated";
-	const envResult = await ensureEnvVarInEnv(prismaProjectDir, "DATABASE_URL", options.databaseUrl ?? getDefaultDatabaseUrl(options.provider), {
+	await ensureEnvVarInEnv(prismaProjectDir, "DATABASE_URL", options.databaseUrl ?? getDefaultDatabaseUrl(options.provider), {
 		mode: options.databaseUrl ? "upsert" : "keep-existing",
 		comment: "Added by create-prisma"
 	});
-	let claimEnvStatus;
 	if (options.claimUrl) {
-		claimEnvStatus = (await ensureEnvVarInEnv(prismaProjectDir, "CLAIM_URL", options.claimUrl, {
+		await ensureEnvVarInEnv(prismaProjectDir, "CLAIM_URL", options.claimUrl, {
 			mode: "upsert",
 			comment: PRISMA_POSTGRES_TEMPORARY_NOTICE
-		})).status;
+		});
 		await ensureEnvComment(prismaProjectDir, PRISMA_POSTGRES_TEMPORARY_NOTICE);
 	}
-	const gitignoreResult = await ensureGitignoreEntry(prismaProjectDir, generatedDir);
-	return {
-		schemaPath,
-		configPath,
-		singletonPath,
-		envPath: envResult.envPath,
-		envStatus: envResult.status,
-		gitignorePath: gitignoreResult.gitignorePath,
-		gitignoreStatus: gitignoreResult.status,
-		claimEnvStatus
-	};
+	await ensureGitignoreEntry(prismaProjectDir, generatedDir);
 }
 async function provisionPrismaPostgresIfNeeded(context, projectDir) {
 	if (!context.shouldUsePrismaPostgres) return { databaseUrl: context.databaseUrl };
@@ -858,10 +939,11 @@ async function provisionPrismaPostgresIfNeeded(context, projectDir) {
 async function writeDependenciesForContext(context, projectDir) {
 	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
 	try {
-		return await writePrismaDependencies(context.databaseProvider, context.packageManager, prismaProjectDir);
+		await writePrismaDependencies(context.databaseProvider, context.packageManager, prismaProjectDir);
+		return true;
 	} catch (error) {
 		cancel(getCommandErrorMessage(error));
-		return;
+		return false;
 	}
 }
 async function installDependenciesForContext(context, projectDir) {
@@ -894,18 +976,18 @@ async function finalizePrismaFilesForContext(context, projectDir, provisionResul
 	const initSpinner = spinner();
 	initSpinner.start("Preparing Prisma files...");
 	try {
-		const finalizeResult = await finalizePrismaFiles({
+		await finalizePrismaFiles({
 			provider: context.databaseProvider,
 			databaseUrl: provisionResult.databaseUrl,
 			claimUrl: provisionResult.claimUrl,
 			projectDir
 		});
 		initSpinner.stop("Prisma files ready.");
-		return finalizeResult;
+		return true;
 	} catch (error) {
 		initSpinner.stop("Could not prepare Prisma files.");
 		cancel(getCommandErrorMessage(error));
-		return;
+		return false;
 	}
 }
 async function generatePrismaClientForContext(context, projectDir) {
@@ -952,10 +1034,10 @@ function buildNextStepsForContext(opts) {
 async function executePrismaSetupContext(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 finalizePrismaFilesForContext(context, projectDir, provisionResult)) return;
+	if (!provisionResult) return false;
+	if (!await writeDependenciesForContext(context, projectDir)) return false;
+	if (!await installDependenciesForContext(context, projectDir)) return false;
+	if (!await finalizePrismaFilesForContext(context, projectDir, provisionResult)) return false;
 	const generateResult = await generatePrismaClientForContext(context, projectDir);
 	const warningLines = buildWarningLines(provisionResult.warning, generateResult.warning);
 	const nextSteps = buildNextStepsForContext({
@@ -967,7 +1049,7 @@ async function executePrismaSetupContext(context, options = {}) {
 
 Next steps:
 ${nextSteps.join("\n")}`);
-	return { packageManager: context.packageManager };
+	return true;
 }
 
 //#endregion
@@ -1500,21 +1582,12 @@ async function executeCreateAddonSetupContext(params) {
 
 //#endregion
 //#region src/telemetry/client.ts
-const TELEMETRY_API_KEY = "phc_cmc85avbWyuJ2JyKdGPdv7dxXli8xLdWDBPbvIXWJfs";
+const TELEMETRY_API_KEY = "";
 const TELEMETRY_HOST = "https://us.i.posthog.com";
 const TELEMETRY_CONFIG_FILE = "telemetry.json";
 const UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-function isTruthyEnvValue(value) {
-	return [
-		"1",
-		"true",
-		"yes",
-		"on"
-	].includes(String(value ?? "").trim().toLowerCase());
-}
 function shouldDisableTelemetry() {
-	if (isTruthyEnvValue(process.env.CI) || isTruthyEnvValue(process.env.GITHUB_ACTIONS)) return true;
-	return process.env.CREATE_PRISMA_DISABLE_TELEMETRY !== void 0 || process.env.CREATE_PRISMA_TELEMETRY_DISABLED !== void 0 || process.env.DO_NOT_TRACK !== void 0;
+	return true;
 }
 function getTelemetryConfigDir() {
 	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", "create-prisma");
@@ -1536,7 +1609,7 @@ async function getAnonymousId() {
 }
 function getCommonProperties() {
 	return {
-		"cli-version": "0.3.2",
+		"cli-version": "0.4.1-pr.33.62.1",
 		"node-version": process.version,
 		platform: process.platform,
 		arch: process.arch
@@ -1596,7 +1669,7 @@ function getBaseCreateProperties(input, context) {
 		template: context?.template ?? input.template ?? null,
 		"database-provider": context?.prismaSetupContext.databaseProvider ?? input.provider ?? null,
 		"package-manager": context?.prismaSetupContext.packageManager ?? input.packageManager ?? null,
-		"schema-preset": context?.schemaPreset ?? input.schemaPreset ?? null,
+		"schema-preset": context?.prismaSetupContext.schemaPreset ?? input.schemaPreset ?? null,
 		"should-install": context?.prismaSetupContext.shouldInstall ?? input.install ?? null,
 		"should-generate": context?.prismaSetupContext.shouldGenerate ?? input.generate ?? null,
 		"uses-prisma-postgres": context?.prismaSetupContext.shouldUsePrismaPostgres ?? input.prismaPostgres ?? null,
@@ -1658,7 +1731,7 @@ function formatPathForDisplay(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 (trimmed === "..") return "Project name cannot be '..'.";
 	if (path.isAbsolute(trimmed)) return "Use a relative project name instead of an absolute path.";
 }
 async function promptForProjectName() {
@@ -1684,6 +1757,16 @@ async function promptForCreateTemplate() {
 				label: "Hono",
 				hint: "TypeScript API starter"
 			},
+			{
+				value: "elysia",
+				label: "Elysia",
+				hint: "TypeScript API starter with Elysia's Node adapter"
+			},
+			{
+				value: "nest",
+				label: "NestJS",
+				hint: "Official Nest-style API starter with a Prisma service"
+			},
 			{
 				value: "next",
 				label: "Next.js",
@@ -1782,8 +1865,14 @@ async function runCreateCommand(rawInput = {}) {
 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 projectNameInput = input.name ?? (useDefaults ? DEFAULT_PROJECT_NAME : await promptForProjectName());
+	if (projectNameInput === void 0) return;
+	const projectName = String(projectNameInput).trim();
+	const projectNameValidationError = validateProjectName(projectName);
+	if (projectNameValidationError) {
+		cancel(projectNameValidationError);
+		return;
+	}
 	const template = input.template ?? (useDefaults ? DEFAULT_TEMPLATE : await promptForCreateTemplate());
 	if (!template) return;
 	const targetDirectory = path.resolve(process.cwd(), projectName);
@@ -1812,7 +1901,6 @@ async function collectCreateContext(input) {
 		targetPathState,
 		force,
 		template,
-		schemaPreset: prismaSetupContext.schemaPreset,
 		projectPackageName: toPackageName(path.basename(targetDirectory)),
 		prismaSetupContext,
 		addonSetupContext: addonSetupContext ?? void 0
@@ -1826,7 +1914,7 @@ async function executeCreateContext(context) {
 			projectDir: context.targetDirectory,
 			projectName: context.projectPackageName,
 			template: context.template,
-			schemaPreset: context.schemaPreset,
+			schemaPreset: context.prismaSetupContext.schemaPreset,
 			provider: context.prismaSetupContext.databaseProvider,
 			packageManager: context.prismaSetupContext.packageManager
 		});
@@ -1839,8 +1927,21 @@ async function executeCreateContext(context) {
 			error
 		};
 	}
+	try {
+		await writeCreateTemplateDependencies({
+			template: context.template,
+			packageManager: context.prismaSetupContext.packageManager,
+			projectDir: context.targetDirectory
+		});
+	} catch (error) {
+		return {
+			ok: false,
+			stage: "scaffold_template",
+			error
+		};
+	}
 	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)}`;
+	const nextSteps = formatPathForDisplay(context.targetDirectory) === "." ? [] : [`- cd ${formatPathForDisplay(context.targetDirectory)}`];
 	if (context.addonSetupContext) try {
 		await executeCreateAddonSetupContext({
 			context: context.addonSetupContext,
@@ -1857,7 +1958,7 @@ async function executeCreateContext(context) {
 	}
 	try {
 		if (!await executePrismaSetupContext(context.prismaSetupContext, {
-			prependNextSteps: [cdStep],
+			prependNextSteps: nextSteps,
 			projectDir: context.targetDirectory,
 			includeDevNextStep: true
 		})) return {

package/dist/index.d.mts

@@ -197,6 +197,8 @@ declare const SchemaPresetSchema: z.ZodEnum<{
 }>;
 declare const CreateTemplateSchema: z.ZodEnum<{
   hono: "hono";
+  elysia: "elysia";
+  nest: "nest";
   next: "next";
   svelte: "svelte";
   astro: "astro";
@@ -233,6 +235,8 @@ declare const CreateCommandInputSchema: z.ZodObject<{
   name: z.ZodOptional<z.ZodString>;
   template: z.ZodOptional<z.ZodEnum<{
     hono: "hono";
+    elysia: "elysia";
+    nest: "nest";
     next: "next";
     svelte: "svelte";
     astro: "astro";
@@ -277,6 +281,8 @@ declare const router: {
     name: zod.ZodOptional<zod.ZodString>;
     template: zod.ZodOptional<zod.ZodEnum<{
       hono: "hono";
+      elysia: "elysia";
+      nest: "nest";
       next: "next";
       svelte: "svelte";
       astro: "astro";

package/dist/index.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { a as DatabaseUrlSchema, i as DatabaseProviderSchema, n as CreateCommandInputSchema, o as PackageManagerSchema, r as CreateTemplateSchema, s as SchemaPresetSchema, t as runCreateCommand } from "./create-DOr8R2_6.mjs";
+import { a as DatabaseUrlSchema, i as DatabaseProviderSchema, n as CreateCommandInputSchema, o as PackageManagerSchema, r as CreateTemplateSchema, s as SchemaPresetSchema, t as runCreateCommand } from "./create-CDlZ32XO.mjs";
 import { os } from "@orpc/server";
 import { createCli } from "trpc-cli";
 
 //#region src/index.ts
-const CLI_VERSION = "0.3.2";
+const CLI_VERSION = "0.4.1-pr.33.62.1";
 const router = os.router({ create: os.meta({
 	description: "Create a new project with Prisma setup",
 	default: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma",
-  "version": "0.3.2",
+  "version": "0.4.1-pr.33.62.1",
   "private": false,
   "description": "Create Prisma 7 projects with first-party templates and great DX.",
   "homepage": "https://github.com/prisma/create-prisma",