create-prisma 0.7.1-pr.52.167.1 → 0.7.1-pr.52.169.1

package/README.md

@@ -12,7 +12,7 @@ Scaffold a new app with Prisma already wired up.
 - writes a Prisma client singleton in the right place for the selected template
 - adds `db:generate`, `db:migrate`, and `db:seed` scripts
 - creates or updates the template env file with `DATABASE_URL`
-- can install dependencies and run `prisma generate` for you
+- installs dependencies when requested and generates Prisma Client automatically
 - can deploy the finished app and its Prisma Postgres database with Prisma Composer
 
 ## Quick Start
@@ -71,10 +71,10 @@ Create a monorepo with a shared Prisma package:
 create-prisma --name my-monorepo --template turborepo --provider postgresql
 ```
 
-Use Prisma Postgres auto-provisioning:
+Use Prisma Postgres auto-provisioning, which is the PostgreSQL default:
 
 ```bash
-create-prisma --name my-app --template nest --provider postgresql --prisma-postgres
+create-prisma --name my-app --template nest --provider postgresql
 ```
 
 Deploy a supported app with Prisma Composer:
@@ -83,7 +83,7 @@ Deploy a supported app with Prisma Composer:
 create-prisma --name my-api --template hono --provider postgresql --deploy
 ```
 
-With PostgreSQL and no `--database-url`, the deploy flow asks whether to use Prisma Postgres. If accepted, or if `--prisma-postgres` is passed, Composer provisions the database as part of the application graph, injects its connection into the service, and deploys both together. Pass `--no-prisma-postgres` to bind an existing database URL instead.
+With PostgreSQL and no `--database-url`, Prisma Postgres is included automatically. When deploying immediately, Composer provisions the database as part of the application graph, injects its connection into the service, then create-prisma applies the starter migration and seed. Pass `--database-url` to bind an existing database instead.
 
 ## Supported Templates
 
@@ -103,6 +103,7 @@ Prisma Composer files are included by default, and deployment is supported for:
 - `elysia`
 - `nest`
 - `next`
+- `svelte`
 - `astro`
 - `nuxt`
 - `tanstack-start`
@@ -132,12 +133,9 @@ Composer generation and deployment currently apply to the Node-compatible packag
 - `--template` choose the template
 - `--provider` choose the database provider
 - `--package-manager` choose the package manager/runtime
-- `--schema-preset empty|basic`
 - `--deploy` deploy supported templates with Prisma Composer
 - `--yes` accept defaults and skip prompts
 - `--no-install` scaffold only
-- `--no-generate` skip `prisma generate`
-- `--prisma-postgres` provision Prisma Postgres for PostgreSQL
 - `--skills --mcp --extension` enable optional add-ons
 - `--force` allow scaffolding into a non-empty directory
 - `--verbose` print full command output
