create-prisma 0.4.2-next.37.204.1 → 0.4.2-next.37.212.1

package/README.md

@@ -15,7 +15,7 @@ bunx create-prisma@next my-app
 
 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:
+The deployment prompt is:
 
 ```text
 Deploy to Prisma now?
@@ -23,6 +23,10 @@ Deploy to Prisma now?
 
 Choose no to deploy later with the generated `deploy` script.
 
+When multiple Prisma workspace sessions are available, the CLI asks which workspace should receive
+the deployment. For unattended usage, pass `--workspace <id-or-name>` or omit it to use the active
+workspace. Choosing another workspace also updates the Prisma CLI's active workspace session.
+
 ## Templates
 
 - `minimal`
@@ -45,6 +49,7 @@ PostgreSQL and MongoDB are supported with PSL or TypeScript contract authoring.
 - `--authoring psl|typescript`
 - `--package-manager npm|pnpm|yarn|bun`
 - `--deploy` / `--no-deploy`
+- `--workspace <id-or-name>`
 - `--yes`
 - `--force`
 - `--verbose`

package/dist/cli.mjs

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

package/dist/{create-DO0KhezB.mjs → create-4KBOFn2z.mjs}

@@ -49,7 +49,7 @@ async function getAnonymousId() {
 }
 function getCommonProperties() {
 	return {
-		"cli-version": "0.4.2-next.37.204.1",
+		"cli-version": "0.4.2-next.37.212.1",
 		"node-version": process.version,
 		platform: process.platform,
 		arch: process.arch
@@ -178,7 +178,8 @@ const PrismaSetupOptionsSchema = z.object({
 	provider: DatabaseProviderSchema.optional().describe("Prisma 8 database target: PostgreSQL relational models or MongoDB document models"),
 	authoring: AuthoringStyleSchema.optional().describe("Contract authoring style"),
 	packageManager: PackageManagerSchema.optional().describe("Package manager used for dependency installation"),
-	deploy: z.boolean().optional().describe("Deploy the generated app to Prisma immediately")
+	deploy: z.boolean().optional().describe("Deploy the generated app to Prisma immediately"),
+	workspace: z.string().trim().min(1, "Please enter a valid workspace id or name").optional().describe("Prisma workspace id or name to deploy into")
 });
 const PrismaSetupCommandInputSchema = CommonCommandOptionsSchema.extend(PrismaSetupOptionsSchema.shape);
 const CreateScaffoldOptionsSchema = z.object({
@@ -611,6 +612,15 @@ function getErrorMessage(error) {
 	if (error instanceof Error) return redactSecrets(error.message);
 	return redactSecrets(String(error));
 }
+function stripResourcePrefix(id, prefix) {
+	const marker = `${prefix}_`;
+	return id.startsWith(marker) ? id.slice(marker.length) : id;
+}
+function getConsoleProjectUrl(workspaceId, projectId) {
+	const consoleWorkspaceId = stripResourcePrefix(workspaceId, "wksp");
+	const consoleProjectId = stripResourcePrefix(projectId, "proj");
+	return `https://console.prisma.io/${encodeURIComponent(consoleWorkspaceId)}/${encodeURIComponent(consoleProjectId)}`;
+}
 function parsePrismaCliEnvelope(output) {
 	const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).reverse();
 	for (const line of lines) try {
@@ -622,37 +632,49 @@ 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;
+async function ensureAuthentication(packageManager, projectDir, beforeInteractiveLogin) {
+	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",
 		"login"
 	]);
 	if (process.stdin.isTTY !== true) throw new Error(`Sign in first with ${loginCommand}, then run ${getRunScriptCommand(packageManager, "deploy")}.`);
