@prisma/cli 3.0.0-dev.119.1 → 3.0.0-dev.121.1

package/dist/commands/init/index.js

@@ -8,7 +8,7 @@ import { Command, Option } from "commander";
 //#region src/commands/init/index.ts
 function createInitCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("init"), runtime), "init");
-	command.addOption(new Option("--framework <framework>", "Framework override; detected when omitted")).addOption(new Option("--entry <path>", "Source entrypoint for entrypoint frameworks (Bun, Hono)")).addOption(new Option("--http-port <port>", "HTTP port the app listens on")).addOption(new Option("--region <region>", "Region used when deploy creates the app")).addOption(new Option("--name <app-name>", "App name")).addOption(new Option("--link", "Link this directory to a Project")).addOption(new Option("--no-link", "Skip the Project link step")).addOption(new Option("--project <id-or-name>", "Project to link this directory to")).addOption(new Option("--install", "Install @prisma/compute-sdk for config types")).addOption(new Option("--no-install", "Skip the types install step"));
+	command.addOption(new Option("--framework <framework>", "Framework override; detected when omitted")).addOption(new Option("--entry <path>", "Source entrypoint for entrypoint frameworks (Bun, Hono)")).addOption(new Option("--http-port <port>", "HTTP port the app listens on")).addOption(new Option("--region <region>", "Region used when deploy creates the app")).addOption(new Option("--name <app-name>", "App name")).addOption(new Option("--link", "Link this directory to a Project")).addOption(new Option("--no-link", "Skip the Project link step")).addOption(new Option("--project <id-or-name>", "Project to link this directory to")).addOption(new Option("--install", "Install @prisma/compute-sdk for config types")).addOption(new Option("--no-install", "Skip the types install step")).addOption(new Option("--format <ts|json>", "Config file format: ts (default) writes prisma.compute.ts, json writes dependency-free prisma.compute.json; --format ts converts an existing prisma.compute.json"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const flags = options;
@@ -20,7 +20,8 @@ function createInitCommand(runtime) {
 			name: flags.name,
 			link: flags.link,
 			project: flags.project,
-			install: flags.install
+			install: flags.install,
+			format: flags.format
 		}), {
 			renderHuman: (context, descriptor, result) => renderInit(context, descriptor, result),
 			renderJson: (result) => serializeInit(result)

package/dist/controllers/init.js

@@ -9,14 +9,30 @@ 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";
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { COMPUTE_CONFIG_FILENAME, COMPUTE_CONFIG_JSON_FILENAME, COMPUTE_REGIONS, FRAMEWORKS, defaultHttpPortForBuildType, findComputeConfigCandidates, findComputeConfigDir, frameworkByKey, frameworkFromAlias, normalizeComputeConfig, serializeComputeConfig, serializeComputeConfigJson } 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 format = parseInitFormat(flags.format, formatCommand);
+	if (format.value === "json" && flags.install === true) throw usageError("--install does not apply to the JSON config format", `${COMPUTE_CONFIG_JSON_FILENAME} is a dependency-free static config; the ${COMPUTE_SDK_PACKAGE} devDependency exists only for ${COMPUTE_CONFIG_FILENAME} editor types.`, "Drop --install, or use the TypeScript format.", [formatCommand([
+		"init",
+		"--format",
+		"json"
+	])], "app");
+	const existingConfig = await findExistingComputeConfig(cwd, signal);
+	if (existingConfig) {
+		const solePath = existingConfig.candidates.length === 1 ? existingConfig.candidates[0] : void 0;
+		const soleIsJson = solePath !== void 0 && path.extname(solePath) === ".json";
+		if (soleIsJson && format.value === "typescript" && format.explicit) {
+			rejectConversionResolutionFlags(flags, formatCommand);
+			return runInitConversion(context, flags, solePath, formatCommand);
+		}
+		if (solePath && !soleIsJson && format.value === "json") throw initConvertUnsupportedError(solePath);
+		throw initConfigExistsError(existingConfig.candidates[0] ?? existingConfig.directory);
+	}
 	const region = parseInitRegion(flags.region, formatCommand);
 	let framework = await resolveInitFramework(context, flags, formatCommand);
 	const name = await resolveInitAppName(cwd, flags.name, signal, formatCommand);
@@ -27,6 +43,11 @@ async function runInit(context, flags) {
 	const adjusted = await maybeAdjustSettings(context, framework, httpPort, { portExplicit: flags.httpPort !== void 0 });
 	framework = adjusted.framework;
 	httpPort = adjusted.httpPort;
+	if (format.value === "json" && framework.key === "custom") throw usageError("Custom framework requires the TypeScript config format", "The custom framework needs build.outputDirectory and build.entrypoint, which init does not collect; the TypeScript format includes a commented build stub to complete, and strict JSON cannot carry it.", `Rerun without --format json and fill in the build stub, or write ${COMPUTE_CONFIG_JSON_FILENAME} by hand with a build object.`, [formatCommand([
+		"init",
+		"--framework",
+		"custom"
+	])], "app");
 	const entry = await resolveInitEntry(cwd, framework, flags.entry, signal);
 	const settings = [
 		{
@@ -63,9 +84,14 @@ async function runInit(context, flags) {
 		...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;
+	const configFilename = format.value === "json" ? COMPUTE_CONFIG_JSON_FILENAME : COMPUTE_CONFIG_FILENAME;
+	const configPath = path.join(cwd, configFilename);
+	let source;
+	if (format.value === "json") source = serializeComputeConfigJson(config);
+	else {
+		source = serializeComputeConfig(config);
+		if (framework.key === "custom") source += CUSTOM_BUILD_STUB;
+	}
 	signal.throwIfAborted();
 	try {
 		await writeFile(configPath, source, {
@@ -77,7 +103,11 @@ async function runInit(context, flags) {
 		throw error;
 	}
 	const warnings = [];
-	const types = await resolveInitTypes(context, flags, { onWarning: (message) => warnings.push(message) });
+	const types = format.value === "json" ? {
+		status: "skipped",
+		package: COMPUTE_SDK_PACKAGE,
+		installCommand: null
+	} : await resolveInitTypes(context, flags, { onWarning: (message) => warnings.push(message) });
 	const link = await resolveInitLink(context, flags, {
 		onWarning: (message) => warnings.push(message),
 		formatCommand
@@ -87,7 +117,9 @@ async function runInit(context, flags) {
 	return {
 		command: "init",
 		result: {
-			configPath: COMPUTE_CONFIG_FILENAME,
+			configPath: configFilename,
+			format: format.value,
+			converted: false,
 			directory: formatInitDirectory(cwd),
 			app: {
 				name: name.value,
@@ -230,10 +262,237 @@ const CUSTOM_BUILD_STUB = `
 //   entrypoint: "server.js",
 // },
 `;
-async function requireNoExistingComputeConfig(cwd, signal) {
+/**
+* Nearest existing compute config, searching from `cwd` up to the source
+* root. Init routes on this: refuse, convert, or proceed fresh.
+*/
+async function findExistingComputeConfig(cwd, signal) {
 	const configDir = await findComputeConfigDir(cwd, signal);
-	if (!configDir) return;
-	throw initConfigExistsError((await findComputeConfigCandidates(configDir, signal))[0] ?? configDir);
+	if (!configDir) return null;
+	return {
+		directory: configDir,
+		candidates: await findComputeConfigCandidates(configDir, signal)
+	};
+}
+function parseInitFormat(value, formatCommand) {
+	if (value === void 0) return {
+		value: "typescript",
+		explicit: false
+	};
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "ts" || normalized === "typescript") return {
+		value: "typescript",
+		explicit: true
+	};
+	if (normalized === "json") return {
+		value: "json",
+		explicit: true
+	};
+	throw usageError("Unknown config format", `"${value}" is not a supported config format.`, "Pass --format ts or --format json.", [formatCommand([
+		"init",
+		"--format",
+		"json"
+	])], "app");
+}
+/**
+* Conversion transports the existing config's values; it never re-resolves
+* settings. Refusing resolution flags beats silently ignoring them.
+*/
+function rejectConversionResolutionFlags(flags, formatCommand) {
+	const passed = [
+		flags.framework !== void 0 ? "--framework" : null,
+		flags.entry !== void 0 ? "--entry" : null,
+		flags.httpPort !== void 0 ? "--http-port" : null,
+		flags.name !== void 0 ? "--name" : null,
+		flags.region !== void 0 ? "--region" : null
+	].filter((flag) => flag !== null);
+	if (passed.length === 0) return;
+	throw usageError(`${passed.join(", ")} ${passed.length === 1 ? "does" : "do"} not apply when converting an existing config`, `--format ts with an existing ${COMPUTE_CONFIG_JSON_FILENAME} converts it as-is; settings are transported, never re-resolved.`, `Convert first, then edit ${COMPUTE_CONFIG_FILENAME} directly.`, [formatCommand([
+		"init",
+		"--format",
+		"ts"
+	])], "app");
+}
+function initConvertIncompleteError(jsonConfigPath, tsConfigPath) {
+	return new CliError({
+		code: "INIT_CONVERT_INCOMPLETE",
+		domain: "app",
+		summary: "Conversion left two config files behind",
+		why: `${path.basename(tsConfigPath)} was written but ${path.basename(jsonConfigPath)} could not be deleted, and rolling back the write also failed. Commands refuse to load a directory with two config files.`,
+		fix: `Delete one file by hand: keep ${path.basename(tsConfigPath)} to finish the conversion, or keep ${path.basename(jsonConfigPath)} to undo it.`,
+		exitCode: 1,
+		nextSteps: [],
+		meta: {
+			jsonConfigPath,
+			tsConfigPath
+		}
+	});
+}
+function initConvertUnsupportedError(existingPath) {
+	return new CliError({
+		code: "INIT_CONVERT_UNSUPPORTED",
+		domain: "app",
+		summary: "TypeScript configs do not convert to JSON",
+		why: `${existingPath} may contain imports, expressions, or comments that the static ${COMPUTE_CONFIG_JSON_FILENAME} format cannot express, so an automatic conversion would be lossy.`,
+		fix: `If the config is fully static, rewrite it by hand as ${COMPUTE_CONFIG_JSON_FILENAME} and delete ${path.basename(existingPath)}.`,
+		exitCode: 1,
+		nextSteps: [],
+		meta: { existingConfigPath: existingPath }
+	});
+}
+/**
+* The graduation path: an explicit `--format ts` with an existing
+* `prisma.compute.json` rewrites the same config as `prisma.compute.ts` and
+* deletes the JSON file, so a static config can grow into a programmatic one.
+* The values are transported, never re-resolved.
+*/
+async function runInitConversion(context, flags, jsonConfigPath, formatCommand) {
+	const cwd = context.runtime.cwd;
+	const signal = context.runtime.signal;
+	let parsed;
+	try {
+		parsed = JSON.parse(await readFile(jsonConfigPath, "utf8"));
+	} catch (error) {
+		if (signal.aborted) throw error;
+		throw initConvertInvalidError(jsonConfigPath, [error instanceof Error ? error.message.split("\n")[0] : String(error)]);
+	}
+	const config = stripJsonSchemaKey(parsed);
+	const normalized = normalizeComputeConfig(config, jsonConfigPath);
+	if (normalized.isErr()) throw initConvertInvalidError(jsonConfigPath, normalized.error.issues);
+	const loaded = normalized.value;
+	const tsConfigPath = path.join(loaded.configDir, COMPUTE_CONFIG_FILENAME);
+	const source = serializeComputeConfig(config);
+	signal.throwIfAborted();
+	try {
+		await writeFile(tsConfigPath, source, {
+			encoding: "utf8",
+			flag: "wx"
+		});
+	} catch (error) {
+		if (error.code === "EEXIST") throw initConfigExistsError(tsConfigPath);
+		throw error;
+	}
+	try {
+		await rm(jsonConfigPath);
+	} catch (error) {
+		try {
+			await rm(tsConfigPath, { force: true });
+		} catch {
+			throw initConvertIncompleteError(jsonConfigPath, tsConfigPath);
+		}
+		throw error;
+	}
+	const settings = conversionSettings(loaded);
+	renderInitSettingsPreview(context, settings);
+	const warnings = [];
+	const stepContext = withRuntimeCwd(context, loaded.configDir);
+	const types = await resolveInitTypes(stepContext, flags, { onWarning: (message) => warnings.push(message) });
+	const link = await resolveInitLink(stepContext, flags, {
+		onWarning: (message) => warnings.push(message),
+		formatCommand
+	});
+	const unlinked = link.status !== "already-linked" && link.status !== "linked";
+	const typesMissing = types.status !== "installed" && types.status !== "already-installed";
+	return {
+		command: "init",
+		result: {
+			configPath: path.relative(cwd, tsConfigPath) || COMPUTE_CONFIG_FILENAME,
+			format: "typescript",
+			converted: true,
+			directory: formatInitDirectory(loaded.configDir),
+			app: conversionApp(loaded),
+			settings,
+			types,
+			link
+		},
+		warnings,
+		nextSteps: [
+			...typesMissing && types.installCommand ? [types.installCommand] : [],
+			formatCommand(["app", "deploy"]),
+			...unlinked ? [formatCommand(["project", "link"])] : []
+		]
+	};
+}
+/** The same command context, acting from `cwd` instead of the invocation directory. */
+function withRuntimeCwd(context, cwd) {
+	if (path.resolve(context.runtime.cwd) === path.resolve(cwd)) return context;
+	return {
+		...context,
+		runtime: {
+			...context.runtime,
+			cwd
+		}
+	};
+}
+function stripJsonSchemaKey(parsed) {
+	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return parsed;
+	const { $schema: _schema, ...config } = parsed;
+	return config;
+}
+function initConvertInvalidError(jsonConfigPath, issues) {
+	return new CliError({
+		code: "COMPUTE_CONFIG_INVALID",
+		domain: "app",
+		summary: `Invalid ${path.basename(jsonConfigPath)}`,
+		why: issues.join(" "),
+		fix: `Fix ${path.basename(jsonConfigPath)} and rerun the conversion.`,
+		where: jsonConfigPath,
+		meta: {
+			configPath: jsonConfigPath,
+			issues
+		},
+		exitCode: 2,
+		nextSteps: []
+	});
+}
+/** Preview rows for a conversion; every value is sourced from the JSON file. */
+function conversionSettings(loaded) {
+	const target = loaded.kind === "single" ? loaded.targets[0] : void 0;
+	if (!target) return [];
+	const source = COMPUTE_CONFIG_JSON_FILENAME;
+	return [
+		...target.name ? [{
+			key: "app",
+			value: target.name,
+			source
+		}] : [],
+		...target.framework ? [{
+			key: "framework",
+			value: frameworkByKey(target.framework).displayName,
+			source
+		}] : [],
+		...target.entry ? [{
+			key: "entry",
+			value: target.entry,
+			source
+		}] : [],
+		...target.httpPort !== null ? [{
+			key: "http port",
+			value: String(target.httpPort),
+			source
+		}] : [],
+		...target.region ? [{
+			key: "region",
+			value: target.region,
+			source
+		}] : []
+	];
+}
+/**
+* App identity for the conversion result. Configs written by init pin all of
+* name, framework, and httpPort; hand-written configs that omit any of them
+* (or define multiple apps) report null instead of a partial identity.
+*/
+function conversionApp(loaded) {
+	const target = loaded.kind === "single" ? loaded.targets[0] : void 0;
+	if (!target?.name || !target.framework || target.httpPort === null) return null;
+	return {
+		name: target.name,
+		framework: target.framework,
+		httpPort: target.httpPort,
+		...target.entry ? { entry: target.entry } : {},
+		...target.region ? { region: target.region } : {}
+	};
 }
 function initConfigExistsError(existingPath) {
 	return new CliError({

package/dist/presenters/init.js

@@ -1,10 +1,11 @@
 import { resolvePrismaCliPackageCommandFormatterSync } from "../lib/agent/cli-command.js";
 import { renderNextSteps, renderSummaryLine } from "../shell/ui.js";
+import { COMPUTE_CONFIG_JSON_FILENAME } from "@prisma/compute-sdk/config";
 //#region src/presenters/init.ts
 function renderInit(context, _descriptor, result) {
 	const ui = context.ui;
 	const formatCommand = resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd);
-	const lines = [renderSummaryLine(ui, "success", `Wrote ${result.configPath}`)];
+	const lines = [renderSummaryLine(ui, "success", result.converted ? `Converted ${COMPUTE_CONFIG_JSON_FILENAME} to ${result.configPath}` : `Wrote ${result.configPath}`)];
 	if (result.types.status === "installed") lines.push(renderSummaryLine(ui, "success", `Installed ${result.types.package} (config types)`));
 	else if ((result.types.status === "skipped" || result.types.status === "declined") && result.types.installCommand) lines.push(`  ${ui.dim(`For editor types: ${result.types.installCommand}`)}`);
 	switch (result.link.status) {

package/dist/shell/command-meta.js

@@ -23,7 +23,7 @@ const DESCRIPTORS = [
 	{
 		id: "init",
 		path: ["prisma", "init"],
-		description: "Write a committed prisma.compute.ts for this app",
+		description: "Write a committed compute config for this app",
 		examples: (runtime) => agentCommandExamples(runtime, [
 			["init"],
 			[
@@ -33,6 +33,11 @@ const DESCRIPTORS = [
 				"--entry",
 				"src/index.ts"
 			],
+			[
+				"init",
+				"--format",
+				"json"
+			],
 			["init", "--no-link"]
 		])
 	},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.119.1",
+  "version": "3.0.0-dev.121.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.5.0",
-    "@prisma/compute-sdk": "0.31.0",
+    "@prisma/compute-sdk": "0.33.0",
     "@prisma/credentials-store": "^7.8.0",
     "@prisma/management-api-sdk": "^1.46.0",
     "better-result": "^2.9.2",