create-prisma 0.4.2-pr.34.109.1 → 0.4.2-pr.34.112.1

package/dist/cli.mjs

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

package/dist/{create-dRPbnGmA.mjs → create-D7XYRH3T.mjs}

@@ -1706,7 +1706,9 @@ async function executeCreateAddonSetupContext(params) {
 
 //#endregion
 //#region src/tasks/deploy-to-compute.ts
-const PRISMA_CLI_PACKAGE = "@prisma/cli@dev";
+const PRISMA_CLI_PACKAGE = "@prisma/cli@latest";
+const COMPUTE_DEPLOY_BRANCH = "main";
+const COMPUTE_ENV_ROLE = "production";
 const DEPLOY_OPTIONS_BY_TEMPLATE = {
 	hono: {
 		framework: "hono",
@@ -1720,12 +1722,15 @@ const DEPLOY_OPTIONS_BY_TEMPLATE = {
 	"tanstack-start": { framework: "tanstack-start" }
 };
 function getPrismaCliCommand(packageManager) {
-	return getPackageExecutionCommand(packageManager, [PRISMA_CLI_PACKAGE]);
+	return getPackageExecutionCommand(getPrismaCliExecutionPackageManager(packageManager), [PRISMA_CLI_PACKAGE]);
 }
 function runPrismaCli(packageManager, args, options = {}) {
-	const execution = getPackageExecutionArgs(packageManager, [PRISMA_CLI_PACKAGE, ...args]);
+	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, [
@@ -1752,85 +1757,6 @@ async function ensurePrismaCliAvailable(packageManager) {
 		return false;
 	}
 }
-async function fetchProjects(packageManager) {
-	const { stdout } = await runPrismaCli(packageManager, [
-		"project",
-		"list",
-		"--json"
-	], { stdio: "pipe" });
-	const parsed = parseProjectListJson(stdout);
-	if (!parsed) throw new Error("Failed to list Prisma projects: invalid command output");
-	if (!parsed.ok) throw new Error(getJsonErrorMessage(parsed.error, "Failed to list Prisma projects"));
-	return parsed.result.items.map((project) => ({
-		id: project.id,
-		name: project.name
-	}));
-}
-function parseProjectListJson(stdout) {
-	if (typeof stdout !== "string" || stdout.trim().length === 0) return null;
-	try {
-		return JSON.parse(stdout);
-	} catch {
-		return null;
-	}
-}
-async function promptForNewProjectName(defaultProjectName) {
-	const projectNameInput = await text({
-		message: "Prisma project name",
-		placeholder: defaultProjectName,
-		initialValue: defaultProjectName,
-		validate: (value) => {
-			if (!value || value.trim().length === 0) return "Project name is required";
-		}
-	});
-	if (isCancel(projectNameInput)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	return projectNameInput.trim();
-}
-async function promptForNewProjectTarget(defaultProjectName) {
-	const projectName = await promptForNewProjectName(defaultProjectName);
-	return projectName ? { createProjectName: projectName } : void 0;
-}
-async function collectProjectTarget(options) {
-	const projects = await fetchProjects(options.packageManager);
-	if (projects.length === 1) {
-		const only = projects[0];
-		const shouldUseExistingProject = await confirm({
-			message: `Use Prisma project ${only.name}?`,
-			initialValue: true
-		});
-		if (isCancel(shouldUseExistingProject)) {
-			cancel("Operation cancelled.");
-			return;
-		}
-		return shouldUseExistingProject ? { projectRef: only.id } : promptForNewProjectTarget(options.defaultProjectName);
-	}
-	if (projects.length > 1) {
-		const selection = await select({
-			message: "Select Prisma project",
-			options: [{
-				value: { type: "create" },
-				label: "Create new project"
-			}, ...projects.slice().sort((a, b) => a.name.localeCompare(b.name)).map((project) => ({
-				value: {
-					type: "existing",
-					project
-				},
-				label: project.name,
-				hint: project.id
-			}))]
-		});
-		if (isCancel(selection)) {
-			cancel("Operation cancelled.");
-			return;
-		}
-		return selection.type === "create" ? promptForNewProjectTarget(options.defaultProjectName) : { projectRef: selection.project.id };
-	}
-	log.info("No Prisma projects found.");
-	return promptForNewProjectTarget(options.defaultProjectName);
-}
 async function collectComputeDeployContext(input, options) {
 	if (!isComputeDeployableTemplate(options.template)) return null;
 	if (input.deploy === false) return null;
@@ -1863,43 +1789,15 @@ async function collectComputeDeployContext(input, options) {
 			return null;
 		}
 	}
-	let projectTarget;
-	try {
-		projectTarget = await collectProjectTarget({
-			packageManager: options.packageManager,
-			defaultProjectName: options.defaultServiceName
-		});
-	} catch (error) {
-		log.warn(`Could not list Prisma projects${error instanceof Error ? `: ${redactSecrets(error.message)}` : "."}`);
-		if (input.deploy === true) throw createExplicitDeployError("could not list Prisma projects", error);
-		return null;
-	}
-	if (!projectTarget) {
-		if (input.deploy === true) throw createExplicitDeployError("no Prisma project was selected or created");
-		return null;
-	}
-	const appNameInput = await text({
-		message: "App name",
-		placeholder: options.defaultServiceName,
-		initialValue: options.defaultServiceName,
-		validate: (value) => {
-			if (!value || value.trim().length === 0) return "App name is required";
-		}
-	});
-	if (isCancel(appNameInput)) {
-		cancel("Operation cancelled.");
-		return;
-	}
 	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 {
-		...projectTarget,
 		template: options.template,
 		packageManager: options.packageManager,
-		appName: appNameInput.trim(),
+		createProjectName: options.defaultServiceName,
 		framework: deployOptions.framework,
 		httpPort: deployOptions.httpPort
 	};
@@ -1908,6 +1806,15 @@ 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 parseDeployJson(stdout) {
+	return parsePrismaCliJson(stdout);
+}
+function parseProjectCreateJson(stdout) {
+	return parsePrismaCliJson(stdout);
+}
+function parseProjectEnvJson(stdout) {
+	return parsePrismaCliJson(stdout);
+}
+function parsePrismaCliJson(stdout) {
 	if (typeof stdout !== "string" || stdout.trim().length === 0) return null;
 	try {
 		return JSON.parse(stdout);
@@ -1939,29 +1846,95 @@ function toComputeDeployResult(data) {
 		branchName: data.result.branch.name
 	};
 }
+async function createComputeProjectForDeploy(params) {
+	const { stdout, exitCode } = await runPrismaCli(params.context.packageManager, [
+		"project",
+		"create",
+		params.context.createProjectName,
+		"--json",
+		"--yes"
+	], {
+		cwd: params.projectDir,
+		reject: false,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	const parsed = parseProjectCreateJson(stdout);
+	if (!parsed) throw new Error("Could not parse prisma project create output.");
+	if (exitCode !== 0 || !parsed.ok) throw createDeployError(parsed.ok ? "Prisma project create failed." : getJsonErrorMessage(parsed.error, "Prisma project create failed."));
+	return parsed.result.project.id;
+}
+async function writeComputeEnvironmentVariables(params) {
+	for (const [key, value] of Object.entries(params.envVars ?? {})) {
+		const commonArgs = [
+			`${key}=${value}`,
+			"--project",
+			params.projectRef,
+			"--role",
+			COMPUTE_ENV_ROLE,
+			"--json",
+			"--yes"
+		];
+		if ((await runProjectEnvCommand(params.context, params.projectDir, ["add", ...commonArgs])).ok) continue;
+		const updateResult = await runProjectEnvCommand(params.context, params.projectDir, ["update", ...commonArgs]);
+		if (!updateResult.ok) throw createDeployError(getJsonErrorMessage(updateResult.error, `Failed to configure ${key} for Prisma Compute.`));
+	}
+}
+async function runProjectEnvCommand(context, projectDir, args) {
+	const { stdout, exitCode } = await runPrismaCli(context.packageManager, [
+		"project",
+		"env",
+		...args
+	], {
+		cwd: projectDir,
+		reject: false,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	const parsed = parseProjectEnvJson(stdout);
+	if (!parsed) throw new Error("Could not parse prisma project env output.");
+	if (exitCode !== 0 && parsed.ok) return {
+		ok: false,
+		error: { message: "Prisma project env command failed." }
+	};
+	return parsed;
+}
 async function executeComputeDeployContext(params) {
+	const deploySpinner = spinner();
+	deploySpinner.start("Deploying to Prisma Compute...");
+	const envVars = params.envVars ?? {};
+	const shouldPreconfigureEnvVars = Object.keys(envVars).length > 0;
 	const args = [
 		"app",
 		"deploy",
 		"--json",
 		"--yes",
-		"--app",
-		params.context.appName,
 		"--framework",
-		params.context.framework
+		params.context.framework,
+		"--branch",
+		COMPUTE_DEPLOY_BRANCH
 	];
-	if (params.context.projectRef) args.push("--project", params.context.projectRef);
-	else if (params.context.createProjectName) args.push("--create-project", params.context.createProjectName);
-	else return {
-		ok: false,
-		cancelled: false,
-		error: /* @__PURE__ */ new Error("Deploy target is missing a Prisma project.")
-	};
-	if (params.context.httpPort) args.push("--http-port", String(params.context.httpPort));
-	for (const [key, value] of Object.entries(params.envVars ?? {})) args.push("--env", `${key}=${value}`);
-	const deploySpinner = spinner();
-	deploySpinner.start("Deploying to Prisma Compute...");
 	try {
+		if (shouldPreconfigureEnvVars) {
+			const projectRef = await createComputeProjectForDeploy({
+				context: params.context,
+				projectDir: params.projectDir
+			});
+			await writeComputeEnvironmentVariables({
+				context: params.context,
+				projectDir: params.projectDir,
+				projectRef,
+				envVars
+			});
+			args.push("--project", projectRef);
+		} else args.push("--create-project", params.context.createProjectName);
+		if (params.context.httpPort) args.push("--http-port", String(params.context.httpPort));
 		const { stdout, exitCode } = await runPrismaCli(params.context.packageManager, args, {
 			cwd: params.projectDir,
 			reject: false,
@@ -2051,7 +2024,7 @@ async function getAnonymousId() {
 }
 function getCommonProperties() {
 	return {
-		"cli-version": "0.4.2-pr.34.109.1",
+		"cli-version": "0.4.2-pr.34.112.1",
 		"node-version": process.version,
 		platform: process.platform,
 		arch: process.arch

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