+	beforeInteractiveLogin?.();
 	log.info("Sign in to Prisma to deploy.");
 	const login = getPrismaCliArgs(packageManager, ["auth", "login"]);
 	await execa(login.command, login.args, {
@@ -660,30 +682,180 @@ 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 workspaceLabel(workspace) {
+	return workspace.name ?? workspace.id;
+}
+async function useWorkspace(options) {
+	return (await runPrismaJsonCommand({
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
+		args: [
+			"auth",
+			"workspace",
+			"use",
+			options.workspace
+		]
+	})).workspace;
+}
+async function selectDeploymentWorkspace(options) {
+	const activeWorkspace = options.authState.workspace;
+	if (!activeWorkspace) throw new Error("The active Prisma credential does not specify a workspace.");
+	if (options.workspace) {
+		if (options.authState.source === "environment") {
+			if (options.workspace === activeWorkspace.id || options.workspace === activeWorkspace.name) return activeWorkspace;
+			throw new Error(`The environment credential is fixed to workspace ${workspaceLabel(activeWorkspace)}. Unset it before using --workspace ${options.workspace}.`);
+		}
+		return useWorkspace({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			workspace: options.workspace
+		});
+	}
+	if (!options.shouldPrompt || process.stdin.isTTY !== true) return activeWorkspace;
+	const available = await runPrismaJsonCommand({
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
+		args: [
+			"auth",
+			"workspace",
+			"list"
+		]
+	});
+	if (available.items.length <= 1) return activeWorkspace;
+	options.beforePrompt?.();
+	const selectedWorkspaceId = await select({
+		message: "Select Prisma workspace for deployment",
+		initialValue: activeWorkspace.id,
+		options: available.items.map((workspace) => ({
+			value: workspace.workspaceId,
+			label: workspace.workspaceName ?? workspace.workspaceId,
+			hint: workspace.current ? `${workspace.workspaceId}, current` : workspace.workspaceId
+		}))
+	});
+	if (isCancel(selectedWorkspaceId)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	options.afterPrompt?.();
+	if (selectedWorkspaceId === activeWorkspace.id) return activeWorkspace;
+	return useWorkspace({
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
+		workspace: selectedWorkspaceId
+	});
+}
+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: getConsoleProjectUrl(result.workspace.id, result.project.id)
+			}
+		};
+	} catch {
+		return;
+	}
 }
 async function deployWithComposer(options) {
 	const progress = options.verbose ? void 0 : spinner();
+	let progressRunning = false;
+	const showProgress = (message) => {
+		if (!progress) return;
+		if (progressRunning) progress.message(message);
+		else {
+			progress.start(message);
+			progressRunning = true;
+		}
+	};
+	const clearProgress = () => {
+		if (!progress || !progressRunning) return;
+		progress.clear();
+		progressRunning = false;
+	};
 	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, {
+		showProgress("Checking Prisma account...");
+		if (options.verbose) log.step("Checking Prisma account.");
+		const authState = await ensureAuthentication(options.packageManager, options.projectDir, clearProgress);
+		showProgress("Checking Prisma workspace...");
+		if (options.verbose) log.step("Checking Prisma workspace.");
+		const selectedWorkspace = await selectDeploymentWorkspace({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			shouldPrompt: options.shouldPromptForWorkspace,
+			authState,
+			beforePrompt: clearProgress,
+			afterPrompt: () => showProgress("Selecting Prisma workspace..."),
+			...options.workspace ? { workspace: options.workspace } : {}
+		});
+		if (!selectedWorkspace) return;
+		showProgress("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"
 		});
+		showProgress("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;
+		showProgress("Loading deployment details...");
+		const details = await getProjectDetails({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			appName
+		});
 		progress?.stop("Deployed to Prisma.");
+		progressRunning = false;
 		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 ?? selectedWorkspace;
+		return {
+			appName,
+			...deployment?.appUrl ? { appUrl: deployment.appUrl } : {},
+			...workspace ? { workspace } : {},
+			project: details?.project ?? { name: appName }
+		};
 	} catch (error) {
-		progress?.stop("Deployment failed.");
+		progress?.error("Deployment failed.");
+		progressRunning = false;
 		log.error(`Deploy failed: ${getErrorMessage(error)}`);
-		return false;
+		return;
 	}
 }
 