@@ -163,11 +161,11 @@ Accept the deploy prompt when it appears, or pass the flag:
 create-prisma --name my-api --template hono --provider postgresql --deploy
 ```
 
-Deployment requires `PRISMA_SERVICE_TOKEN` and `PRISMA_WORKSPACE_ID`. With PostgreSQL and no `--database-url`, create-prisma asks whether to use Prisma Postgres. If accepted, Composer provisions the database and passes its connection through `service.load()`. After the first deployment, create-prisma writes a direct connection to the Prisma env file and runs the requested migration and seed. Other database configurations are passed through a secret Composer service input.
+Deployment requires `PRISMA_SERVICE_TOKEN` and `PRISMA_WORKSPACE_ID`. With PostgreSQL and no `--database-url`, Composer provisions Prisma Postgres and passes its connection through `service.load()`. After the first deployment, create-prisma writes a direct connection to the Prisma env file and automatically runs the starter migration and seed. Other database configurations are passed through a secret Composer service input.
 
-A `deploy` script is generated for npm, pnpm, Yarn, and Bun. It applies existing migrations for a Composer-managed database, builds the framework artifact, and runs `prisma-composer deploy module.ts`.
+A `deploy` script is generated for npm, pnpm, Yarn, and Bun. It builds and deploys the Composer application, then resolves the Composer-managed Prisma Postgres connection, applies the starter migration, and seeds the database.
 
-The only Composer-specific prompt asks whether to deploy immediately. It is skipped in `--yes` runs unless you pass `--deploy`; the Composer files are still generated.
+The only Composer-specific prompt asks whether to deploy immediately. It is skipped in `--yes` runs unless you pass `--deploy`; the Composer files are still generated. Prisma Client generation is automatic, and PostgreSQL uses Prisma Postgres by default without additional prompts.
 
 ## Local Development
 

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as createCreatePrismaCli } from "./src-BZW88NIr.mjs";
+import { n as createCreatePrismaCli } from "./src-8s8Pt9Xh.mjs";
 //#region src/cli.ts
 await createCreatePrismaCli().run({ formatError: (error) => error instanceof Error ? error.message : String(error) });
 if (process.exitCode && process.exitCode !== 0) process.exit(process.exitCode);

package/dist/index.d.mts

@@ -187,10 +187,6 @@ declare const PackageManagerSchema: z.ZodEnum<{
   bun: "bun";
   deno: "deno";
 }>;
-declare const SchemaPresetSchema: z.ZodEnum<{
-  empty: "empty";
-  basic: "basic";
-}>;
 declare const CreateTemplateSchema: z.ZodEnum<{
   hono: "hono";
   elysia: "elysia";
@@ -220,15 +216,8 @@ declare const CreateCommandInputSchema: z.ZodObject<{
     bun: "bun";
     deno: "deno";
   }>>;
-  prismaPostgres: z.ZodOptional<z.ZodBoolean>;
   databaseUrl: z.ZodOptional<z.ZodString>;
   install: z.ZodOptional<z.ZodBoolean>;
-  generate: z.ZodOptional<z.ZodBoolean>;
-  migrateAndSeed: z.ZodOptional<z.ZodBoolean>;
-  schemaPreset: z.ZodOptional<z.ZodEnum<{
-    empty: "empty";
-    basic: "basic";
-  }>>;
   name: z.ZodOptional<z.ZodString>;
   template: z.ZodOptional<z.ZodEnum<{
     hono: "hono";
@@ -268,15 +257,8 @@ declare const router: {
       bun: "bun";
       deno: "deno";
     }>>;
-    prismaPostgres: import("zod").ZodOptional<import("zod").ZodBoolean>;
     databaseUrl: import("zod").ZodOptional<import("zod").ZodString>;
     install: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    generate: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    migrateAndSeed: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    schemaPreset: import("zod").ZodOptional<import("zod").ZodEnum<{
-      empty: "empty";
-      basic: "basic";
-    }>>;
     name: import("zod").ZodOptional<import("zod").ZodString>;
     template: import("zod").ZodOptional<import("zod").ZodEnum<{
       hono: "hono";
@@ -299,4 +281,4 @@ declare const router: {
 declare function createCreatePrismaCli(): import("trpc-cli").TrpcCli;
 declare function create(input?: CreateCommandInput): Promise<void>;
 //#endregion
-export { type CreateCommandInput, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, router };
+export { type CreateCommandInput, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, create, createCreatePrismaCli, router };

package/dist/index.mjs

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import { a as CreateTemplateSchema, c as PackageManagerSchema, i as CreateCommandInputSchema, l as SchemaPresetSchema, n as createCreatePrismaCli, o as DatabaseProviderSchema, r as router, s as DatabaseUrlSchema, t as create } from "./src-BZW88NIr.mjs";
-export { CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, router };
+import { a as CreateTemplateSchema, c as PackageManagerSchema, i as CreateCommandInputSchema, n as createCreatePrismaCli, o as DatabaseProviderSchema, r as router, s as DatabaseUrlSchema, t as create } from "./src-8s8Pt9Xh.mjs";
+export { CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, create, createCreatePrismaCli, router };

package/dist/{src-BZW88NIr.mjs → src-8s8Pt9Xh.mjs}

@@ -4,6 +4,7 @@ import { createCli } from "trpc-cli";
 import { cancel, confirm, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
 import fs from "fs-extra";
 import path from "node:path";
+import { isMap, parseDocument } from "yaml";
 import Handlebars from "handlebars";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -48,6 +49,7 @@ const dependencyVersionMap = {
 	prisma: "^7.8.0",
 	tsx: "^4.22.4"
 };
+const prismaPlatformCliPackage = "@prisma/cli@3.0.0-beta.29";
 const composerTemplates = /* @__PURE__ */ new Set([
 	"hono",
 	"elysia",
@@ -55,6 +57,7 @@ const composerTemplates = /* @__PURE__ */ new Set([
 	"next",
 	"astro",
 	"nuxt",
+	"svelte",
 	"tanstack-start",
 	"turborepo"
 ]);
@@ -89,9 +92,10 @@ function getCreateTemplateDependencies(template, packageManager, composer = fals
 				"@prisma/composer",
 				"@prisma/composer-prisma-cloud",
 				"arktype",
-				"effect"
+				"effect",
+				...template === "turborepo" ? ["dotenv"] : []
 			],
-			devDependencies: template === "hono" || template === "elysia" || template === "nest" ? ["esbuild"] : []
+			devDependencies: template === "hono" || template === "elysia" || template === "nest" || template === "svelte" ? ["esbuild"] : []
 		});
 		if (template === "turborepo") targets.push({
 			packageJsonPath: "apps/api/package.json",
@@ -117,7 +121,6 @@ const packageManagers = [
 	"bun",
 	"deno"
 ];
-const schemaPresets = ["empty", "basic"];
 const createTemplates = [
 	"hono",
 	"elysia",
@@ -150,7 +153,6 @@ const prismaSkillNames = [
 ];
 const DatabaseProviderSchema = z.enum(databaseProviders);
 const PackageManagerSchema = z.enum(packageManagers);
-const SchemaPresetSchema = z.enum(schemaPresets);
 const CreateTemplateSchema = z.enum(createTemplates);
 z.enum(createAddons);
 z.enum(addonInstallScopes);
@@ -164,12 +166,8 @@ 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("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"),
-	migrateAndSeed: z.boolean().optional().describe("Run an initial migration and seed after Prisma Client generation"),
-	schemaPreset: SchemaPresetSchema.optional().describe("Schema preset to scaffold in prisma/schema.prisma")
+	install: z.boolean().optional().describe("Install dependencies with selected package manager")
 });
 const PrismaSetupCommandInputSchema = CommonCommandOptionsSchema.extend(PrismaSetupOptionsSchema.shape);
 const CreateScaffoldOptionsSchema = z.object({
@@ -188,6 +186,7 @@ const COMPOSER_DEPLOYABLE_TEMPLATES = /* @__PURE__ */ new Set([
 	"next",
 	"astro",
 	"nuxt",
+	"svelte",
 	"tanstack-start",
 	"turborepo"
 ]);
@@ -428,10 +427,10 @@ function getPrismaCliArgs(packageManager, prismaArgs) {
 		]
 	};
 	if (packageManager === "bun") return {
-		command: "bun",
+		command: "bunx",
 		args: [
-			"--env-file=.env",
-			"./node_modules/.bin/prisma",
+			"--bun",
+			"prisma",
 			...prismaArgs
 		]
 	};
@@ -469,10 +468,11 @@ function getSeedCommand(packageManager) {
 }
 function getPrismaCommand(packageManager, subcommand) {
 	if (packageManager === "deno") return `deno run -A --env-file=.env npm:prisma@${dependencyVersionMap.prisma} ${subcommand}`;
-	if (packageManager === "bun") return `bun --env-file=.env ./node_modules/.bin/prisma ${subcommand}`;
 	return `prisma ${subcommand}`;
 }
 Handlebars.registerHelper("eq", (left, right) => left === right);
+Handlebars.registerHelper("composerPlatformCliInvocation", (packageManager) => packageManager ? JSON.stringify(getPackageExecutionArgs(packageManager, [prismaPlatformCliPackage], { silent: true })) : "{}");
+Handlebars.registerHelper("prismaCliInvocation", (packageManager) => packageManager ? JSON.stringify(getPrismaCliArgs(packageManager, [])) : "{}");
 Handlebars.registerHelper("runScriptCommand", (packageManager, scriptName) => packageManager ? getRunScriptCommand(packageManager, scriptName) : "");
 Handlebars.registerHelper("runScriptInDirectoryCommand", (packageManager, directory, scriptName) => packageManager ? getRunScriptInDirectoryCommand(packageManager, directory, scriptName) : "");
 Handlebars.registerHelper("packageManagerManifestValue", (packageManager) => getPackageManagerManifestValue(packageManager) ?? "");
@@ -551,11 +551,11 @@ async function renderTemplateTree(opts) {
 function getCreateTemplateDir(template) {
 	return resolveTemplatesDir(`templates/create/${template}`);
 }
-function createTemplateContext(projectName, provider, schemaPreset, packageManager, composer, composerPostgres) {
+function createTemplateContext(projectName, template, provider, packageManager, composer, composerPostgres) {
 	return {
 		projectName,
+		template,
 		provider,
-		schemaPreset,
 		packageManager,
 		composer,
 		composerPostgres
@@ -604,15 +604,15 @@ function mergePnpmAllowBuilds(content) {
 	return `${lines.join("\n")}\n`;
 }
 function mergePnpmComposerOverrides(content) {
-	const missingOverrides = Object.entries(composerEffectOverrides).filter(([packageName]) => !new RegExp(`^\\s*${escapeRegExp(JSON.stringify(packageName))}\\s*:`, "m").test(content));
+	const document = parseDocument(content);
+	if (document.errors.length > 0) throw new Error(`Could not update pnpm-workspace.yaml: ${document.errors[0]?.message}`);
+	if (!document.has("overrides")) document.set("overrides", document.createNode({}));
+	const overrides = document.get("overrides", true);
+	if (!isMap(overrides)) throw new Error("Could not update pnpm-workspace.yaml: \"overrides\" must be a mapping.");
+	const missingOverrides = Object.entries(composerEffectOverrides).filter(([packageName]) => !overrides.has(packageName));
 	if (missingOverrides.length === 0) return content;
-	const missingLines = missingOverrides.map(([packageName, version]) => `  ${JSON.stringify(packageName)}: ${version}`);
-	const trimmedContent = content.trimEnd();
-	const lines = trimmedContent.length > 0 ? trimmedContent.split("\n") : [];
-	const overridesIndex = lines.findIndex((line) => /^overrides:\s*$/.test(line));
-	if (overridesIndex === -1) return `${trimmedContent}\n\noverrides:\n${missingLines.join("\n")}\n`;
-	lines.splice(overridesIndex + 1, 0, ...missingLines);
-	return `${lines.join("\n")}\n`;
+	for (const [packageName, version] of missingOverrides) overrides.set(packageName, version);
+	return document.toString();
 }
 async function ensurePnpmWorkspace(projectDir, composer) {
 	const workspacePath = path.join(projectDir, "pnpm-workspace.yaml");
@@ -627,11 +627,18 @@ async function ensurePnpmWorkspace(projectDir, composer) {
 	if (nextContent !== existingContent) await fs.writeFile(workspacePath, nextContent, "utf8");
 }
 async function scaffoldCreateTemplate(opts) {
-	const { projectDir, projectName, template, provider, schemaPreset, packageManager } = opts;
+	const { projectDir, projectName, template, provider, packageManager } = opts;
+	const templateRoot = getCreateTemplateDir(template);
+	const context = createTemplateContext(projectName, template, provider, packageManager, opts.composer === true, opts.composerPostgres === true);
 	await renderTemplateTree({
-		templateRoot: getCreateTemplateDir(template),
+		templateRoot,
 		outputDir: projectDir,
-		context: createTemplateContext(projectName, provider, schemaPreset, packageManager, opts.composer === true, opts.composerPostgres === true)
+		context
+	});
+	if (context.composer && context.composerPostgres) await renderTemplateFile({
+		templateFilePath: resolveTemplatesDir("templates/shared/setup-composer-postgres.mjs.hbs"),
+		outputPath: path.join(projectDir, "scripts/setup-composer-postgres.mjs"),
+		context
 	});
 	if (packageManager === "pnpm") await ensurePnpmWorkspace(projectDir, opts.composer === true);
 }
@@ -660,16 +667,6 @@ function getPrismaScriptMap(packageManager) {
 			"db:seed": `${prismaCli} 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:migrate:deploy": `${prismaCli} migrate deploy`,
