@prisma/cli 3.0.0-beta.21 → 3.0.0-beta.22

package/dist/controllers/init.js

@@ -0,0 +1,491 @@
+import { detectPackageManagerSync } from "../lib/agent/package-manager.js";
+import { resolvePrismaCliPackageCommandFormatterSync } from "../lib/agent/cli-command.js";
+import { CliError, usageError } from "../shell/errors.js";
+import { canPrompt } from "../shell/runtime.js";
+import { confirmPrompt, isPromptCancelError, selectPrompt, textPrompt } from "../shell/prompt.js";
+import { readLocalResolutionPin } from "../lib/project/local-pin.js";
+import { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-project.js";
+import { runProjectLink } from "./project.js";
+import { detectDeployFramework } from "./app.js";
+import { execa } from "execa";
+import path from "node:path";
+import { writeFile } from "node:fs/promises";
+import { COMPUTE_CONFIG_FILENAME, COMPUTE_REGIONS, FRAMEWORKS, defaultHttpPortForBuildType, findComputeConfigCandidates, findComputeConfigDir, frameworkByKey, frameworkFromAlias, serializeComputeConfig } from "@prisma/compute-sdk/config";
+//#region src/controllers/init.ts
+async function runInit(context, flags) {
+	const cwd = context.runtime.cwd;
+	const signal = context.runtime.signal;
+	const formatCommand = resolvePrismaCliPackageCommandFormatterSync(cwd);
+	await requireNoExistingComputeConfig(cwd, signal);
+	const region = parseInitRegion(flags.region, formatCommand);
+	let framework = await resolveInitFramework(context, flags, formatCommand);
+	const name = await resolveInitAppName(cwd, flags.name, signal, formatCommand);
+	let httpPort = parseInitHttpPort(flags.httpPort, formatCommand) ?? {
+		value: defaultHttpPortForBuildType(frameworkByKey(framework.key).buildType),
+		source: "framework default"
+	};
+	const adjusted = await maybeAdjustSettings(context, framework, httpPort, { portExplicit: flags.httpPort !== void 0 });
+	framework = adjusted.framework;
+	httpPort = adjusted.httpPort;
+	const entry = await resolveInitEntry(cwd, framework, flags.entry, signal);
+	const settings = [
+		{
+			key: "app",
+			value: name.value,
+			source: name.source
+		},
+		{
+			key: "framework",
+			value: framework.displayName,
+			source: framework.source
+		},
+		...entry ? [{
+			key: "entry",
+			value: entry.value,
+			source: entry.source
+		}] : [],
+		{
+			key: "http port",
+			value: String(httpPort.value),
+			source: httpPort.source
+		},
+		...region ? [{
+			key: "region",
+			value: region,
+			source: "flag"
+		}] : []
+	];
+	renderInitSettingsPreview(context, settings);
+	const config = { app: {
+		name: name.value,
+		framework: framework.key,
+		httpPort: httpPort.value,
+		...entry ? { entry: entry.value } : {},
+		...region ? { region } : {}
+	} };
+	const configPath = path.join(cwd, COMPUTE_CONFIG_FILENAME);
+	let source = serializeComputeConfig(config);
+	if (framework.key === "custom") source += CUSTOM_BUILD_STUB;
+	signal.throwIfAborted();
+	try {
+		await writeFile(configPath, source, {
+			encoding: "utf8",
+			flag: "wx"
+		});
+	} catch (error) {
+		if (error.code === "EEXIST") throw initConfigExistsError(configPath);
+		throw error;
+	}
+	const warnings = [];
+	const types = await resolveInitTypes(context, flags, { onWarning: (message) => warnings.push(message) });
+	const link = await resolveInitLink(context, flags, {
+		onWarning: (message) => warnings.push(message),
+		formatCommand
+	});
+	const unlinked = link.status !== "linked" && link.status !== "already-linked";
+	const typesMissing = types.status !== "installed" && types.status !== "already-installed";
+	return {
+		command: "init",
+		result: {
+			configPath: COMPUTE_CONFIG_FILENAME,
+			directory: formatInitDirectory(cwd),
+			app: {
+				name: name.value,
+				framework: framework.key,
+				httpPort: httpPort.value,
+				...entry ? { entry: entry.value } : {},
+				...region ? { region } : {}
+			},
+			settings,
+			types,
+			link
+		},
+		warnings,
+		nextSteps: [
+			...typesMissing && types.installCommand ? [types.installCommand] : [],
+			formatCommand(["app", "deploy"]),
+			...unlinked ? [formatCommand(["project", "link"])] : []
+		]
+	};
+}
+/** Dev dependency that provides editor types for the generated config. */
+const COMPUTE_SDK_PACKAGE = "@prisma/compute-sdk";
+function packageAddCommand(packageManager) {
+	switch (packageManager) {
+		case "pnpm": return [
+			"pnpm",
+			"add",
+			"-D",
+			COMPUTE_SDK_PACKAGE
+		];
+		case "bun": return [
+			"bun",
+			"add",
+			"-d",
+			COMPUTE_SDK_PACKAGE
+		];
+		case "yarn": return [
+			"yarn",
+			"add",
+			"-D",
+			COMPUTE_SDK_PACKAGE
+		];
+		case "npm": return [
+			"npm",
+			"install",
+			"-D",
+			COMPUTE_SDK_PACKAGE
+		];
+	}
+}
+/**
+* Offers to install `@prisma/compute-sdk` as a devDependency so the generated
+* config's typed import resolves in the editor. Deploy resolves the import
+* without a local install, so every outcome short of success is a hint, never
+* a failure.
+*/
+async function resolveInitTypes(context, flags, hooks) {
+	const cwd = context.runtime.cwd;
+	let packageJson;
+	try {
+		packageJson = await readBunPackageJson(cwd, context.runtime.signal);
+	} catch (error) {
+		if (context.runtime.signal.aborted) throw error;
+		hooks.onWarning(`Skipped the ${COMPUTE_SDK_PACKAGE} types install: package.json could not be read (${error instanceof Error ? error.message.split("\n")[0] : String(error)}).`);
+		return {
+			status: "skipped",
+			package: COMPUTE_SDK_PACKAGE,
+			installCommand: null
+		};
+	}
+	if (hasComputeSdkDependency(packageJson)) return {
+		status: "already-installed",
+		package: COMPUTE_SDK_PACKAGE,
+		installCommand: null
+	};
+	const installCommand = packageAddCommand(detectPackageManagerSync(cwd) ?? "npm");
+	const installCommandText = installCommand.join(" ");
+	const state = (status) => ({
+		status,
+		package: COMPUTE_SDK_PACKAGE,
+		installCommand: installCommandText
+	});
+	if (!packageJson) return state("skipped");
+	if (flags.install === false) return state("skipped");
+	let shouldInstall = flags.install === true;
+	if (!shouldInstall) {
+		if (!canPrompt(context) || context.flags.yes) return state("skipped");
+		try {
+			shouldInstall = await confirmPrompt({
+				input: context.runtime.stdin,
+				output: context.output.stderr,
+				signal: context.runtime.signal,
+				message: `Install ${COMPUTE_SDK_PACKAGE} for config types? (${installCommandText})`,
+				initialValue: true
+			});
+		} catch (error) {
+			if (isPromptCancelError(error)) return state("declined");
+			throw error;
+		}
+		if (!shouldInstall) return state("declined");
+	}
+	const command = resolveInitInstallCommandOverride(context) ?? installCommand;
+	if (!context.flags.quiet && !context.flags.json) context.output.stderr.write(`Installing ${COMPUTE_SDK_PACKAGE}...\n`);
+	try {
+		const [executable, ...args] = command;
+		await execa(executable, args, {
+			cwd,
+			env: context.runtime.env,
+			cancelSignal: context.runtime.signal,
+			stdin: "ignore"
+		});
+		return state("installed");
+	} catch (error) {
+		if (context.runtime.signal.aborted) throw error;
+		const detail = error instanceof Error ? error.message.split("\n")[0] : String(error);
+		hooks.onWarning(`Installing ${COMPUTE_SDK_PACKAGE} failed: ${detail}. Install it later with ${installCommandText}.`);
+		return state("failed");
+	}
+}
+function hasComputeSdkDependency(packageJson) {
+	for (const group of [packageJson?.dependencies, packageJson?.devDependencies]) if (group && typeof group === "object" && COMPUTE_SDK_PACKAGE in group) return true;
+	return false;
+}
+/** Test hook: JSON array command that replaces the real package-manager install. */
+function resolveInitInstallCommandOverride(context) {
+	const raw = context.runtime.env.PRISMA_CLI_INIT_INSTALL_COMMAND;
+	if (!raw) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		return Array.isArray(parsed) && parsed.every((p) => typeof p === "string") ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+const CUSTOM_BUILD_STUB = `
+// framework "custom" deploys a prebuilt artifact. Add its build settings:
+// build: {
+//   command: "npm run build",
+//   outputDirectory: "dist",
+//   entrypoint: "server.js",
+// },
+`;
+async function requireNoExistingComputeConfig(cwd, signal) {
+	const configDir = await findComputeConfigDir(cwd, signal);
+	if (!configDir) return;
+	throw initConfigExistsError((await findComputeConfigCandidates(configDir, signal))[0] ?? configDir);
+}
+function initConfigExistsError(existingPath) {
+	return new CliError({
+		code: "INIT_CONFIG_EXISTS",
+		domain: "app",
+		summary: "A compute config already exists",
+		why: `${existingPath} already defines this repository's compute config, and init never overwrites or merges.`,
+		fix: "Edit the existing config instead, or delete it first if you want init to regenerate it.",
+		exitCode: 1,
+		nextSteps: [],
+		meta: { existingConfigPath: existingPath }
+	});
+}
+async function resolveInitFramework(context, flags, formatCommand) {
+	if (flags.framework) {
+		const framework = frameworkFromAlias(flags.framework.trim());
+		if (!framework) throw usageError("Unknown framework", `"${flags.framework}" is not a supported framework.`, `Pass one of: ${FRAMEWORKS.map((candidate) => candidate.key).join(", ")}.`, [formatCommand([
+			"init",
+			"--framework",
+			"hono"
+		])], "app");
+		return {
+			key: framework.key,
+			displayName: framework.displayName,
+			source: "flag"
+		};
+	}
+	const detected = await detectDeployFramework(context.runtime.cwd, context.runtime.signal);
+	if (detected) return {
+		key: detected.key,
+		displayName: detected.displayName,
+		source: detected.annotation
+	};
+	if (canPrompt(context) && !context.flags.yes) {
+		const key = await selectPrompt({
+			input: context.runtime.stdin,
+			output: context.output.stderr,
+			signal: context.runtime.signal,
+			message: "Which framework does this app use?",
+			choices: FRAMEWORKS.map((framework) => ({
+				label: framework.displayName,
+				value: framework.key
+			}))
+		});
+		return {
+			key,
+			displayName: frameworkByKey(key).displayName,
+			source: "selected"
+		};
+	}
+	throw new CliError({
+		code: "INIT_DETECTION_FAILED",
+		domain: "app",
+		summary: "No supported framework detected",
+		why: "The directory has none of the framework signals init detects from, and no --framework was passed.",
+		fix: `Pass --framework with one of: ${FRAMEWORKS.map((framework) => framework.key).join(", ")}.`,
+		exitCode: 1,
+		nextSteps: FRAMEWORKS.slice(0, 3).map((framework) => formatCommand([
+			"init",
+			"--framework",
+			framework.key
+		])),
+		meta: { frameworks: FRAMEWORKS.map((framework) => framework.key) }
+	});
+}
+async function resolveInitAppName(cwd, explicitName, signal, formatCommand) {
+	const trimmed = explicitName?.trim();
+	if (explicitName !== void 0 && !trimmed) throw usageError("App name required", "--name needs a non-empty value.", "Pass a non-empty app name.", [formatCommand([
+		"init",
+		"--name",
+		"api"
+	])], "app");
+	if (trimmed) return {
+		value: trimmed,
+		source: "flag"
+	};
+	const packageJson = await readBunPackageJson(cwd, signal);
+	const packageName = typeof packageJson?.name === "string" ? packageJson.name.trim() : "";
+	if (packageName) return {
+		value: packageName,
+		source: "package.json"
+	};
+	return {
+		value: path.basename(cwd),
+		source: "directory name"
+	};
+}
+function parseInitHttpPort(value, formatCommand) {
+	if (value === void 0) return;
+	const port = Number(value.trim());
+	if (!Number.isInteger(port) || port < 1 || port > 65535) throw usageError("Invalid HTTP port", "--http-port must be an integer between 1 and 65535.", "Pass a valid port.", [formatCommand([
+		"init",
+		"--http-port",
+		"3000"
+	])], "app");
+	return {
+		value: port,
+		source: "flag"
+	};
+}
+function parseInitRegion(value, formatCommand) {
+	if (value === void 0) return;
+	const trimmed = value.trim();
+	if (COMPUTE_REGIONS.includes(trimmed)) return trimmed;
+	throw usageError("Unknown region", `"${value}" is not a supported Compute region.`, `Pass one of: ${COMPUTE_REGIONS.join(", ")}.`, [formatCommand([
+		"init",
+		"--region",
+		"us-east-1"
+	])], "app");
+}
+async function resolveInitEntry(cwd, resolvedFramework, explicitEntry, signal) {
+	const framework = frameworkByKey(resolvedFramework.key);
+	const trimmed = explicitEntry?.trim();
+	if (!framework.usesEntrypoint) {
+		if (trimmed) throw usageError("--entry is not supported for this framework", `${resolvedFramework.displayName} derives its entrypoint from build output; --entry applies only to frameworks that run a source entrypoint (Bun, Hono).`, "Drop --entry, or pass an entrypoint framework with --framework.", [], "app");
+		return;
+	}
+	if (trimmed) return {
+		value: trimmed,
+		source: "flag"
+	};
+	const packageEntrypoint = readBunPackageEntrypoint(await readBunPackageJson(cwd, signal));
+	if (packageEntrypoint) return {
+		value: packageEntrypoint,
+		source: "package.json"
+	};
+}
+async function maybeAdjustSettings(context, framework, httpPort, options) {
+	if (!canPrompt(context) || context.flags.yes) return {
+		framework,
+		httpPort
+	};
+	if (!await confirmPrompt({
+		input: context.runtime.stdin,
+		output: context.output.stderr,
+		signal: context.runtime.signal,
+		message: `Adjust these settings? (${framework.displayName}, HTTP ${httpPort.value})`,
+		initialValue: false
+	})) return {
+		framework,
+		httpPort
+	};
+	const key = await selectPrompt({
+		input: context.runtime.stdin,
+		output: context.output.stderr,
+		signal: context.runtime.signal,
+		message: "Framework",
+		choices: FRAMEWORKS.map((candidate) => ({
+			label: candidate.key === framework.key ? `${candidate.displayName} (current)` : candidate.displayName,
+			value: candidate.key
+		}))
+	});
+	const nextFramework = key === framework.key ? framework : {
+		key,
+		displayName: frameworkByKey(key).displayName,
+		source: "selected"
+	};
+	const defaultPort = options.portExplicit ? httpPort.value : defaultHttpPortForBuildType(frameworkByKey(key).buildType);
+	const portText = await textPrompt({
+		input: context.runtime.stdin,
+		output: context.output.stderr,
+		signal: context.runtime.signal,
+		message: "HTTP port",
+		placeholder: String(defaultPort),
+		validate: (value) => {
+			if (!value?.trim()) return;
+			const port = Number(value.trim());
+			return Number.isInteger(port) && port >= 1 && port <= 65535 ? void 0 : "Enter a port between 1 and 65535.";
+		}
+	});
+	return {
+		framework: nextFramework,
+		httpPort: portText.trim() ? {
+			value: Number(portText.trim()),
+			source: "selected"
+		} : {
+			value: defaultPort,
+			source: options.portExplicit ? httpPort.source : "framework default"
+		}
+	};
+}
+function renderInitSettingsPreview(context, settings) {
+	if (context.flags.quiet || context.flags.json) return;
+	const keyWidth = Math.max(...settings.map((row) => row.key.length));
+	const valueWidth = Math.max(...settings.map((row) => row.value.length));
+	const lines = settings.map((row) => `  ${row.key.padEnd(keyWidth)}  ${row.value.padEnd(valueWidth)}  ${context.ui.dim(row.source)}`);
+	context.output.stderr.write(`${lines.join("\n")}\n\n`);
+}
+async function resolveInitLink(context, flags, hooks) {
+	const pin = await readLocalResolutionPin(context.runtime.cwd, context.runtime.signal);
+	if (pin.isOk() && pin.value.kind === "present") return {
+		status: "already-linked",
+		project: null
+	};
+	if (flags.link === false) return {
+		status: "skipped",
+		project: null
+	};
+	const explicitProject = flags.project?.trim();
+	let shouldLink = Boolean(explicitProject) || flags.link === true;
+	if (!shouldLink) {
+		if (!canPrompt(context) || context.flags.yes) return {
+			status: "skipped",
+			project: null
+		};
+		try {
+			shouldLink = await confirmPrompt({
+				input: context.runtime.stdin,
+				output: context.output.stderr,
+				signal: context.runtime.signal,
+				message: "Link this directory to a Prisma Project now?",
+				initialValue: true
+			});
+		} catch (error) {
+			if (isPromptCancelError(error)) return {
+				status: "declined",
+				project: null
+			};
+			throw error;
+		}
+		if (!shouldLink) return {
+			status: "declined",
+			project: null
+		};
+	}
+	try {
+		const linked = await runProjectLink(context, explicitProject || void 0);
+		return {
+			status: "linked",
+			project: {
+				id: linked.result.project.id,
+				name: linked.result.project.name
+			}
+		};
+	} catch (error) {
+		if (error instanceof CliError) {
+			if (isPromptCancelError(error)) return {
+				status: "declined",
+				project: null
+			};
+			hooks.onWarning(`Project link failed: ${error.summary}. Link later with ${hooks.formatCommand(["project", "link"])}.`);
+			return {
+				status: "failed",
+				project: null
+			};
+		}
+		throw error;
+	}
+}
+function formatInitDirectory(cwd) {
+	const basename = path.basename(cwd);
+	return basename ? `./${basename}` : ".";
+}
+//#endregion
+export { runInit };