@@ -790,7 +962,9 @@ async function collectPrismaSetupContext(input, options = {}) {
 		databaseProvider,
 		authoring,
 		packageManager,
-		shouldDeploy
+		shouldDeploy,
+		shouldPromptForWorkspace: !useDefaults,
+		...input.workspace ? { workspace: input.workspace } : {}
 	};
 }
 function getCommandErrorMessage(error) {
@@ -870,6 +1044,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({
@@ -912,20 +1100,29 @@ 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;
+			shouldPromptForWorkspace: context.shouldPromptForWorkspace,
+			verbose: context.verbose,
+			...context.workspace ? { workspace: context.workspace } : {}
+		});
+		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;
 }
 
@@ -1167,7 +1364,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",
@@ -1181,7 +1378,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",
@@ -1207,7 +1404,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.d.mts

@@ -222,6 +222,7 @@ declare const CreateCommandInputSchema: z.ZodObject<{
     bun: "bun";
   }>>;
   deploy: z.ZodOptional<z.ZodBoolean>;
+  workspace: z.ZodOptional<z.ZodString>;
   name: z.ZodOptional<z.ZodString>;
   template: z.ZodOptional<z.ZodEnum<{
     minimal: "minimal";
@@ -260,6 +261,7 @@ declare const router: {
       bun: "bun";
     }>>;
     deploy: z.ZodOptional<z.ZodBoolean>;
+    workspace: z.ZodOptional<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
     template: z.ZodOptional<z.ZodEnum<{
       minimal: "minimal";

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-DO0KhezB.mjs";
+import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as PackageManagerSchema, r as CreateCommandInputSchema, t as runCreateCommand } from "./create-4KBOFn2z.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-next.37.204.1";
+const CLI_VERSION = "0.4.2-next.37.212.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-next.37.204.1",
+  "version": "0.4.2-next.37.212.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/astro/tsconfig.json

@@ -1,5 +1,8 @@
 {
   "extends": "astro/tsconfigs/strict",
+  "compilerOptions": {
+    "types": ["astro/client", "node"]
+  },
   "include": [".astro/types.d.ts", "**/*"],
   "exclude": ["dist"]
 }

package/templates/create/elysia/tsconfig.json

@@ -10,6 +10,7 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "outDir": "dist",
-    "rootDir": "."
+    "rootDir": ".",
+    "types": ["node"]
   }
 }

package/templates/create/hono/tsconfig.json

@@ -10,6 +10,7 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "outDir": "dist",
-    "rootDir": "."
+    "rootDir": ".",
+    "types": ["node"]
   }
 }

package/templates/create/minimal/tsconfig.json

@@ -8,7 +8,8 @@
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"]
   },
   "include": ["src/**/*.ts"]
 }

package/templates/create/nest/tsconfig.json

@@ -11,7 +11,8 @@
     "forceConsistentCasingInFileNames": true,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,
-    "outDir": "dist"
+    "outDir": "dist",
+    "types": ["node"]
   },
   "include": ["src/**/*.ts"]
 }

package/templates/create/next/tsconfig.json

@@ -14,6 +14,7 @@
     "isolatedModules": true,
     "jsx": "react-jsx",
     "incremental": true,
+    "types": ["node"],
     "plugins": [
       {
         "name": "next"

package/templates/create/nuxt/tsconfig.json

@@ -1,4 +1,7 @@
 {
+  "compilerOptions": {
+    "types": ["node"]
+  },
   "files": [],
   "references": [
     {

package/templates/create/svelte/tsconfig.json

@@ -10,7 +10,8 @@
     "skipLibCheck": true,
     "sourceMap": true,
     "strict": true,
-    "moduleResolution": "bundler"
+    "moduleResolution": "bundler",
+    "types": ["node"]
   }
   // Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
   // except $lib which is handled by https://svelte.dev/docs/kit/configuration#files

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

@@ -17,7 +17,7 @@
       "@/*": ["./src/*"]
     },
     "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "types": ["vite/client"]
+    "types": ["vite/client", "node"]
   },
   "include": ["src/**/*.ts", "src/**/*.tsx", "vite.config.ts"]
 }