-			"db:seed": `${prismaCli} db seed`
-		};
-	}
 	return {
 		"db:generate": "prisma generate",
 		"db:push": "prisma db push",
@@ -858,11 +855,7 @@ function getCreateDbCommand(packageManager) {
 //#endregion
 //#region src/tasks/setup-prisma.ts
 const DEFAULT_DATABASE_PROVIDER = "postgresql";
-const DEFAULT_SCHEMA_PRESET$1 = "empty";
-const DEFAULT_PRISMA_POSTGRES = true;
 const DEFAULT_INSTALL = true;
-const DEFAULT_GENERATE = true;
-const DEFAULT_MIGRATE_AND_SEED = true;
 const PRISMA_POSTGRES_MIGRATION_DELAY_MS = 2e3;
 const requiredPrismaFileGroups = [
 	["prisma/schema.prisma", "packages/db/prisma/schema.prisma"],
@@ -969,28 +962,6 @@ async function promptForDependencyInstall(packageManager) {
 	}
 	return Boolean(shouldInstall);
 }
-async function promptForMigrateAndSeed() {
-	const shouldMigrateAndSeed = await confirm({
-		message: "Run an initial migration and seed your database now?",
-		initialValue: DEFAULT_MIGRATE_AND_SEED
-	});
-	if (isCancel(shouldMigrateAndSeed)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	return Boolean(shouldMigrateAndSeed);
-}
-async function promptForPrismaPostgres() {
-	const shouldUsePrismaPostgres = await confirm({
-		message: "Use Prisma Postgres and write DATABASE_URL automatically?",
-		initialValue: true
-	});
-	if (isCancel(shouldUsePrismaPostgres)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	return Boolean(shouldUsePrismaPostgres);
-}
 function getCommandErrorMessage(error) {
 	if (error instanceof Error && "stderr" in error) {
 		const stderr = String(error.stderr ?? "").trim();
@@ -1002,10 +973,8 @@ async function collectPrismaSetupInitialContext(input, options = {}) {
 	const projectDir = path.resolve(options.projectDir ?? process.cwd());
 	const useDefaults = input.yes === true;
 	const verbose = input.verbose === true;
-	const shouldGenerate = input.generate ?? DEFAULT_GENERATE;
 	const databaseProvider = input.provider ?? (useDefaults ? DEFAULT_DATABASE_PROVIDER : await promptForDatabaseProvider());
 	if (!databaseProvider) return;
-	const schemaPreset = input.schemaPreset ?? options.defaultSchemaPreset ?? DEFAULT_SCHEMA_PRESET$1;
 	const databaseUrl = input.databaseUrl;
 	const detectedPackageManager = await detectPackageManager(projectDir);
 	const packageManager = input.packageManager ?? (useDefaults ? detectedPackageManager : await promptForPackageManager(detectedPackageManager));
@@ -1015,29 +984,18 @@ async function collectPrismaSetupInitialContext(input, options = {}) {
 	return {
 		projectDir,
 		verbose,
-		shouldGenerate,
 		databaseProvider,
-		schemaPreset,
 		databaseUrl,
 		packageManager,
 		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;
+async function completePrismaSetupContext(context, options = {}) {
+	const shouldUsePrismaPostgres = context.databaseProvider === "postgresql" && !context.databaseUrl;
 	return {
 		...context,
 		shouldUsePrismaPostgres,
-		shouldMigrateAndSeed
+		shouldMigrateAndSeed: options.shouldMigrateAndSeed === true
 	};
 }
 function getDefaultDatabaseUrl(provider) {
@@ -1223,7 +1181,6 @@ async function finalizePrismaFilesForContext(context, projectDir, provisionResul
 }
 async function generatePrismaClientForContext(context, projectDir) {
 	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
-	if (!context.shouldGenerate) return { didGenerateClient: false };
 	const generateCommand = getRunScriptCommand(context.packageManager, "db:generate");
 	if (context.verbose) log.step(`Running ${generateCommand}`);
 	const generateSpinner = context.verbose ? void 0 : spinner();
@@ -1257,7 +1214,7 @@ function buildNextStepsForContext(opts) {
 	const { context, options, didGenerateClient, didMigrate, didSeed } = 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 (!didGenerateClient) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:generate")}`);
 	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")}`);
@@ -1271,7 +1228,7 @@ async function executePrismaMigrationAndSeed(params) {
 	});
 	return migrateAndSeedIfRequested(params.context, params.projectDir, {
 		databaseUrl: params.databaseUrl,
-		didGenerateClient: true
+		didGenerateClient: params.didGenerateClient
 	});
 }
 async function executePrismaSetupContext(context, options = {}) {
@@ -1298,6 +1255,7 @@ async function executePrismaSetupContext(context, options = {}) {
 			didSeed: migrateAndSeedResult.didSeed
 		}),
 		warningSection: warningLines.length > 0 ? `\n\n${warningLines.join("\n")}` : "",
+		didGenerateClient: generateResult.didGenerateClient,
 		databaseUrl: provisionResult.databaseUrl ?? context.databaseUrl
 	};
 }
@@ -1899,7 +1857,6 @@ async function executeCreateAddonSetupContext(params) {
 }
 //#endregion
 //#region src/tasks/deploy-with-composer.ts
-const PRISMA_PLATFORM_CLI = "@prisma/cli@latest";
 function hasEnvironmentValue(name) {
 	return (process.env[name] ?? "").trim().length > 0;
 }
@@ -1925,7 +1882,7 @@ function createExplicitDeployError(reason, error) {
 }
 async function runPlatformCliJson(params) {
 	const execution = getPackageExecutionArgs(params.context.packageManager, [
-		PRISMA_PLATFORM_CLI,
+		prismaPlatformCliPackage,
 		...params.args,
 		"--json",
 		"--no-interactive"
@@ -1947,8 +1904,8 @@ async function runPlatformCliJson(params) {
 		}
 	})();
 	if (result.exitCode !== 0 || !parsed || !parsed.ok) {
-		const detail = parsed && !parsed.ok ? parsed.error?.summary ?? parsed.error?.message : result.stderr || "invalid JSON output";
-		throw new Error(getErrorMessage(detail));
+		const detail = parsed && !parsed.ok ? parsed.error?.summary ?? parsed.error?.message ?? result.stderr : result.stderr || "invalid JSON output";
+		throw new Error(getErrorMessage(detail || "Prisma CLI reported an unknown error"));
 	}
 	return parsed.result;
 }
@@ -2014,13 +1971,15 @@ async function resolveComposerPostgresDatabaseUrl(params) {
 	return databaseUrl;
 }
 function getComposerDeployScriptMap(context) {
+	const steps = [
+		getRunScriptCommand(context.packageManager, "build"),
+		getRunScriptCommand(context.packageManager, "composer:deploy"),
+		...context.useComposerPostgres ? [getRunScriptCommand(context.packageManager, "composer:database:setup")] : []
+	];
 	return {
 		"composer:deploy": "prisma-composer deploy module.ts",
-		deploy: [
-			...context.useComposerPostgres ? [getRunScriptCommand(context.packageManager, "db:migrate:deploy")] : [],
-			getRunScriptCommand(context.packageManager, "build"),
-			getRunScriptCommand(context.packageManager, "composer:deploy")
-		].join(" && ")
+		...context.useComposerPostgres ? { "composer:database:setup": "node scripts/setup-composer-postgres.mjs" } : {},
+		deploy: steps.join(" && ")
 	};
 }
 async function collectComposerDeployContext(input, options) {
@@ -2136,7 +2095,7 @@ async function getAnonymousId() {
 }
 function getCommonProperties() {
 	return {
-		"cli-version": "0.7.1-pr.52.167.1",
+		"cli-version": "0.7.1-pr.52.169.1",
 		"node-version": process.version,
 		platform: process.platform,
 		arch: process.arch
@@ -2195,10 +2154,9 @@ 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?.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,
+		"should-generate": true,
+		"uses-prisma-postgres": context?.prismaSetupContext.shouldUsePrismaPostgres ?? (input.provider === "postgresql" && !input.databaseUrl ? true : null),
 		addons: resolvedAddons,
 		"addon-count": resolvedAddons.length,
 		"addon-scope": context?.addonSetupContext?.scope ?? null,
@@ -2245,7 +2203,6 @@ function getCreatePrismaIntro() {
 //#region src/commands/create.ts
 const DEFAULT_PROJECT_NAME = "my-app";
 const DEFAULT_TEMPLATE = "hono";
-const DEFAULT_SCHEMA_PRESET = "basic";
 function toPackageName(projectName) {
 	return projectName.toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^-+/, "").replace(/-+$/, "") || "app";
 }
@@ -2406,10 +2363,7 @@ async function collectCreateContext(input) {
 		cancel(`Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`);
 		return;
 	}
-	const prismaSetupInitialContext = await collectPrismaSetupInitialContext(input, {
-		projectDir: targetDirectory,
-		defaultSchemaPreset: DEFAULT_SCHEMA_PRESET
-	});
+	const prismaSetupInitialContext = await collectPrismaSetupInitialContext(input, { projectDir: targetDirectory });
 	if (!prismaSetupInitialContext) return;
 	const projectPackageName = toPackageName(path.basename(targetDirectory));
 	const composerDeployContext = await collectComposerDeployContext(input, {
@@ -2419,16 +2373,17 @@ async function collectCreateContext(input) {
 		useDefaults
 	});
 	if (composerDeployContext === void 0) return;
-	const prismaSetupContext = await completePrismaSetupContext(input, prismaSetupInitialContext);
+	const prismaSetupContext = await completePrismaSetupContext(prismaSetupInitialContext, { shouldMigrateAndSeed: Boolean(composerDeployContext) });
 	if (!prismaSetupContext) return;
-	const useComposerPostgres = Boolean(composerDeployContext && prismaSetupContext.shouldUsePrismaPostgres);
+	const composerEnabled = isComposerDeployableTemplate(template) && prismaSetupContext.packageManager !== "deno";
+	const useComposerPostgres = composerEnabled && prismaSetupContext.shouldUsePrismaPostgres;
 	if (composerDeployContext) composerDeployContext.useComposerPostgres = useComposerPostgres;
-	if (useComposerPostgres) log.info("Prisma Postgres selected: Composer will provision the database and wire it into the application.");
-	const composerContext = isComposerDeployableTemplate(template) && prismaSetupContext.packageManager !== "deno" ? composerDeployContext ?? {
+	if (composerDeployContext && useComposerPostgres) log.info("Composer will provision Prisma Postgres and wire it into the application.");
+	const composerScaffoldContext = composerEnabled ? composerDeployContext ?? {
 		template,
 		packageManager: prismaSetupContext.packageManager,
 		projectName: projectPackageName,
-		useComposerPostgres: false
+		useComposerPostgres
 	} : void 0;
 	const addonSetupContext = await collectCreateAddonSetupContext(input, {
 		useDefaults,
@@ -2445,7 +2400,7 @@ async function collectCreateContext(input) {
 		projectPackageName,
 		prismaSetupContext,
 		addonSetupContext: addonSetupContext ?? void 0,
-		composerContext,
+		composerScaffoldContext,
 		composerDeployContext: composerDeployContext ?? void 0,
 		useComposerPostgres
 	};
@@ -2458,10 +2413,9 @@ async function executeCreateContext(context) {
 			projectDir: context.targetDirectory,
 			projectName: context.projectPackageName,
 			template: context.template,
-			schemaPreset: context.prismaSetupContext.schemaPreset,
 			provider: context.prismaSetupContext.databaseProvider,
 			packageManager: context.prismaSetupContext.packageManager,
-			composer: Boolean(context.composerContext),
+			composer: Boolean(context.composerScaffoldContext),
 			composerPostgres: context.useComposerPostgres
 		});
 		scaffoldSpinner.stop("Project files scaffolded.");
@@ -2477,11 +2431,11 @@ async function executeCreateContext(context) {
 		await writeCreateTemplateDependencies({
 			template: context.template,
 			packageManager: context.prismaSetupContext.packageManager,
-			composer: Boolean(context.composerContext),
+			composer: Boolean(context.composerScaffoldContext),
 			projectDir: context.targetDirectory
 		});
-		if (context.composerContext) await addPackageDependency({
-			scripts: getComposerDeployScriptMap(context.composerContext),
+		if (context.composerScaffoldContext) await addPackageDependency({
+			scripts: getComposerDeployScriptMap(context.composerScaffoldContext),
 			scriptMode: "if-missing",
 			projectDir: context.targetDirectory
 		});
@@ -2510,7 +2464,8 @@ async function executeCreateContext(context) {
 	}
 	let prismaResult;
 	try {
-		prismaResult = await executePrismaSetupContext(context.useComposerPostgres ? {
+		const deploysComposerPostgresNow = Boolean(context.composerDeployContext && context.useComposerPostgres);
+		prismaResult = await executePrismaSetupContext(deploysComposerPostgresNow ? {
 			...context.prismaSetupContext,
 			shouldUsePrismaPostgres: false,
 			shouldMigrateAndSeed: false
@@ -2518,7 +2473,7 @@ async function executeCreateContext(context) {
 			prependNextSteps: nextSteps,
 			projectDir: context.targetDirectory,
 			includeDevNextStep: true,
-			includeMigrationAndSeedNextSteps: !context.useComposerPostgres
+			includeMigrationAndSeedNextSteps: !deploysComposerPostgresNow
 		});
 		if (!prismaResult.ok) return {
 			ok: false,
@@ -2545,15 +2500,25 @@ async function executeCreateContext(context) {
 		if (result.ok) {
 			deployResult = result.result;
 			if (context.useComposerPostgres) {
-				const databaseUrl = await resolveComposerPostgresDatabaseUrl({
-					context: context.composerDeployContext,
-					projectDir: context.targetDirectory
-				});
-				const migration = await executePrismaMigrationAndSeed({
-					context: context.prismaSetupContext,
-					projectDir: context.targetDirectory,
-					databaseUrl
-				});
+				let migration;
+				try {
+					const databaseUrl = await resolveComposerPostgresDatabaseUrl({
+						context: context.composerDeployContext,
+						projectDir: context.targetDirectory
+					});
+					migration = await executePrismaMigrationAndSeed({
+						context: context.prismaSetupContext,
+						projectDir: context.targetDirectory,
+						databaseUrl,
+						didGenerateClient: prismaResult.didGenerateClient
+					});
+				} catch (error) {
+					migration = {
+						didMigrate: false,
+						didSeed: false,
+						warning: `Could not resolve the Composer-provisioned database URL: ${error instanceof Error ? error.message : String(error)}`
+					};
+				}
 				if (migration.warning) prismaResult.warningSection += `\n\n- ${migration.warning}`;
 				if (!migration.didMigrate) prismaResult.nextSteps.push(`- ${getRunScriptCommand(context.prismaSetupContext.packageManager, "db:migrate")}`);
 				if (!migration.didSeed) prismaResult.nextSteps.push(`- ${getRunScriptCommand(context.prismaSetupContext.packageManager, "db:seed")}`);
@@ -2576,7 +2541,7 @@ async function executeCreateContext(context) {
 }
 //#endregion
 //#region src/index.ts
-const CLI_VERSION = "0.7.1-pr.52.167.1";
+const CLI_VERSION = "0.7.1-pr.52.169.1";
 const router = os.router({ create: os.meta({
 	description: "Create a new project with Prisma setup",
 	default: true,
@@ -2595,4 +2560,4 @@ async function create(input = {}) {
 	await runCreateCommand(input);
 }
 //#endregion
-export { CreateTemplateSchema as a, PackageManagerSchema as c, CreateCommandInputSchema as i, SchemaPresetSchema as l, createCreatePrismaCli as n, DatabaseProviderSchema as o, router as r, DatabaseUrlSchema as s, create as t };
+export { CreateTemplateSchema as a, PackageManagerSchema as c, CreateCommandInputSchema as i, createCreatePrismaCli as n, DatabaseProviderSchema as o, router as r, DatabaseUrlSchema as s, create as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma",
-  "version": "0.7.1-pr.52.167.1",
+  "version": "0.7.1-pr.52.169.1",
   "private": false,
   "description": "Create Prisma 7 projects with first-party templates and great DX.",
   "homepage": "https://github.com/prisma/create-prisma",
@@ -54,6 +54,7 @@
     "handlebars": "^4.7.9",
     "posthog-node": "^5.38.2",
     "trpc-cli": "^0.15.1",
+    "yaml": "^2.8.2",
     "zod": "^4.4.3"
   },
   "devDependencies": {