create-prisma 0.4.2 → 0.5.0-pr.42.125.1

package/README.md

@@ -13,6 +13,7 @@ Scaffold a new app with Prisma already wired up.
 - adds `db:generate`, `db:migrate`, and `db:seed` scripts
 - creates or updates `.env` with `DATABASE_URL`
 - can install dependencies and run `prisma generate` for you
+- can deploy the finished app to Prisma Compute and return a live URL
 
 ## Quick Start
 
@@ -76,6 +77,14 @@ Use Prisma Postgres auto-provisioning:
 create-prisma --name my-app --template nest --provider postgresql --prisma-postgres
 ```
 
+Deploy a supported app to Prisma Compute:
+
+```bash
+create-prisma --name my-api --template hono --provider postgresql --deploy
+```
+
+With PostgreSQL, no `--database-url`, and no `--no-prisma-postgres`, the Compute flow creates a Prisma Compute project, creates a `main` Prisma Postgres database on the `main` branch, writes `DATABASE_URL` to `.env`, and deploys the app with environment variables loaded from `.env`.
+
 ## Supported Templates
 
 - `hono`
@@ -88,6 +97,13 @@ create-prisma --name my-app --template nest --provider postgresql --prisma-postg
 - `tanstack-start`
 - `turborepo`
 
+Prisma Compute deployment is currently supported for:
+
+- `hono`
+- `elysia`
+- `next`
+- `tanstack-start`
+
 ## Supported Databases
 
 - `postgresql`
@@ -111,6 +127,7 @@ create-prisma --name my-app --template nest --provider postgresql --prisma-postg
 - `--provider` choose the database provider
 - `--package-manager` choose the package manager/runtime
 - `--schema-preset empty|basic`
+- `--deploy` deploy supported templates to Prisma Compute
 - `--yes` accept defaults and skip prompts
 - `--no-install` scaffold only
 - `--no-generate` skip `prisma generate`
@@ -128,6 +145,23 @@ create-prisma --name my-app --template nest --provider postgresql --prisma-postg
 - Prisma IDE extension install
 
 These can be selected interactively or enabled with flags.
+When Prisma Compute deploy is selected, the skills add-on recommends the `prisma-compute` skill too.
+
+## Deploy to Prisma Compute
+
+After scaffolding, `create-prisma` can deploy your app to [Prisma Compute](https://www.prisma.io/docs/compute), the serverless hosting for TypeScript apps that runs next to your Prisma Postgres database. It is offered for the templates the Prisma CLI can deploy today: `hono`, `elysia`, `next`, and `tanstack-start`.
+
+Accept the prompt ("Deploy to Prisma Compute now?") when it appears, or pass the flag:
+
+```bash
+create-prisma --name my-api --template hono --provider postgresql --deploy
+```
+
+The deploy step signs you in with the Prisma CLI if you are not signed in yet. With PostgreSQL, no `--database-url`, and no `--no-prisma-postgres`, setup creates a Prisma Compute project, creates a `main` Prisma Postgres database on the `main` branch, writes `DATABASE_URL` to `.env`, runs the requested Prisma setup, then deploys the app with environment variables loaded from `.env`.
+
+A `compute:deploy` script is added to the generated project so you can redeploy app changes later. That script only runs `@prisma/cli@latest app deploy` with `.env`; it does not create a new project, create a new database, run migrations, or seed data.
+
+The deploy prompt is skipped in `--yes` runs unless you pass `--deploy`. Browser sign-in may still need a person at the keyboard if no Prisma CLI session exists.
 
 ## Local Development
 

package/dist/cli.mjs

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

package/dist/{create-Cy_IS-sg.mjs → create-ClKlnRHX.mjs}

@@ -107,6 +107,7 @@ const extensionTargets = [
 const prismaSkillNames = [
 	"prisma-cli",
 	"prisma-client-api",
+	"prisma-compute",
 	"prisma-database-setup",
 	"prisma-upgrade-v7",
 	"prisma-postgres"
@@ -127,7 +128,7 @@ const CommonCommandOptionsSchema = z.object({
 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"),
+	prismaPostgres: z.boolean().optional().describe("Use Prisma Postgres 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"),
@@ -141,8 +142,18 @@ const CreateScaffoldOptionsSchema = z.object({
 	skills: z.boolean().optional().describe("Enable skills addon"),
 	mcp: z.boolean().optional().describe("Enable MCP addon"),
 	extension: z.boolean().optional().describe("Enable extension addon"),
+	deploy: z.boolean().optional().describe("Deploy the scaffolded project to Prisma Compute"),
 	force: z.boolean().optional().describe("Allow scaffolding into a non-empty target directory")
 });
+const COMPUTE_DEPLOYABLE_TEMPLATES = new Set([
+	"hono",
+	"elysia",
+	"next",
+	"tanstack-start"
+]);
+function isComputeDeployableTemplate(template) {
+	return COMPUTE_DEPLOYABLE_TEMPLATES.has(template);
+}
 const CreateCommandInputSchema = PrismaSetupCommandInputSchema.extend(CreateScaffoldOptionsSchema.shape);
 
 //#endregion
@@ -340,11 +351,6 @@ function getPackageExecutionCommand(packageManager, commandArgs) {
 	return [execution.command, ...execution.args].join(" ");
 }
 function getPrismaCliArgs(packageManager, prismaArgs) {
-	if (packageManager === "bun") return getPackageExecutionArgs(packageManager, [
-		"--bun",
-		"prisma",
-		...prismaArgs
-	]);
 	if (packageManager === "deno") return {
 		command: "deno",
 		args: [
@@ -357,7 +363,7 @@ function getPrismaCliArgs(packageManager, prismaArgs) {
 	};
 	return getPackageExecutionArgs(packageManager, ["prisma", ...prismaArgs]);
 }
-function getPrismaCliCommand(packageManager, prismaArgs) {
+function getPrismaCliCommand$1(packageManager, prismaArgs) {
 	const execution = getPrismaCliArgs(packageManager, prismaArgs);
 	return [execution.command, ...execution.args].join(" ");
 }
@@ -460,12 +466,13 @@ async function renderTemplateTree(opts) {
 function getCreateTemplateDir(template) {
 	return resolveTemplatesDir(`templates/create/${template}`);
 }
-function createTemplateContext(projectName, provider, schemaPreset, packageManager) {
+function createTemplateContext(projectName, provider, schemaPreset, packageManager, compute) {
 	return {
 		projectName,
 		provider,
 		schemaPreset,
-		packageManager
+		packageManager,
+		compute
 	};
 }
 async function scaffoldCreateTemplate(opts) {
@@ -473,7 +480,7 @@ async function scaffoldCreateTemplate(opts) {
 	await renderTemplateTree({
 		templateRoot: getCreateTemplateDir(template),
 		outputDir: projectDir,
-		context: createTemplateContext(projectName, provider, schemaPreset, packageManager)
+		context: createTemplateContext(projectName, provider, schemaPreset, packageManager, opts.compute === true)
 	});
 }
 
@@ -813,7 +820,7 @@ function getCommandErrorMessage(error) {
 	}
 	return error instanceof Error ? error.message : String(error);
 }
-async function collectPrismaSetupContext(input, options = {}) {
+async function collectPrismaSetupInitialContext(input, options = {}) {
 	const projectDir = path.resolve(options.projectDir ?? process.cwd());
 	const useDefaults = input.yes === true;
 	const verbose = input.verbose === true;
@@ -822,19 +829,11 @@ async function collectPrismaSetupContext(input, options = {}) {
 	if (!databaseProvider) return;
 	const schemaPreset = input.schemaPreset ?? options.defaultSchemaPreset ?? 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;
-	const shouldMigrateAndSeed = !(shouldInstall && shouldGenerate) ? false : input.migrateAndSeed ?? (useDefaults ? DEFAULT_MIGRATE_AND_SEED : await promptForMigrateAndSeed());
-	if (shouldMigrateAndSeed === void 0) return;
 	return {
 		projectDir,
 		verbose,
@@ -842,9 +841,24 @@ async function collectPrismaSetupContext(input, options = {}) {
 		databaseProvider,
 		schemaPreset,
 		databaseUrl,
-		shouldUsePrismaPostgres,
 		packageManager,
-		shouldInstall,
+		shouldInstall
+	};
+}
+async function completePrismaSetupContext(input, context, options = {}) {
+	const useDefaults = input.yes === true;
+	let shouldUsePrismaPostgres = false;
+	const shouldUseComputePostgres = context.databaseProvider === "postgresql" && !context.databaseUrl && options.useComputePostgres === true;
+	if (context.databaseProvider === "postgresql" && !context.databaseUrl && !shouldUseComputePostgres) {
+		const prismaPostgresChoice = input.prismaPostgres ?? (useDefaults ? DEFAULT_PRISMA_POSTGRES : await promptForPrismaPostgres());
+		if (prismaPostgresChoice === void 0) return;
+		shouldUsePrismaPostgres = prismaPostgresChoice;
+	}
+	const shouldMigrateAndSeed = !(context.shouldInstall && context.shouldGenerate && !(shouldUseComputePostgres && options.skipMigrateAndSeedPrompt)) ? false : input.migrateAndSeed ?? (useDefaults ? DEFAULT_MIGRATE_AND_SEED : await promptForMigrateAndSeed());
+	if (shouldMigrateAndSeed === void 0) return;
+	return {
+		...context,
+		shouldUsePrismaPostgres,
 		shouldMigrateAndSeed
 	};
 }
@@ -1038,7 +1052,7 @@ async function finalizePrismaFilesForContext(context, projectDir, provisionResul
 async function generatePrismaClientForContext(context, projectDir) {
 	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
 	if (!context.shouldGenerate) return { didGenerateClient: false };
-	const generateCommand = getPrismaCliCommand(context.packageManager, ["generate"]);
+	const generateCommand = getPrismaCliCommand$1(context.packageManager, ["generate"]);
 	if (context.verbose) log.step(`Running ${generateCommand}`);
 	const generateSpinner = context.verbose ? void 0 : spinner();
 	generateSpinner?.start("Generating Prisma Client...");
@@ -1072,33 +1086,37 @@ function buildNextStepsForContext(opts) {
 	const nextSteps = [...options.prependNextSteps ?? []];
 	if (!context.shouldInstall) nextSteps.push(`- ${getInstallCommand(context.packageManager)}`);
 	if (!didGenerateClient || !context.shouldGenerate) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:generate")}`);
