create-prisma 0.4.2-pr.53.201.1 → 0.4.2-pr.55.205.1

package/README.md

@@ -13,7 +13,7 @@ yarn dlx create-prisma@next my-app
 bunx create-prisma@next my-app
 ```
 
-The CLI initializes Prisma 8 with the aligned `@prisma/cli` prerelease, installs dependencies, emits the contract, and generates a deployable Composer app. PostgreSQL projects use Composer's native Prisma Postgres provider, including migrations and a typed runtime client.
+The CLI initializes Prisma 8 with `prisma@next`, installs dependencies, emits the contract, and generates a deployable Composer app. PostgreSQL projects use Composer's native Prisma Postgres provider, including migrations and a typed runtime client.
 
 The only Composer prompt is:
 

package/dist/cli.mjs

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

package/dist/{create-Bp1eBfXs.mjs → create-ek-5J5Ze.mjs}

@@ -40,7 +40,7 @@ async function getAnonymousId() {
 }
 function getCommonProperties() {
 	return {
-		"cli-version": "0.4.2-pr.53.201.1",
+		"cli-version": "0.4.2-pr.55.205.1",
 		"node-version": process.version,
 		platform: process.platform,
 		arch: process.arch
@@ -429,10 +429,10 @@ const dependencyVersionMap = {
 	"@astrojs/node": "^10.0.2",
 	"@elysiajs/node": "^1.4.5",
 	"@prisma/cli-engine": "0.2.0",
-	"@prisma/composer": "0.9.0",
-	"@prisma/composer-prisma-cloud": "0.9.0",
-	"@prisma/orm-mongo": "8.0.0-rc.3",
-	"@prisma/orm-postgres": "8.0.0-rc.3",
+	"@prisma/composer": "0.10.0",
+	"@prisma/composer-prisma-cloud": "0.10.0",
+	"@prisma/orm-mongo": "8.0.0-rc.4",
+	"@prisma/orm-postgres": "8.0.0-rc.4",
 	"@sveltejs/adapter-node": "^5.3.2",
 	"@types/node": "^25.6.2",
 	alchemy: "2.0.0-beta.67",
@@ -613,31 +613,42 @@ function parsePrismaCliEnvelope(output) {
 	} catch {}
 	throw new Error("Prisma CLI returned output that is not a valid result envelope.");
 }
-function extractDeploymentUrl(output) {
-	return output.match(/https:\/\/[a-z0-9.-]+\.prisma\.build\/?/gi)?.at(-1)?.replace(/\/$/, "");
-}
 function getPrismaCliArgs(packageManager, args) {
 	return getPackageExecutionArgs(packageManager, [PRISMA_PLATFORM_CLI_PACKAGE, ...args]);
 }
-async function isAuthenticated(packageManager, projectDir) {
-	const invocation = getPrismaCliArgs(packageManager, [
-		"auth",
-		"whoami",
+async function runPrismaJsonCommand(options) {
+	const invocation = getPrismaCliArgs(options.packageManager, [
+		...options.args,
 		"--json",
 		"--no-interactive"
 	]);
 	const result = await execa(invocation.command, invocation.args, {
-		cwd: projectDir,
+		cwd: options.projectDir,
 		env: process.env,
 		reject: false
 	});
-	const envelope = parsePrismaCliEnvelope(result.stdout);
-	if (result.exitCode !== 0 || !envelope.ok) throw new Error(envelope.error?.summary ?? envelope.error?.message ?? "Prisma authentication check failed.");
-	if (typeof envelope.result !== "object" || envelope.result === null) return false;
-	return Reflect.get(envelope.result, "authenticated") === true;
+	if (options.forwardStderr && result.stderr) process.stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}\n`);
+	let envelope;
+	try {
+		envelope = parsePrismaCliEnvelope(result.stdout);
+	} catch (error) {
+		if (result.exitCode !== 0 && result.stderr.trim()) throw new Error(result.stderr.trim());
+		throw error;
+	}
+	if (result.exitCode !== 0 || !envelope.ok || envelope.result === void 0) {
+		const summary = envelope.error?.summary ?? envelope.error?.message;
+		throw new Error([summary, envelope.error?.why].filter(Boolean).join(": ") || result.stderr.trim() || "Prisma CLI command failed.");
+	}
+	return envelope.result;
 }
 async function ensureAuthentication(packageManager, projectDir) {
-	if (await isAuthenticated(packageManager, projectDir)) return;
+	const whoami = () => runPrismaJsonCommand({
+		packageManager,
+		projectDir,
+		args: ["auth", "whoami"]
+	});
+	const authState = await whoami();
+	if (authState.authenticated) return authState;
 	const loginCommand = getPackageExecutionCommand(packageManager, [
 		PRISMA_PLATFORM_CLI_PACKAGE,
 		"auth",
@@ -651,30 +662,88 @@ async function ensureAuthentication(packageManager, projectDir) {
 		env: process.env,
 		stdio: "inherit"
 	});
-	if (!await isAuthenticated(packageManager, projectDir)) throw new Error("Prisma sign-in completed without an active workspace session.");
+	const authenticatedState = await whoami();
+	if (!authenticatedState.authenticated) throw new Error("Prisma sign-in completed without an active workspace session.");
+	return authenticatedState;
+}
+function parseComposerDeployResult(result) {
+	const summary = result.summary;
+	if (!summary) return;
+	const computeService = summary.nodes.flatMap((node) => node.entities).find((entity) => entity.kind === "compute-service");
+	return {
+		appName: summary.app,
+		...computeService?.url ? { appUrl: computeService.url.replace(/\/$/, "") } : {}
+	};
+}
+async function getProjectDetails(options) {
+	try {
+		const result = await runPrismaJsonCommand({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			args: [
+				"project",
+				"show",
+				"--project",
+				options.appName
+			]
+		});
+		if (!result.project) return;
+		return {
+			workspace: result.workspace,
+			project: {
+				id: result.project.id,
+				name: result.project.name,
+				consoleUrl: `https://console.prisma.io/${encodeURIComponent(result.workspace.id)}/${encodeURIComponent(result.project.id)}`
+			}
+		};
+	} catch {
+		return;
+	}
 }
 async function deployWithComposer(options) {
 	const progress = options.verbose ? void 0 : spinner();
 	try {
-		await ensureAuthentication(options.packageManager, options.projectDir);
-		progress?.start("Deploying to Prisma...");
-		const command = getRunScriptArgs(options.packageManager, "deploy");
-		const result = await execa(command.command, command.args, {
+		const authState = await ensureAuthentication(options.packageManager, options.projectDir);
+		progress?.start("Building for deployment...");
+		if (options.verbose) log.step("Building for deployment.");
+		const build = getRunScriptArgs(options.packageManager, "build");
+		await execa(build.command, build.args, {
 			cwd: options.projectDir,
 			env: process.env,
 			stdio: options.verbose ? "inherit" : "pipe"
 		});
+		progress?.message("Deploying to Prisma...");
+		if (options.verbose) log.step("Deploying to Prisma.");
+		const deployment = parseComposerDeployResult(await runPrismaJsonCommand({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			args: [
+				"composer",
+				"deploy",
+				"module.ts"
+			],
+			forwardStderr: options.verbose
+		}));
+		const appName = deployment?.appName ?? options.appName;
+		progress?.message("Loading deployment details...");
+		const details = await getProjectDetails({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			appName
+		});
 		progress?.stop("Deployed to Prisma.");
 		if (options.verbose) log.success("Deployed to Prisma.");
-		else {
-			const deploymentUrl = extractDeploymentUrl([result.stdout, result.stderr].filter((value) => typeof value === "string").join("\n"));
-			if (deploymentUrl) log.info(`App: ${deploymentUrl}`);
-		}
-		return true;
+		const workspace = details?.workspace ?? authState.workspace ?? void 0;
+		return {
+			appName,
+			...deployment?.appUrl ? { appUrl: deployment.appUrl } : {},
+			...workspace ? { workspace } : {},
+			project: details?.project ?? { name: appName }
+		};
 	} catch (error) {
-		progress?.stop("Deployment failed.");
+		progress?.error("Deployment failed.");
 		log.error(`Deploy failed: ${getErrorMessage(error)}`);
-		return false;
+		return;
 	}
 }
 
@@ -861,6 +930,20 @@ async function emitContract(context, projectDir) {
 function formatNextSteps(steps) {
 	return steps.map((step) => `${step.command}\n  ${step.description}`).join("\n\n");
 }
+function formatPlatformTarget(name, id) {
+	return name ? `${name} (${id})` : id;
+}
+function formatProjectSummary(options) {
+	const lines = [];
+	if (options.createdProjectPath) lines.push(`Path: ${path.resolve(options.createdProjectPath)}`);
+	if (options.deployment?.workspace) lines.push(`Workspace: ${formatPlatformTarget(options.deployment.workspace.name, options.deployment.workspace.id)}`);
+	if (options.deployment) {
+		lines.push(`Project: ${options.deployment.project.id ? formatPlatformTarget(options.deployment.project.name, options.deployment.project.id) : options.deployment.project.name}`);
+		lines.push(`App: ${options.deployment.appUrl ?? options.deployment.appName}`);
+		if (options.deployment.project.consoleUrl) lines.push(`Console: ${options.deployment.project.consoleUrl}`);
+	}
+	return lines.join("\n");
+}
 function buildNextSteps(context, options) {
 	const nextSteps = [...options.prependNextSteps ?? []];
 	if (context.databaseProvider === "mongo") nextSteps.push({
@@ -903,20 +986,27 @@ async function executePrismaSetupContext(context, options = {}) {
 		await emitContract(context, projectDir);
 		progress?.stop("Prisma 8 project ready.");
 	} catch (error) {
-		progress?.stop("Could not create Prisma 8 project.");
+		progress?.error("Could not create Prisma 8 project.");
 		cancel(getCommandErrorMessage(error));
 		return false;
 	}
+	let deployment;
 	if (context.shouldDeploy) {
-		if (!await deployWithComposer({
+		deployment = await deployWithComposer({
+			appName: projectName,
 			packageManager: context.packageManager,
 			projectDir,
 			verbose: context.verbose
-		})) return false;
+		});
+		if (!deployment) return false;
 	}
-	if (options.createdProjectPath) note(path.resolve(options.createdProjectPath), "Project path");
+	const projectSummary = formatProjectSummary({
+		createdProjectPath: options.createdProjectPath,
+		deployment
+	});
+	if (projectSummary) note(projectSummary, context.shouldDeploy ? "Deployment" : "Project");
 	note(formatNextSteps(buildNextSteps(context, options)), "Next steps");
-	outro(context.shouldDeploy ? "Prisma 8 app deployed." : "Prisma 8 setup complete.");
+	outro(context.shouldDeploy ? "Prisma 8 app deployed." : "Prisma 8 project ready.");
 	return true;
 }
 
@@ -1158,7 +1248,7 @@ async function executeCreateContext(context) {
 		});
 		if (context.prismaSetupContext.verbose) log.success("Starter files scaffolded.");
 	} catch (error) {
-		createSpinner?.stop("Could not create Prisma 8 project.");
+		createSpinner?.error("Could not create Prisma 8 project.");
 		return {
 			ok: false,
 			stage: "scaffold_template",
@@ -1172,7 +1262,7 @@ async function executeCreateContext(context) {
 			projectDir: context.targetDirectory
 		});
 	} catch (error) {
-		createSpinner?.stop("Could not create Prisma 8 project.");
+		createSpinner?.error("Could not create Prisma 8 project.");
 		return {
 			ok: false,
 			stage: "scaffold_template",
@@ -1198,7 +1288,7 @@ async function executeCreateContext(context) {
 			stage: "prisma_setup"
 		};
 	} catch (error) {
-		createSpinner?.stop("Could not create Prisma 8 project.");
+		createSpinner?.error("Could not create Prisma 8 project.");
 		return {
 			ok: false,
 			stage: "prisma_setup",

package/dist/index.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as PackageManagerSchema, r as CreateCommandInputSchema, t as runCreateCommand } from "./create-Bp1eBfXs.mjs";
+import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as PackageManagerSchema, r as CreateCommandInputSchema, t as runCreateCommand } from "./create-ek-5J5Ze.mjs";
 import { os } from "@orpc/server";
 import { createCli } from "trpc-cli";
 import { z } from "zod";
 
 //#region src/index.ts
-const CLI_VERSION = "0.4.2-pr.53.201.1";
+const CLI_VERSION = "0.4.2-pr.55.205.1";
 const CreateCliInputSchema = z.tuple([z.string().trim().min(1, "Please enter a valid project name").optional().describe("Project name / directory"), CreateCommandInputSchema]);
 function normalizeCreateCliInput(input) {
 	const [projectName, options] = input;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma",
-  "version": "0.4.2-pr.53.201.1",
+  "version": "0.4.2-pr.55.205.1",
   "private": false,
   "description": "Create Prisma 8 projects with first-party templates and great DX.",
   "homepage": "https://github.com/prisma/create-prisma",
@@ -50,7 +50,7 @@
     "release-notes": "bunx changelogithub"
   },
   "dependencies": {
-    "@clack/prompts": "^1.0.1",
+    "@clack/prompts": "^1.7.0",
     "@orpc/server": "^1.13.5",
     "execa": "^9.6.1",
     "fs-extra": "^11.3.3",

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

@@ -27,8 +27,7 @@ MongoDB is not provisioned by Composer. Set `MONGODB_URL` before running Compose
 ## Prisma
 
 - Contract: `src/prisma/contract{{#if (eq authoring "typescript")}}.ts{{else}}.prisma{{/if}}`
-- Prisma 8 config: `prisma-next.config.ts`
-- Universal CLI config: `prisma.config.ts`
+- Prisma and Composer config: `prisma.config.ts`
 - Composer app: `module.ts` and `service.ts`
 
 After changing the contract, run:

package/templates/create/_shared/module.ts.hbs

@@ -14,7 +14,7 @@ export default module("{{projectName}}", ({ provision }) => {
     pnPostgres({
       name: "database",
       contract: appContract,
-      config: "./prisma-next.config.ts",
+      config: "./prisma.config.ts",
     }),
     { id: "database" },
   );

package/templates/create/_shared/prisma.config.ts.hbs

@@ -1,9 +1,16 @@
 import { definePrismaConfig } from "@prisma/cli-engine";
-
-import orm from "./prisma-next.config.ts";
+import { defineConfig as ormConfig } from "@prisma/orm-{{#if (eq provider "postgres")}}postgres{{else}}mongo{{/if}}/config";
 
 export default definePrismaConfig({
-  orm,
+  orm: ormConfig({
+    contract: "./src/prisma/contract{{#if (eq authoring "typescript")}}.ts{{else}}.prisma{{/if}}",
+{{#if (eq authoring "typescript")}}
+    output: "./src/prisma/generated",
+{{/if}}
+    db: {
+      connection: process.env.{{#if (eq provider "postgres")}}DATABASE_URL{{else}}MONGODB_URL{{/if}}!,
+    },
+  }),
   composer: {
     configPath: "./prisma-composer.config.ts",
   },

package/templates/create/_shared/prisma-next.config.ts.hbs

@@ -1,11 +0,0 @@
-import { defineConfig } from "@prisma/orm-{{#if (eq provider "postgres")}}postgres{{else}}mongo{{/if}}/config";
-
-export default defineConfig({
-  contract: "./src/prisma/contract{{#if (eq authoring "typescript")}}.ts{{else}}.prisma{{/if}}",
-{{#if (eq authoring "typescript")}}
-  output: "./src/prisma/generated",
-{{/if}}
-  db: {
-    connection: process.env.DATABASE_URL!,
-  },
-});