@prisma/cli 3.0.0-dev.97.1 → 8.0.0-rc.1

package/dist/lib/app/branch-database.js

@@ -1,8 +1,9 @@
-import { access, readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
+import { access, readFile, readdir, stat } from "node:fs/promises";
 //#region src/lib/app/branch-database.ts
 const SKIPPED_DIRECTORIES = new Set([
 	".git",
+	".agents",
 	".next",
 	".nuxt",
 	".output",
@@ -54,14 +55,18 @@ async function inspectBranchDatabaseSignal(cwd, signal) {
 	} : selectedPrismaOrmSchema.schema;
 	return {
 		schema,
-		unsupportedSchema: schema ? null : unsupportedPrismaNextConfig ? {
-			kind: "prisma-next",
-			path: unsupportedPrismaNextConfig.path,
-			target: unsupportedPrismaNextConfig.target
-		} : selectedPrismaOrmSchema.unsupportedSchema,
+		unsupportedSchema: schema ? null : toUnsupportedSchema(unsupportedPrismaNextConfig) ?? selectedPrismaOrmSchema.unsupportedSchema,
 		databaseUrlReferences: state.databaseUrlReferences
 	};
 }
+function toUnsupportedSchema(config) {
+	if (!config) return null;
+	return {
+		kind: "prisma-next",
+		path: config.path,
+		target: config.target
+	};
+}
 function hasBranchDatabaseSignal(signal) {
 	if (signal.unsupportedSchema) return false;
 	return Boolean(signal.schema || signal.databaseUrlReferences.length > 0);
@@ -69,29 +74,42 @@ function hasBranchDatabaseSignal(signal) {
 async function scanDirectory(cwd, directory, depth, state, signal) {
 	signal.throwIfAborted();
 	if (depth > MAX_SCAN_DEPTH || state.filesVisited >= MAX_SCAN_FILES) return;
-	let entries;
-	try {
-		entries = await readdir(directory, { withFileTypes: true });
-	} catch (error) {
-		if (error.code === "ENOENT") return;
-		throw error;
-	}
-	entries.sort((left, right) => left.name.localeCompare(right.name));
+	const entries = await readSortedDirectoryEntries(directory);
 	for (const entry of entries) {
 		signal.throwIfAborted();
 		if (state.filesVisited >= MAX_SCAN_FILES) return;
 		const entryPath = path.join(directory, entry.name);
-		if (entry.isDirectory()) {
-			if (!SKIPPED_DIRECTORIES.has(entry.name)) await scanDirectory(cwd, entryPath, depth + 1, state, signal);
+		if (isScannableDirectory(entry)) {
+			await scanDirectory(cwd, entryPath, depth + 1, state, signal);
 			continue;
 		}
 		if (!entry.isFile()) continue;
 		state.filesVisited += 1;
-		if (entry.name === "schema.prisma") state.schemaCandidates.push(entryPath);
-		if (isPrismaNextConfigFile(entry.name)) state.prismaNextConfigCandidates.push(entryPath);
+		recordSchemaCandidates(entry.name, entryPath, state);
 		if (state.databaseUrlReferences.length < MAX_DATABASE_URL_REFERENCE_FILES && shouldScanForDatabaseUrl(entry.name) && await fileContainsDatabaseUrl(entryPath, signal)) state.databaseUrlReferences.push(path.relative(cwd, entryPath) || entry.name);
 	}
 }
+async function readSortedDirectoryEntries(directory) {
+	let entries;
+	try {
+		entries = await readdir(directory, { withFileTypes: true });
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	return entries.sort((left, right) => compareCodeUnits(left.name, right.name));
+}
+function compareCodeUnits(left, right) {
+	if (left < right) return -1;
+	return left > right ? 1 : 0;
+}
+function isScannableDirectory(entry) {
+	return entry.isDirectory() && !SKIPPED_DIRECTORIES.has(entry.name);
+}
+function recordSchemaCandidates(fileName, filePath, state) {
+	if (fileName === "schema.prisma") state.schemaCandidates.push(filePath);
+	if (isPrismaNextConfigFile(fileName)) state.prismaNextConfigCandidates.push(filePath);
+}
 async function selectPrismaOrmSchema(cwd, candidates, signal) {
 	const sorted = sortByPreferredRelativePath(cwd, candidates, "schema.prisma");
 	for (const schemaPath of sorted) {
@@ -137,7 +155,7 @@ function sortByPreferredRelativePath(cwd, candidates, preferredRootFile) {
 	})).sort((left, right) => {
 		if (left.relative === preferredRootFile) return -1;
 		if (right.relative === preferredRootFile) return 1;
-		return left.relative.length - right.relative.length || left.relative.localeCompare(right.relative);
+		return left.relative.length - right.relative.length || compareCodeUnits(left.relative, right.relative);
 	}).map((candidate) => candidate.absolute);
 }
 async function hasMigrationsDirectory(schemaDirectory, signal) {
@@ -174,8 +192,9 @@ async function classifyPrismaNextConfig(configPath, signal) {
 		target: "unknown"
 	};
 }
+const SCHEMA_PROVIDER = /\bprovider\s*=\s*"([^"]+)"/;
 async function classifyPrismaOrmSchemaTarget(schemaPath, signal) {
-	switch ((await readTextFileIfSmall(schemaPath, signal))?.match(/\bprovider\s*=\s*"([^"]+)"/)?.[1] ?? null) {
+	switch ((await readTextFileIfSmall(schemaPath, signal))?.match(SCHEMA_PROVIDER)?.[1] ?? null) {
 		case "postgresql": return "postgresql";
 		case "mongodb": return "mongodb";
 		case "mysql": return "mysql";

package/dist/lib/app/build-settings.js

@@ -1,5 +1,5 @@
-import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { readFile } from "node:fs/promises";
 import { resolveBuildSettings, resolveConfiguredBuildSettings } from "@prisma/compute-sdk";
 //#region src/lib/app/build-settings.ts
 /** Legacy build-settings file: no longer read or written, only detected for migration. */
@@ -26,7 +26,7 @@ async function detectLegacyBuildSettings(options) {
 	let legacy;
 	try {
 		const parsed = JSON.parse(content);
-		const buildCommand = parsed.buildCommand === null || typeof parsed.buildCommand === "string" ? typeof parsed.buildCommand === "string" ? parsed.buildCommand.trim() || null : null : void 0;
+		const buildCommand = normalizeLegacyBuildCommand(parsed.buildCommand);
 		const outputDirectory = typeof parsed.outputDirectory === "string" ? normalizeRelativePath(parsed.outputDirectory) : void 0;
 		if (buildCommand === void 0 || !outputDirectory) return {
 			kind: "invalid",
@@ -80,10 +80,15 @@ async function resolveConfiguredAppBuildSettings(options) {
 		settings
 	};
 }
+const WINDOWS_DRIVE_PREFIX = /^[A-Za-z]:/;
+function normalizeLegacyBuildCommand(value) {
+	if (typeof value === "string") return value.trim() || null;
+	if (value === null) return null;
+}
 function normalizeRelativePath(value) {
 	const raw = value.trim().replace(/\\/g, "/");
 	if (raw.length === 0 || raw.split("/").includes("..")) return;
-	if (/^[A-Za-z]:/.test(raw)) return;
+	if (WINDOWS_DRIVE_PREFIX.test(raw)) return;
 	const normalized = path.posix.normalize(raw);
 	const segments = normalized.split("/");
 	if (path.win32.isAbsolute(value) || path.posix.isAbsolute(normalized) || segments.includes("..")) return;

package/dist/lib/app/build.js

@@ -1,18 +1,19 @@
-import "./build-settings.js";
-import "node:fs/promises";
 import "node:path";
+import "node:fs/promises";
+import { FRAMEWORKS } from "@prisma/compute-sdk/config";
 import { normalizeArtifactSymlinks, resolveBuildStrategy } from "@prisma/compute-sdk";
 //#region src/lib/app/build.ts
-const APP_BUILD_TYPES = [
-	"auto",
-	"bun",
-	"nextjs",
-	"nuxt",
-	"astro",
-	"nestjs",
-	"tanstack-start"
-];
-const RESOLVED_APP_BUILD_TYPES = APP_BUILD_TYPES.filter((buildType) => buildType !== "auto");
+const RESOLVED_APP_BUILD_TYPES = [...frameworkBuildTypesByLastOccurrence()];
+const APP_BUILD_TYPES = ["auto", ...RESOLVED_APP_BUILD_TYPES];
+const APP_BUILD_TYPE_LABELS = APP_BUILD_TYPES.join(", ");
+function frameworkBuildTypesByLastOccurrence() {
+	const buildTypes = /* @__PURE__ */ new Set();
+	for (const framework of FRAMEWORKS) {
+		if (buildTypes.has(framework.buildType)) buildTypes.delete(framework.buildType);
+		buildTypes.add(framework.buildType);
+	}
+	return buildTypes;
+}
 var AppBuildStrategy = class {
 	#appPath;
 	#entrypoint;
@@ -68,13 +69,14 @@ async function executeAppBuild(options) {
 	}
 }
 async function resolveAppBuildStrategy(options) {
+	const buildType = options.buildType === "auto" && options.entrypoint ? "bun" : options.buildType;
 	return resolveBuildStrategy({
 		appPath: options.appPath,
-		buildType: options.buildType,
+		buildType,
 		entrypoint: options.entrypoint,
 		buildSettings: options.buildSettings,
 		signal: options.signal
 	});
 }
 //#endregion
-export { APP_BUILD_TYPES, AppBuildStrategy, RESOLVED_APP_BUILD_TYPES, executeAppBuild };
+export { APP_BUILD_TYPES, APP_BUILD_TYPE_LABELS, AppBuildStrategy, RESOLVED_APP_BUILD_TYPES, executeAppBuild };

package/dist/lib/app/bun-project.js

@@ -1,5 +1,5 @@
-import { access, readFile } from "node:fs/promises";
 import path from "node:path";
+import { access, readFile } from "node:fs/promises";
 //#region src/lib/app/bun-project.ts
 async function readBunPackageJson(appPath, signal) {
 	const packageJsonPath = path.join(appPath, "package.json");

package/dist/lib/app/compute-config.js

@@ -1,6 +1,6 @@
-import { CliError } from "../../shell/errors.js";
-import { COMPUTE_CONFIG_FILENAME, COMPUTE_CONFIG_FILENAME as COMPUTE_CONFIG_FILENAME$1, ComputeConfigTargetRequiredError, computeTargetAppDir, frameworkByKey, inferComputeTargetFromCwd, loadComputeConfig, selectComputeDeployTarget } from "@prisma/compute-sdk/config";
+import { CliError } from "../../errors.js";
 import path from "node:path";
+import { COMPUTE_CONFIG_FILENAME, frameworkByKey, loadComputeConfig } from "@prisma/compute-sdk/config";
 import { matchError } from "better-result";
 //#region src/lib/app/compute-config.ts
 /**
@@ -18,47 +18,45 @@ function computeFrameworkToBuildType(framework) {
 function mergeComputeDeployInputs(options) {
 	const { cli, target, configFilename } = options;
 	const configAnnotation = `set by ${configFilename}`;
-	const framework = cli.framework ? {
-		value: cli.framework,
-		annotation: "set by --framework"
-	} : target?.framework ? {
-		value: target.framework,
-		annotation: configAnnotation
-	} : void 0;
-	const entrypoint = cli.entrypoint ? {
-		value: cli.entrypoint,
-		annotation: "set by --entry"
-	} : target?.entry ? {
-		value: target.entry,
-		annotation: configAnnotation
-	} : void 0;
-	const httpPort = cli.httpPort ? {
-		value: cli.httpPort,
-		annotation: "set by --http-port"
-	} : target?.httpPort ? {
-		value: String(target.httpPort),
-		annotation: configAnnotation
-	} : void 0;
+	const framework = mergeStringInput(cli.framework, "set by --framework", target?.framework ?? void 0, configAnnotation);
+	const entrypoint = mergeStringInput(cli.entrypoint, "set by --entry", target?.entry ?? void 0, configAnnotation);
+	const httpPort = mergeStringInput(cli.httpPort, "set by --http-port", target?.httpPort ? String(target.httpPort) : void 0, configAnnotation);
+	const region = mergeStringInput(cli.region, "set by --region", target?.region ?? void 0, configAnnotation);
 	const cliEnvInputs = cli.envInputs && cli.envInputs.length > 0 ? cli.envInputs : void 0;
 	const configEnvInputs = target && target.envInputs.length > 0 ? target.envInputs : void 0;
 	const envInputs = cliEnvInputs ?? configEnvInputs;
-	const configAppName = target?.name ? {
-		value: target.name,
-		annotation: configAnnotation
-	} : target?.key ? {
-		value: target.key,
-		annotation: configAnnotation
-	} : void 0;
+	const configAppName = readConfigAppName(target, configAnnotation);
 	return {
 		framework,
 		entrypoint,
 		httpPort,
+		region,
 		envInputs,
 		envInputsFromConfig: !cliEnvInputs && configEnvInputs !== void 0,
 		configAppName,
 		appRoot: target?.root ?? void 0
 	};
 }
+function mergeStringInput(cliValue, cliAnnotation, configValue, configAnnotation) {
+	if (cliValue !== void 0) return {
+		value: cliValue,
+		annotation: cliAnnotation
+	};
+	if (configValue) return {
+		value: configValue,
+		annotation: configAnnotation
+	};
+}
+function readConfigAppName(target, configAnnotation) {
+	if (target?.name) return {
+		value: target.name,
+		annotation: configAnnotation
+	};
+	if (target?.key) return {
+		value: target.key,
+		annotation: configAnnotation
+	};
+}
 /**
 * Merges CLI inputs for the local `app build` and `app run` commands with a
 * selected config target. Explicit flags win; `--build-type auto` is the
@@ -144,4 +142,4 @@ function computeConfigErrorToCliError(error, commandName = "deploy") {
 	});
 }
 //#endregion
-export { COMPUTE_CONFIG_FILENAME$1 as COMPUTE_CONFIG_FILENAME, ComputeConfigTargetRequiredError, computeConfigErrorToCliError, computeFrameworkToBuildType, computeTargetAppDir, inferComputeTargetFromCwd, loadComputeConfig$1 as loadComputeConfig, mergeComputeDeployInputs, mergeComputeLocalInputs, selectComputeDeployTarget };
+export { computeConfigErrorToCliError, computeFrameworkToBuildType, loadComputeConfig$1 as loadComputeConfig, mergeComputeDeployInputs, mergeComputeLocalInputs };

package/dist/lib/app/deploy-plan.js

@@ -30,6 +30,7 @@ function perAppInputsForDeployAll(inputs) {
 		["--framework", inputs.framework],
 		["--entry", inputs.entrypoint],
 		["--http-port", inputs.httpPort],
+		["--region", inputs.region],
 		["--env", inputs.envAssignments?.length ? inputs.envAssignments : void 0],
 		[inputs.appIdEnvVar.name, inputs.appIdEnvVar.value]
 	].filter(([, value]) => value !== void 0).map(([flag]) => flag);

package/dist/lib/app/deploy-progress.js

@@ -6,7 +6,7 @@ function createDeployProgressState() {
 		buildCompleted: false,
 		archiveReady: false,
 		uploadCompleted: false,
-		versionId: null,
+		deploymentId: null,
 		startRequested: false,
 		containerLive: false,
 		deploymentUrl: null,
@@ -39,8 +39,8 @@ function createDeployProgress(output, ui, enabled, state = createDeployProgressS
 		onUploadStart() {
 			write("Uploading...");
 		},
-		onVersionCreated(versionId) {
-			state.versionId = versionId;
+		onDeploymentCreated(deploymentId) {
+			state.deploymentId = deploymentId;
 		},
 		onUploadComplete() {
 			state.uploadCompleted = true;
@@ -69,16 +69,16 @@ function createPromoteProgress(output, enabled) {
 		output.write(`${line}\n`);
 	};
 	return {
-		onVersionStarting(versionId) {
-			write(`Starting deployment ${versionId}...`);
+		onDeploymentStarting(deploymentId) {
+			write(`Starting deployment ${deploymentId}...`);
 		},
-		onVersionStartRequested() {
+		onDeploymentStartRequested() {
 			write("Requesting deployment start...");
 		},
 		onStatusChange(status) {
 			write(`Status: ${status}`);
 		},
-		onVersionRunning() {
+		onDeploymentRunning() {
 			write("Deployment is running.");
 		},
 		onPromoteStart() {

package/dist/lib/app/env-config.js

@@ -1,4 +1,4 @@
-import { usageError } from "../../shell/errors.js";
+import { usageError } from "../../errors.js";
 //#region src/lib/app/env-config.ts
 const VALID_ROLES = new Set(["production", "preview"]);
 function positionalHint(command) {

package/dist/lib/app/env-file.js

@@ -1,7 +1,7 @@
-import { usageError } from "../../shell/errors.js";
+import { usageError } from "../../errors.js";
 import { validateKey } from "./env-config.js";
-import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { readFile } from "node:fs/promises";
 import { parse } from "dotenv";
 //#region src/lib/app/env-file.ts
 const ASSIGNMENT_KEY_PATTERN = /^\s*(?:export\s+)?([^#=\s]+)\s*=/;

package/dist/lib/app/env-vars.js

@@ -1,4 +1,4 @@
-import { usageError } from "../../shell/errors.js";
+import { usageError } from "../../errors.js";
 import { validateKey } from "./env-config.js";
 import { readEnvFileAssignments } from "./env-file.js";
 //#region src/lib/app/env-vars.ts

package/dist/lib/app/local-dev.js

@@ -1,6 +1,6 @@
 import { resolveBunEntrypoint } from "./bun-project.js";
-import "node:fs/promises";
 import path from "node:path";
+import "node:fs/promises";
 import { spawn } from "node:child_process";
 //#region src/lib/app/local-dev.ts
 const DEFAULT_LOCAL_DEV_PORT = 3e3;

package/dist/lib/app/production-deploy-gate.js

@@ -1,6 +1,6 @@
-import { CliError } from "../../shell/errors.js";
-import { confirmPrompt } from "../../shell/prompt.js";
+import { CliError } from "../../errors.js";
 import { canPrompt } from "../../shell/runtime.js";
+import { confirmPrompt } from "../../shell/prompt.js";
 //#region src/lib/app/production-deploy-gate.ts
 async function enforceProductionDeployGate(context, provider, options) {
 	if (options.branchKind !== "production") return { firstProductionDeploy: false };
@@ -25,6 +25,7 @@ async function enforceProductionDeployGate(context, provider, options) {
 	if (!await confirmPrompt({
 		input: context.runtime.stdin,
 		output: context.output.stderr,
+		signal: context.runtime.signal,
 		message: "Deploy to production?",
 		initialValue: false
 	})) throw productionDeployCancelledError();

package/dist/lib/bucket/provider.js

@@ -0,0 +1,139 @@
+import { CliError } from "../../errors.js";
+//#region src/lib/bucket/provider.ts
+function createManagementBucketProvider(client) {
+	return {
+		async listBuckets(options) {
+			const buckets = [];
+			let cursor;
+			while (true) {
+				const result = await client.GET("/v1/buckets", {
+					params: { query: {
+						projectId: options.projectId,
+						branchGitName: options.branchName,
+						cursor
+					} },
+					signal: options.signal
+				});
+				if (result.error || !result.data) throw bucketApiError("Failed to list buckets", result.response, result.error);
+				const data = result.data;
+				buckets.push(...data.data);
+				if (!data.pagination.hasMore || !data.pagination.nextCursor) break;
+				cursor = data.pagination.nextCursor;
+			}
+			return buckets.map(normalizeBucket);
+		},
+		async createBucket(options) {
+			const result = await client.POST("/v1/buckets", {
+				body: {
+					projectId: options.projectId,
+					...options.name ? { name: options.name } : {},
+					...options.branchGitName ? { branchGitName: options.branchGitName } : {}
+				},
+				signal: options.signal
+			});
+			if (result.error || !result.data) throw bucketApiError("Failed to create bucket", result.response, result.error);
+			const data = result.data;
+			return normalizeBucket(data.data);
+		},
+		async deleteBucket(bucketId, options) {
+			const result = await client.DELETE("/v1/buckets/{bucketId}", {
+				params: { path: { bucketId } },
+				signal: options?.signal
+			});
+			if (result.error) throw bucketApiError("Failed to delete bucket", result.response, result.error);
+		},
+		async listKeys(bucketId, options) {
+			const keys = [];
+			let cursor;
+			while (true) {
+				const result = await client.GET("/v1/buckets/{bucketId}/keys", {
+					params: {
+						path: { bucketId },
+						query: { cursor }
+					},
+					signal: options?.signal
+				});
+				if (result.error || !result.data) throw bucketApiError("Failed to list bucket keys", result.response, result.error);
+				const data = result.data;
+				keys.push(...data.data);
+				if (!data.pagination.hasMore || !data.pagination.nextCursor) break;
+				cursor = data.pagination.nextCursor;
+			}
+			return keys.map(normalizeKey);
+		},
+		async createKey(options) {
+			const result = await client.POST("/v1/buckets/{bucketId}/keys", {
+				params: { path: { bucketId: options.bucketId } },
+				body: {
+					role: options.role,
+					...options.name ? { name: options.name } : {}
+				},
+				signal: options.signal
+			});
+			if (result.error || !result.data) throw bucketApiError("Failed to create bucket key", result.response, result.error);
+			const raw = result.data.data;
+			const secretAccessKey = raw.secretAccessKey;
+			const accessKeyId = raw.accessKeyId;
+			const endpoint = raw.endpoint;
+			const bucketName = raw.bucketName;
+			if (!secretAccessKey || !accessKeyId || !endpoint || !bucketName) throw new CliError({
+				code: "BUCKET_KEY_SECRET_MISSING",
+				domain: "bucket",
+				summary: "Created bucket key did not return credentials",
+				why: "Bucket key credentials are one-time-view secrets, but the Management API did not include them in this create response.",
+				fix: "Create another bucket key and store the returned credentials immediately.",
+				exitCode: 1,
+				nextSteps: [`prisma-cli bucket key create ${options.bucketId}`]
+			});
+			return {
+				key: normalizeKey(raw),
+				secretAccessKey,
+				accessKeyId,
+				endpoint,
+				bucketName
+			};
+		},
+		async deleteKey(bucketId, keyId, options) {
+			const result = await client.DELETE("/v1/buckets/{bucketId}/keys/{keyId}", {
+				params: { path: {
+					bucketId,
+					keyId
+				} },
+				signal: options?.signal
+			});
+			if (result.error) throw bucketApiError("Failed to delete bucket key", result.response, result.error);
+		}
+	};
+}
+function normalizeBucket(raw) {
+	return {
+		id: raw.id,
+		name: raw.name,
+		status: raw.status,
+		branchId: raw.branchId,
+		createdAt: raw.createdAt
+	};
+}
+function normalizeKey(raw) {
+	return {
+		id: raw.id,
+		name: raw.name,
+		role: raw.role,
+		valueHint: raw.valueHint,
+		createdAt: raw.createdAt
+	};
+}
+function bucketApiError(summary, response, error) {
+	const status = response?.status ?? 0;
+	return new CliError({
+		code: error?.error?.code ?? "BUCKET_API_ERROR",
+		domain: "bucket",
+		summary,
+		why: error?.error?.message ?? `The Management API returned status ${status || "unknown"}.`,
+		fix: error?.error?.hint ?? "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+//#endregion
+export { createManagementBucketProvider };