-	if (!didMigrate) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:migrate")}`);
-	if (!didSeed) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:seed")}`);
+	if (options.includeMigrationAndSeedNextSteps !== false && !didMigrate) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:migrate")}`);
+	if (options.includeMigrationAndSeedNextSteps !== false && !didSeed) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:seed")}`);
 	if (options.includeDevNextStep) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "dev")}`);
 	return nextSteps;
 }
 async function executePrismaSetupContext(context, options = {}) {
 	const projectDir = path.resolve(options.projectDir ?? context.projectDir);
 	const provisionResult = await provisionPrismaPostgresIfNeeded(context, projectDir);
-	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;
+	if (!provisionResult) return { ok: false };
+	if (!await writeDependenciesForContext(context, projectDir)) return { ok: false };
+	if (!await installDependenciesForContext(context, projectDir)) return { ok: false };
+	if (!await finalizePrismaFilesForContext(context, projectDir, provisionResult)) return { ok: false };
+	const databaseUrl = provisionResult.databaseUrl ?? context.databaseUrl ?? getDefaultDatabaseUrl(context.databaseProvider);
 	const generateResult = await generatePrismaClientForContext(context, projectDir);
-	const migrateAndSeedResult = await migrateAndSeedIfRequested(context, projectDir, { didGenerateClient: generateResult.didGenerateClient });
-	const warningLines = buildWarningLines(provisionResult.warning, generateResult.warning, migrateAndSeedResult.warning);
-	const nextSteps = buildNextStepsForContext({
-		context,
-		options,
-		didGenerateClient: generateResult.didGenerateClient,
-		didMigrate: migrateAndSeedResult.didMigrate,
-		didSeed: migrateAndSeedResult.didSeed
+	const migrateAndSeedResult = await migrateAndSeedIfRequested(context, projectDir, {
+		databaseUrl,
+		didGenerateClient: generateResult.didGenerateClient
 	});
-	outro(`Setup complete.${warningLines.length > 0 ? `\n\n${warningLines.join("\n")}` : ""}
-
-Next steps:
-${nextSteps.join("\n")}`);
-	return true;
+	const warningLines = buildWarningLines(provisionResult.warning, generateResult.warning, migrateAndSeedResult.warning);
+	return {
+		ok: true,
+		nextSteps: buildNextStepsForContext({
+			context,
+			options,
+			didGenerateClient: generateResult.didGenerateClient,
+			didMigrate: migrateAndSeedResult.didMigrate,
+			didSeed: migrateAndSeedResult.didSeed
+		}),
+		warningSection: warningLines.length > 0 ? `\n\n${warningLines.join("\n")}` : "",
+		databaseUrl: provisionResult.databaseUrl ?? context.databaseUrl
+	};
 }
 async function migrateAndSeedIfRequested(context, projectDir, options) {
 	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
@@ -1111,6 +1129,11 @@ async function migrateAndSeedIfRequested(context, projectDir, options) {
 		didSeed: false,
 		warning: "Skipped migrate + seed because the Prisma Client was not generated."
 	};
+	if (!options.databaseUrl) return {
+		didMigrate: false,
+		didSeed: false,
+		warning: "Skipped migrate + seed because no DATABASE_URL is available."
+	};
 	const migrateInvocation = getPrismaCliArgs(context.packageManager, [
 		"migrate",
 		"dev",
@@ -1130,7 +1153,7 @@ async function migrateAndSeedIfRequested(context, projectDir, options) {
 		migrateSpinner.stop("Initial migration applied.");
 		didMigrate = true;
 	} catch (error) {
-		migrateSpinner.error(`Migration failed${error instanceof Error ? `: ${error.message}` : "."}`);
+		migrateSpinner.stop(`Migration failed${error instanceof Error ? `: ${error.message}` : "."}`);
 		return {
 			didMigrate: false,
 			didSeed: false,
@@ -1148,7 +1171,7 @@ async function migrateAndSeedIfRequested(context, projectDir, options) {
 		seedSpinner.stop("Database seeded.");
 		didSeed = true;
 	} catch (error) {
-		seedSpinner.error(`Seed failed${error instanceof Error ? `: ${error.message}` : "."}`);
+		seedSpinner.stop(`Seed failed${error instanceof Error ? `: ${error.message}` : "."}`);
 		return {
 			didMigrate,
 			didSeed: false,
@@ -1360,8 +1383,9 @@ const SHARED_PRISMA_SKILLS = [
 	"prisma-upgrade-v7"
 ];
 function getAvailablePrismaSkills(provider) {
-	if (provider === "postgresql") return [...SHARED_PRISMA_SKILLS, "prisma-postgres"];
-	return [...SHARED_PRISMA_SKILLS];
+	const skills = [...SHARED_PRISMA_SKILLS, "prisma-compute"];
+	if (provider === "postgresql") return [...skills, "prisma-postgres"];
+	return skills;
 }
 function getSkillOptions(provider) {
 	const available = getAvailablePrismaSkills(provider);
@@ -1376,6 +1400,11 @@ function getSkillOptions(provider) {
 			label: "prisma-client-api",
 			hint: "Prisma Client query patterns"
 		},
+		"prisma-compute": {
+			value: "prisma-compute",
+			label: "prisma-compute",
+			hint: "Prisma Compute deploy and hosting workflows"
+		},
 		"prisma-database-setup": {
 			value: "prisma-database-setup",
 			label: "prisma-database-setup",
@@ -1421,9 +1450,10 @@ const EXTENSION_TARGET_OPTIONS = [
 function uniqueValues(values) {
 	return Array.from(new Set(values));
 }
-function getRecommendedPrismaSkills(provider, shouldUsePrismaPostgres) {
-	const skills = [...getAvailablePrismaSkills(provider)];
-	if (!shouldUsePrismaPostgres) return skills.filter((skill) => skill !== "prisma-postgres");
+function getRecommendedPrismaSkills(provider, shouldUsePrismaPostgres, shouldUseComputeDeploy) {
+	const skills = [...SHARED_PRISMA_SKILLS];
+	if (provider === "postgresql" && shouldUsePrismaPostgres) skills.push("prisma-postgres");
+	if (shouldUseComputeDeploy) skills.push("prisma-compute");
 	return uniqueValues(skills);
 }
 async function promptForAddons() {
@@ -1521,7 +1551,7 @@ async function collectCreateAddonSetupContext(input, options) {
 	if (addons.length === 0) return null;
 	const scope = addons.includes("skills") || addons.includes("mcp") ? options.useDefaults ? DEFAULT_ADDON_SCOPE : await promptForAddonScope() : DEFAULT_ADDON_SCOPE;
 	if (!scope) return;
-	const recommendedSkills = getRecommendedPrismaSkills(options.provider, options.shouldUsePrismaPostgres);
+	const recommendedSkills = getRecommendedPrismaSkills(options.provider, options.shouldUsePrismaPostgres, options.shouldUseComputeDeploy);
 	const skills = !addons.includes("skills") ? [] : options.useDefaults ? recommendedSkills : await promptForPrismaSkills(options.provider, recommendedSkills);
 	if (!skills) return;
 	const skillsAgents = !addons.includes("skills") ? [] : options.useDefaults ? [...DEFAULT_SKILLS_AGENTS] : await promptForSkillsAgents();
@@ -1689,23 +1719,295 @@ async function executeCreateAddonSetupContext(params) {
 	addonSpinner.stop("Add-ons applied.");
 }
 
+//#endregion
+//#region src/tasks/deploy-to-compute.ts
+const PRISMA_CLI_PACKAGE = "@prisma/cli@latest";
+const DEPLOY_OPTIONS_BY_TEMPLATE = {
+	hono: {
+		framework: "hono",
+		httpPort: 8080
+	},
+	elysia: {
+		framework: "bun",
+		httpPort: 8080,
+		requiresExplicitFramework: true
+	},
+	next: { framework: "nextjs" },
+	"tanstack-start": { framework: "tanstack-start" }
+};
+function getPrismaCliCommand(packageManager) {
+	return getPackageExecutionCommand(getPrismaCliExecutionPackageManager(packageManager), [PRISMA_CLI_PACKAGE]);
+}
+function getPrismaCliAppDeployCommand(packageManager) {
+	return getPackageExecutionCommand(getPrismaCliExecutionPackageManager(packageManager), [
+		PRISMA_CLI_PACKAGE,
+		"app",
+		"deploy"
+	]);
+}
+function getComputeDeployScriptMap(context) {
+	const deployArgs = [
+		"--prod",
+		"--yes",
+		"--env",
+		".env",
+		...getComputeDeployRuntimeArgs(context)
+	];
+	const deployCommand = [getPrismaCliAppDeployCommand(context.packageManager), ...deployArgs].join(" ");
+	return { "compute:deploy": deployCommand };
+}
+function getComputeDeployRuntimeArgs(context) {
+	return [...context.requiresExplicitFramework ? ["--framework", context.framework] : [], ...context.httpPort ? ["--http-port", String(context.httpPort)] : []];
+}
+function runPrismaCli(packageManager, args, options = {}) {
+	const execution = getPackageExecutionArgs(getPrismaCliExecutionPackageManager(packageManager), [PRISMA_CLI_PACKAGE, ...args]);
+	return execa(execution.command, execution.args, options);
+}
+function getPrismaCliExecutionPackageManager(packageManager) {
+	return packageManager === "deno" ? "npm" : packageManager;
+}
+async function isAuthenticated(packageManager) {
+	try {
+		await runPrismaCli(packageManager, [
+			"project",
+			"list",
+			"--json"
+		], { stdio: "pipe" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function ensurePrismaCliAvailable(packageManager) {
+	try {
+		await runPrismaCli(packageManager, ["--help"], { stdio: "pipe" });
+		return true;
+	} catch (error) {
+		const command = getPrismaCliCommand(packageManager);
+		if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+			log.warn(`Could not find the selected package manager. Re-run ${command} manually.`);
+			return false;
+		}
+		log.warn(`Could not run ${command}${error instanceof Error ? `: ${redactSecrets(error.message)}` : "."}`);
+		return false;
+	}
+}
+async function collectComputeDeployContext(input, options) {
+	if (!isComputeDeployableTemplate(options.template)) return null;
+	if (input.deploy === false) return null;
+	let wantsDeploy;
+	if (input.deploy === true) wantsDeploy = true;
+	else if (options.useDefaults) return null;
+	else {
+		const confirmed = await confirm({
+			message: "Deploy to Prisma Compute now?",
+			initialValue: false
+		});
+		if (isCancel(confirmed)) {
+			cancel("Operation cancelled.");
+			return;
+		}
+		wantsDeploy = confirmed;
+	}
+	if (!wantsDeploy) return null;
+	if (!await ensurePrismaCliAvailable(options.packageManager)) {
+		if (input.deploy === true) throw createExplicitDeployError("the Prisma CLI is not available");
+		return null;
+	}
+	if (!await isAuthenticated(options.packageManager)) {
+		log.info("Authenticating with Prisma...");
+		try {
+			await runPrismaCli(options.packageManager, ["auth", "login"], { stdio: "inherit" });
+		} catch (error) {
+			log.warn(`Prisma login was not completed${error instanceof Error ? `: ${redactSecrets(error.message)}` : "."}`);
+			if (input.deploy === true) throw createExplicitDeployError("authentication failed", error);
+			return null;
+		}
+	}
+	const deployOptions = DEPLOY_OPTIONS_BY_TEMPLATE[options.template];
+	if (!deployOptions) {
+		if (input.deploy === true) throw createExplicitDeployError(`${options.template} is not supported by prisma app deploy yet`);
+		return null;
+	}
+	return {
+		template: options.template,
+		packageManager: options.packageManager,
+		createProjectName: options.defaultServiceName,
+		framework: deployOptions.framework,
+		httpPort: deployOptions.httpPort,
+		requiresExplicitFramework: deployOptions.requiresExplicitFramework
+	};
+}
+function redactSecrets(message) {
+	return message.replace(/(['"])([A-Z0-9_]*(?:DATABASE_URL|DIRECT_URL|TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY|ACCESS_KEY)[A-Z0-9_]*=)(.*?)\1/g, "$1$2<redacted>$1").replace(/\b([A-Z0-9_]*(?:DATABASE_URL|DIRECT_URL|TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY|ACCESS_KEY)[A-Z0-9_]*=)[^\s]+/g, "$1<redacted>");
+}
+function parseJson(stdout) {
+	if (typeof stdout !== "string" || stdout.trim().length === 0) return null;
+	try {
+		return JSON.parse(stdout);
+	} catch {
+		return null;
+	}
+}
+function getJsonErrorMessage(error, fallback) {
+	return error?.summary ?? error?.message ?? error?.name ?? fallback;
+}
+function getErrorMessage(error) {
+	return redactSecrets(error instanceof Error ? error.message : String(error));
+}
+function createDeployError(message) {
+	return new Error(redactSecrets(message ?? "unknown error"));
+}
+function createExplicitDeployError(reason, error) {
+	const detail = error instanceof Error ? `: ${redactSecrets(error.message)}` : "";
+	return /* @__PURE__ */ new Error(`Deploy requested but ${reason}${detail}`);
+}
+async function runPrismaCliJson(params) {
+	try {
+		const { stdout, exitCode } = await runPrismaCli(params.packageManager, params.args, {
+			cwd: params.cwd,
+			reject: false,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const parsed = parseJson(stdout);
+		if (!parsed) return {
+			ok: false,
+			error: new Error(params.invalidOutputError)
+		};
+		if (exitCode !== 0 || !parsed.ok) return {
+			ok: false,
+			error: createDeployError(parsed.ok ? params.fallbackError : getJsonErrorMessage(parsed.error, params.fallbackError))
+		};
+		return {
+			ok: true,
+			result: parsed.result
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: new Error(getErrorMessage(error))
+		};
+	}
+}
+function toComputeDeployResult(data) {
+	return {
+		appUrl: data.deployment.url,
+		appId: data.app.id,
+		appName: data.app.name,
+		deploymentId: data.deployment.id,
+		projectId: data.project.id,
+		projectName: data.project.name,
+		branchName: data.branch.name,
+		database: data.branchDatabase?.database
+	};
+}
+async function executeComputeDatabaseSetup(params) {
+	const projectSpinner = spinner();
+	projectSpinner.start("Creating Prisma Compute project...");
+	const projectResult = await runPrismaCliJson({
+		packageManager: params.context.packageManager,
+		args: [
+			"project",
+			"create",
+			params.context.createProjectName,
+			"--json"
+		],
+		cwd: params.projectDir,
+		fallbackError: "Prisma project create failed.",
+		invalidOutputError: "Invalid prisma project create output"
+	});
+	if (!projectResult.ok) {
+		projectSpinner.error(`Project creation failed: ${projectResult.error.message}`);
+		return {
+			ok: false,
+			cancelled: false,
+			error: projectResult.error
+		};
+	}
+	projectSpinner.stop("Prisma Compute project created.");
+	const databaseSpinner = spinner();
+	databaseSpinner.start("Creating Prisma Postgres database...");
+	const databaseResult = await runPrismaCliJson({
+		packageManager: params.context.packageManager,
+		args: [
+			"database",
+			"create",
+			"main",
+			"--branch",
+			"main",
+			"--json"
+		],
+		cwd: params.projectDir,
+		fallbackError: "Prisma database create failed.",
+		invalidOutputError: "Invalid prisma database create output"
+	});
+	if (!databaseResult.ok) {
+		databaseSpinner.error(`Database creation failed: ${databaseResult.error.message}`);
+		return {
+			ok: false,
+			cancelled: false,
+			error: databaseResult.error
+		};
+	}
+	databaseSpinner.stop("Prisma Postgres database created.");
+	return {
+		ok: true,
+		result: {
+			databaseUrl: databaseResult.result.connectionString,
+			projectId: databaseResult.result.projectId,
+			projectName: databaseResult.result.projectName,
+			database: databaseResult.result.database
+		}
+	};
+}
+async function executeComputeDeployContext(params) {
+	const deploySpinner = spinner();
+	deploySpinner.start("Deploying to Prisma Compute...");
+	const args = [
+		"app",
+		"deploy",
+		"--json",
+		"--yes",
+		"--prod",
+		"--env",
+		".env",
+		...params.createProject === false ? [] : ["--create-project", params.context.createProjectName],
+		...getComputeDeployRuntimeArgs(params.context)
+	];
+	const deployResult = await runPrismaCliJson({
+		packageManager: params.context.packageManager,
+		args,
+		cwd: params.projectDir,
+		fallbackError: "Prisma app deploy failed.",
+		invalidOutputError: "Invalid prisma app deploy output"
+	});
+	if (!deployResult.ok) {
+		deploySpinner.error(`Deploy failed: ${deployResult.error.message}`);
+		return {
+			ok: false,
+			cancelled: false,
+			error: deployResult.error
+		};
+	}
+	deploySpinner.stop("Deployed to Prisma Compute.");
+	return {
+		ok: true,
+		result: toComputeDeployResult(deployResult.result)
+	};
+}
+
 //#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");
@@ -1727,7 +2029,7 @@ async function getAnonymousId() {
 }
 function getCommonProperties() {
 	return {
-		"cli-version": "0.4.2",
+		"cli-version": "0.5.0-pr.42.125.1",
 		"node-version": process.version,
 		platform: process.platform,
 		arch: process.arch
@@ -2003,15 +2305,27 @@ async function collectCreateContext(input) {
 		cancel(`Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`);
 		return;
 	}
-	const prismaSetupContext = await collectPrismaSetupContext(input, {
+	const prismaSetupInitialContext = await collectPrismaSetupInitialContext(input, {
 		projectDir: targetDirectory,
 		defaultSchemaPreset: DEFAULT_SCHEMA_PRESET
 	});
+	if (!prismaSetupInitialContext) return;
+	const projectPackageName = toPackageName(path.basename(targetDirectory));
+	const computeDeployContext = await collectComputeDeployContext(input, {
+		template,
+		packageManager: prismaSetupInitialContext.packageManager,
+		useDefaults,
+		defaultServiceName: projectPackageName
+	});
+	if (computeDeployContext === void 0) return;
+	const useComputeDatabase = Boolean(computeDeployContext && prismaSetupInitialContext.databaseProvider === "postgresql" && !prismaSetupInitialContext.databaseUrl && input.prismaPostgres !== false);
+	const prismaSetupContext = await completePrismaSetupContext(input, prismaSetupInitialContext, { useComputePostgres: useComputeDatabase });
 	if (!prismaSetupContext) return;
 	const addonSetupContext = await collectCreateAddonSetupContext(input, {
 		useDefaults,
 		provider: prismaSetupContext.databaseProvider,
-		shouldUsePrismaPostgres: prismaSetupContext.shouldUsePrismaPostgres
+		shouldUsePrismaPostgres: prismaSetupContext.shouldUsePrismaPostgres,
+		shouldUseComputeDeploy: Boolean(computeDeployContext)
 	});
 	if (addonSetupContext === void 0) return;
 	return {
@@ -2019,9 +2333,11 @@ async function collectCreateContext(input) {
 		targetPathState,
 		force,
 		template,
-		projectPackageName: toPackageName(path.basename(targetDirectory)),
+		projectPackageName,
 		prismaSetupContext,
-		addonSetupContext: addonSetupContext ?? void 0
+		addonSetupContext: addonSetupContext ?? void 0,
+		computeDeployContext: computeDeployContext ?? void 0,
+		useComputeDatabase
 	};
 }
 async function executeCreateContext(context) {
@@ -2034,7 +2350,8 @@ async function executeCreateContext(context) {
 			template: context.template,
 			schemaPreset: context.prismaSetupContext.schemaPreset,
 			provider: context.prismaSetupContext.databaseProvider,
-			packageManager: context.prismaSetupContext.packageManager
+			packageManager: context.prismaSetupContext.packageManager,
+			compute: Boolean(context.computeDeployContext)
 		});
 		scaffoldSpinner.stop("Project files scaffolded.");
 	} catch (error) {
@@ -2051,6 +2368,11 @@ async function executeCreateContext(context) {
 			packageManager: context.prismaSetupContext.packageManager,
 			projectDir: context.targetDirectory
 		});
+		if (context.computeDeployContext) await addPackageDependency({
+			scripts: getComputeDeployScriptMap(context.computeDeployContext),
+			scriptMode: "if-missing",
+			projectDir: context.targetDirectory
+		});
 	} catch (error) {
 		return {
 			ok: false,
@@ -2074,12 +2396,38 @@ async function executeCreateContext(context) {
 			error
 		};
 	}
+	let computeDatabaseResult;
+	if (context.useComputeDatabase && context.computeDeployContext) try {
+		const result = await executeComputeDatabaseSetup({
+			context: context.computeDeployContext,
+			projectDir: context.targetDirectory
+		});
+		if (!result.ok && !result.cancelled) return {
+			ok: false,
+			stage: "compute_deploy",
+			error: result.error
+		};
+		if (result.ok) computeDatabaseResult = result.result;
+	} catch (error) {
+		return {
+			ok: false,
+			stage: "compute_deploy",
+			error
+		};
+	}
+	const prismaSetupContext = computeDatabaseResult ? {
+		...context.prismaSetupContext,
+		databaseUrl: computeDatabaseResult.databaseUrl,
+		shouldUsePrismaPostgres: false
+	} : context.prismaSetupContext;
+	let prismaResult;
 	try {
-		if (!await executePrismaSetupContext(context.prismaSetupContext, {
+		prismaResult = await executePrismaSetupContext(prismaSetupContext, {
 			prependNextSteps: nextSteps,
 			projectDir: context.targetDirectory,
-			includeDevNextStep: true
-		})) return {
+			includeDevNextStep: !context.useComputeDatabase
+		});
+		if (!prismaResult.ok) return {
 			ok: false,
 			stage: "prisma_setup"
 		};
@@ -2090,6 +2438,37 @@ async function executeCreateContext(context) {
 			error
 		};
 	}
+	let deployResult;
+	if (context.computeDeployContext) try {
+		const result = await executeComputeDeployContext({
+			context: context.computeDeployContext,
+			projectDir: context.targetDirectory,
+			createProject: !computeDatabaseResult
+		});
+		if (!result.ok && !result.cancelled) return {
+			ok: false,
+			stage: "compute_deploy",
+			error: result.error
+		};
+		if (result.ok) {
+			deployResult = result.result;
+			prismaResult.nextSteps.push(`- ${getRunScriptCommand(context.prismaSetupContext.packageManager, "compute:deploy")}`);
+		}
+	} catch (error) {
+		return {
+			ok: false,
+			stage: "compute_deploy",
+			error
+		};
+	}
+	const summaryLines = [];
+	summaryLines.push(`Setup complete.${prismaResult.warningSection}`);
+	if (deployResult) {
+		const database = computeDatabaseResult?.database ?? deployResult.database;
+		summaryLines.push("", "Deployed to Prisma Compute:", ...deployResult.appUrl ? [`- App URL: ${deployResult.appUrl}`] : [], `- App: ${deployResult.appName} (${deployResult.appId})`, `- Deployment: ${deployResult.deploymentId}`, ...database ? [`- Database: ${database.name} (${database.id})`] : []);
+	}
+	summaryLines.push("", "Next steps:", prismaResult.nextSteps.join("\n"));
+	outro(summaryLines.join("\n"));
 	return { ok: true };
 }
 

package/dist/index.d.mts

@@ -248,6 +248,7 @@ declare const CreateCommandInputSchema: z.ZodObject<{
   skills: z.ZodOptional<z.ZodBoolean>;
   mcp: z.ZodOptional<z.ZodBoolean>;
   extension: z.ZodOptional<z.ZodBoolean>;
+  deploy: z.ZodOptional<z.ZodBoolean>;
   force: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type CreateCommandInput = z.infer<typeof CreateCommandInputSchema>;
@@ -295,6 +296,7 @@ declare const router: {
     skills: zod.ZodOptional<zod.ZodBoolean>;
     mcp: zod.ZodOptional<zod.ZodBoolean>;
     extension: zod.ZodOptional<zod.ZodBoolean>;
+    deploy: zod.ZodOptional<zod.ZodBoolean>;
     force: zod.ZodOptional<zod.ZodBoolean>;
   }, zod_v4_core0.$strip>>, Schema<void, void>, MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
 };

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-Cy_IS-sg.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-ClKlnRHX.mjs";
 import { os } from "@orpc/server";
 import { createCli } from "trpc-cli";
 
 //#region src/index.ts
-const CLI_VERSION = "0.4.2";
+const CLI_VERSION = "0.5.0-pr.42.125.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.4.2",
+  "version": "0.5.0-pr.42.125.1",
   "private": false,
   "description": "Create Prisma 7 projects with first-party templates and great DX.",
   "homepage": "https://github.com/prisma/create-prisma",

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

@@ -8,6 +8,9 @@ Generated by `create-prisma` with the Astro template.
 - `{{runScriptCommand packageManager "build"}}` - build for production
 - `{{runScriptCommand packageManager "preview"}}` - preview the production build
 - `{{runScriptCommand packageManager "astro"}}` - run Astro CLI commands
+{{#if compute}}
+- `{{runScriptCommand packageManager "compute:deploy"}}` - redeploy to Prisma Compute with environment variables from `.env`
+{{/if}}
 
 ## Prisma
 
@@ -33,3 +36,11 @@ The starter page queries a basic `User` model in `src/pages/index.astro`, and `s
 
 The starter page keeps the official Astro minimal structure and points you to `prisma/schema.prisma` for your first model.
 {{/if}}
+{{#if compute}}
+
+## Prisma Compute
+
+This project includes a Prisma Compute deploy script. Deploys load environment variables from `.env`; if setup created a Prisma Postgres database, its `DATABASE_URL` is already written there.
+
+After local changes, run `{{runScriptCommand packageManager "compute:deploy"}}` to redeploy.
+{{/if}}

package/templates/create/astro/astro.config.mjs.hbs

@@ -0,0 +1,10 @@
+// @ts-check
+import { defineConfig } from "astro/config";
+import node from "@astrojs/node";
+
+// https://astro.build/config
+export default defineConfig({
+  output: "server",
+  adapter: node({ mode: "standalone" }),
+  server: { host: true },
+});

package/templates/create/astro/package.json.hbs

@@ -12,7 +12,8 @@
     "astro": "astro"
   },
   "dependencies": {
-    "astro": "^5.17.1"
+    "astro": "^5.17.1",
+    "@astrojs/node": "^9.5.5"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",

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

@@ -7,6 +7,9 @@ Generated by `create-prisma` with the Elysia template.
 - `{{runScriptCommand packageManager "dev"}}` - start local dev server with hot reload
 - `{{runScriptCommand packageManager "build"}}` - {{#if (eq packageManager "deno")}}type-check the app with Deno{{else}}{{#if (eq packageManager "bun")}}type-check the app for Bun{{else}}typecheck and compile{{/if}}{{/if}}
 - `{{runScriptCommand packageManager "start"}}` - {{#if (eq packageManager "deno")}}run the server directly from `src/index.ts` with Deno{{else}}{{#if (eq packageManager "bun")}}run the server directly from `src/index.ts` with Bun{{else}}run compiled server from `dist/`{{/if}}{{/if}}
+{{#if compute}}
+- `{{runScriptCommand packageManager "compute:deploy"}}` - redeploy to Prisma Compute with environment variables from `.env`
+{{/if}}
 
 ## Prisma
 
@@ -30,3 +33,11 @@ Generated Prisma files are written to `src/generated/prisma`.
 
 The template includes a basic `User` model, a sample `GET /users` endpoint, and seed data in `prisma/seed.ts`.
 {{/if}}
+{{#if compute}}
+
+## Prisma Compute
+
+This project includes a Prisma Compute deploy script. Deploys load environment variables from `.env`; if setup created a Prisma Postgres database, its `DATABASE_URL` is already written there.
+
+After local changes, run `{{runScriptCommand packageManager "compute:deploy"}}` to redeploy.
+{{/if}}

package/templates/create/elysia/package.json.hbs

@@ -5,6 +5,7 @@
   "packageManager": "{{packageManagerManifestValue packageManager}}",
   {{/if}}
   "type": "module",
+  "main": "src/index.ts",
   "scripts": {
     "dev": "{{runtimeScript packageManager "dev" "src/index.ts" "dist/src/index.js" denoFlags="--unstable-net"}}",
     "build": "{{runtimeScript packageManager "build" "src/index.ts" "dist/src/index.js"}}",

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

@@ -13,7 +13,7 @@ import { prisma } from "./lib/prisma{{#if (eq packageManager "deno")}}.ts{{/if}}
 const rawPort = ({{#if (eq packageManager "deno")}}Deno.env.get("PORT"){{else}}process.env.PORT{{/if}} ?? "").trim();
 const parsedPort = rawPort.length > 0 ? Number(rawPort) : Number.NaN;
 const port =
-  Number.isInteger(parsedPort) && parsedPort >= 0 && parsedPort <= 65535 ? parsedPort : 3000;
+  Number.isInteger(parsedPort) && parsedPort >= 0 && parsedPort <= 65535 ? parsedPort : 8080;
 
 const app = new Elysia({{#if (eq packageManager "deno")}}{{else}}{ adapter: node() }{{/if}})
   .get("/", () => {

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

@@ -7,6 +7,9 @@ Generated by `create-prisma` with the Hono template.
 - `{{runScriptCommand packageManager "dev"}}` - start local dev server
 - `{{runScriptCommand packageManager "build"}}` - {{#if (eq packageManager "deno")}}type-check the app with Deno{{else}}{{#if (eq packageManager "bun")}}type-check the app for Bun{{else}}typecheck and compile{{/if}}{{/if}}
 - `{{runScriptCommand packageManager "start"}}` - {{#if (eq packageManager "deno")}}run the server directly from `src/index.ts` with Deno{{else}}{{#if (eq packageManager "bun")}}run the server directly from `src/index.ts` with Bun{{else}}run compiled server from `dist/`{{/if}}{{/if}}
+{{#if compute}}
+- `{{runScriptCommand packageManager "compute:deploy"}}` - redeploy to Prisma Compute with environment variables from `.env`
+{{/if}}
 
 ## Prisma
 
@@ -30,3 +33,11 @@ Generated Prisma files are written to `src/generated/prisma`.
 
 The template includes a basic `User` model, a sample `GET /users` endpoint, and seed data in `prisma/seed.ts`.
 {{/if}}
+{{#if compute}}
+
+## Prisma Compute
+
+This project includes a Prisma Compute deploy script. Deploys load environment variables from `.env`; if setup created a Prisma Postgres database, its `DATABASE_URL` is already written there.
+
+After local changes, run `{{runScriptCommand packageManager "compute:deploy"}}` to redeploy.
+{{/if}}

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

@@ -5,6 +5,7 @@
   "packageManager": "{{packageManagerManifestValue packageManager}}",
   {{/if}}
   "type": "module",
+  "main": "src/index.ts",
   "scripts": {
     "dev": "{{runtimeScript packageManager "dev" "src/index.ts" "dist/src/index.js"}}",
     "build": "{{runtimeScript packageManager "build" "src/index.ts" "dist/src/index.js"}}",

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

@@ -31,7 +31,7 @@ app.get("/users", async (c) => {
 const rawPort = ({{#if (eq packageManager "deno")}}Deno.env.get("PORT"){{else}}process.env.PORT{{/if}} ?? "").trim();
 const parsedPort = rawPort.length > 0 ? Number(rawPort) : Number.NaN;
 const port =
-  Number.isInteger(parsedPort) && parsedPort >= 0 && parsedPort <= 65535 ? parsedPort : 3000;
+  Number.isInteger(parsedPort) && parsedPort >= 0 && parsedPort <= 65535 ? parsedPort : 8080;
 serve({
   fetch: app.fetch,
   port,

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

@@ -7,6 +7,9 @@ Generated by `create-prisma` with the NestJS template.
 - `{{runScriptCommand packageManager "dev"}}` - start the Nest dev server with watch mode
 - `{{runScriptCommand packageManager "build"}}` - {{#if (eq packageManager "deno")}}type-check the app with Deno{{else}}{{#if (eq packageManager "bun")}}type-check the app for Bun{{else}}compile the app into `dist/`{{/if}}{{/if}}
 - `{{runScriptCommand packageManager "start"}}` - {{#if (eq packageManager "deno")}}run the server directly from `src/main.ts` with Deno{{else}}{{#if (eq packageManager "bun")}}run the server directly from `src/main.ts` with Bun{{else}}run the compiled server from `dist/main.js`{{/if}}{{/if}}
+{{#if compute}}
+- `{{runScriptCommand packageManager "compute:deploy"}}` - redeploy to Prisma Compute with environment variables from `.env`
+{{/if}}
 
 ## Prisma
 
@@ -30,3 +33,11 @@ Generated Prisma files are written to `src/generated/prisma`.
 
 The template includes a basic `User` model, a sample `GET /users` endpoint, and seed data in `prisma/seed.ts`.
 {{/if}}
+{{#if compute}}
+
+## Prisma Compute
+
+This project includes a Prisma Compute deploy script. Deploys load environment variables from `.env`; if setup created a Prisma Postgres database, its `DATABASE_URL` is already written there.
+
+After local changes, run `{{runScriptCommand packageManager "compute:deploy"}}` to redeploy.
+{{/if}}

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

@@ -7,6 +7,9 @@ Generated by `create-prisma` with the Next.js template.
 - `{{runScriptCommand packageManager "dev"}}` - start local dev server
 - `{{runScriptCommand packageManager "build"}}` - production build
 - `{{runScriptCommand packageManager "start"}}` - run production server
+{{#if compute}}
+- `{{runScriptCommand packageManager "compute:deploy"}}` - redeploy to Prisma Compute with environment variables from `.env`
+{{/if}}
 
 ## Prisma
 
@@ -28,3 +31,11 @@ Database helper scripts are added to `package.json`:
 
 The starter page in `src/app/page.tsx` reads from a basic `User` model so you can verify queries quickly, and `prisma/seed.ts` inserts starter users.
 {{/if}}
+{{#if compute}}
+
+## Prisma Compute
+
+This project includes a Prisma Compute deploy script. Deploys load environment variables from `.env`; if setup created a Prisma Postgres database, its `DATABASE_URL` is already written there.
+
+After local changes, run `{{runScriptCommand packageManager "compute:deploy"}}` to redeploy.
+{{/if}}

package/templates/create/next/{next.config.ts → next.config.ts.hbs}

@@ -1,7 +1,7 @@
 import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
-  // Add Next config here when needed.
+  output: "standalone",
 };
 
 export default nextConfig;

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

@@ -8,6 +8,9 @@ Generated by `create-prisma` with the Nuxt template.
 - `{{runScriptCommand packageManager "build"}}` - build for production
 - `{{runScriptCommand packageManager "preview"}}` - preview the production build
 - `{{runScriptCommand packageManager "typecheck"}}` - run Nuxt type checks
+{{#if compute}}
+- `{{runScriptCommand packageManager "compute:deploy"}}` - redeploy to Prisma Compute with environment variables from `.env`
+{{/if}}
 
 ## Prisma
 
@@ -30,3 +33,11 @@ Database helper scripts are added to `package.json`:
 
 The starter page in `app/pages/index.vue` fetches seeded users from `server/api/users.get.ts`, and `prisma/seed.ts` inserts starter users.
 {{/if}}
+{{#if compute}}
+
+## Prisma Compute
+
+This project includes a Prisma Compute deploy script. Deploys load environment variables from `.env`; if setup created a Prisma Postgres database, its `DATABASE_URL` is already written there.
+
+After local changes, run `{{runScriptCommand packageManager "compute:deploy"}}` to redeploy.
+{{/if}}

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

@@ -8,6 +8,9 @@ Generated by `create-prisma` with the SvelteKit template.
 - `{{runScriptCommand packageManager "build"}}` - build for production
 - `{{runScriptCommand packageManager "preview"}}` - preview the production build
 - `{{runScriptCommand packageManager "check"}}` - run SvelteKit sync and type checks
+{{#if compute}}
+- `{{runScriptCommand packageManager "compute:deploy"}}` - redeploy to Prisma Compute with environment variables from `.env`
+{{/if}}
 
 ## Prisma
 
@@ -32,3 +35,11 @@ The starter page loads users in `+page.server.ts`, renders them in `+page.svelte
 
 The starter page keeps the official SvelteKit minimal structure and points you to `prisma/schema.prisma` for your first model.
 {{/if}}
+{{#if compute}}
+
+## Prisma Compute
+
+This project includes a Prisma Compute deploy script. Deploys load environment variables from `.env`; if setup created a Prisma Postgres database, its `DATABASE_URL` is already written there.
+
+After local changes, run `{{runScriptCommand packageManager "compute:deploy"}}` to redeploy.
+{{/if}}

package/templates/create/tanstack-start/README.md.hbs

@@ -8,6 +8,9 @@ Generated by `create-prisma` with the TanStack Start template.
 - `{{runScriptCommand packageManager "build"}}` - build for production
 - `{{runScriptCommand packageManager "preview"}}` - preview the production build
 - `{{runScriptCommand packageManager "typecheck"}}` - run TypeScript checks
+{{#if compute}}
+- `{{runScriptCommand packageManager "compute:deploy"}}` - redeploy to Prisma Compute with environment variables from `.env`
+{{/if}}
 
 ## Prisma
 
@@ -29,3 +32,11 @@ Database helper scripts are added to `package.json`:
 
 The home route uses a TanStack Start server function to load users with the Prisma client from `src/lib/prisma.server.ts`, so you can verify a real database query without adding an API route first.
 {{/if}}
+{{#if compute}}
+
+## Prisma Compute
+
+This project includes a Prisma Compute deploy script. Deploys load environment variables from `.env`; if setup created a Prisma Postgres database, its `DATABASE_URL` is already written there.
+
+After local changes, run `{{runScriptCommand packageManager "compute:deploy"}}` to redeploy.
+{{/if}}

package/templates/create/tanstack-start/package.json.hbs

@@ -7,27 +7,27 @@
   {{/if}}
   "type": "module",
   "scripts": {
-    "dev": "vite dev --port 3000",
+    "dev": "vite dev",
     "build": "vite build",
+    "start": "node .output/server/index.mjs",
     "preview": "vite preview",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@tanstack/react-router": "^1.132.0",
-    "@tanstack/react-start": "^1.132.0",
+    "@tanstack/react-router": "^1.167.42",
+    "@tanstack/react-start": "^1.167.42",
+    "nitro": "^3.0.260415-beta",
     "react": "^19.2.0",
     "react-dom": "^19.2.0"
   },
   "devDependencies": {
-    "@tanstack/router-plugin": "^1.132.0",
     "@types/node": "^24.3.0",
     "@types/react": "^19.2.2",
     "@types/react-dom": "^19.2.2",
-    "@vitejs/plugin-react": "^5.1.4",
+    "@vitejs/plugin-react": "^6.0.0",
     "tsx": "^4.7.1",
     "typescript": "^5.9.3",
-    "vite": "^7.3.1",
-    "vite-tsconfig-paths": "^5.1.4"
+    "vite": "^8.0.8"
   }
 }
 

package/templates/create/tanstack-start/vite.config.ts

@@ -1,8 +1,16 @@
 import { defineConfig } from "vite";
 import viteReact from "@vitejs/plugin-react";
 import { tanstackStart } from "@tanstack/react-start/plugin/vite";
-import tsconfigPaths from "vite-tsconfig-paths";
+import { nitro } from "nitro/vite";
 
 export default defineConfig({
-  plugins: [tsconfigPaths({ projects: ["./tsconfig.json"] }), tanstackStart(), viteReact()],
+  resolve: {
+    tsconfigPaths: true,
+  },
+  plugins: [
+    tanstackStart(),
+    nitro(),
+    // react's vite plugin must come after start's vite plugin
+    viteReact(),
+  ],
 });

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

@@ -15,6 +15,9 @@ Generated by `create-prisma` with the Turborepo template.
 - `{{runScriptCommand packageManager "db:generate"}}` - generate Prisma Client in `packages/db`
 - `{{runScriptCommand packageManager "db:migrate"}}` - create/apply migrations in `packages/db`
 - `{{runScriptCommand packageManager "db:seed"}}` - run seed script in `packages/db`
+{{#if compute}}
+- `{{runScriptCommand packageManager "compute:deploy"}}` - redeploy to Prisma Compute with environment variables from `.env`
+{{/if}}
 
 ## Prisma
 
@@ -27,3 +30,11 @@ Prisma is scaffolded inside `packages/db`:
 - `packages/db/src/generated/prisma`
 
 `apps/api/src/index.ts` imports the shared Prisma client from `@repo/db`.
+{{#if compute}}
+
+## Prisma Compute
+
+This project includes a Prisma Compute deploy script. Deploys load environment variables from `.env`; if setup created a Prisma Postgres database, its `DATABASE_URL` is already written there.
+
+After local changes, run `{{runScriptCommand packageManager "compute:deploy"}}` to redeploy.
+{{/if}}

package/templates/create/astro/astro.config.mjs

@@ -1,5 +0,0 @@
-// @ts-check
-import { defineConfig } from "astro/config";
-
-// https://astro.build/config
-export default defineConfig({});