@prisma/cli 3.0.0-dev.60.1 → 3.0.0-dev.61.1

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

@@ -32,6 +32,10 @@ async function maybeSetupBranchDatabase(context, provider, projectId, branch, op
 			warnings: warning ? [warning] : []
 		};
 	}
+	if (localSignal.unsupportedSchema) {
+		if (options.db === true) throw unsupportedBranchDatabaseSchemaError(localSignal.unsupportedSchema, branch.name, context);
+		return emptyBranchDatabaseSetupOutcome();
+	}
 	const hasSignal = hasBranchDatabaseSignal(localSignal) || Boolean(envState.previewDatabaseUrl);
 	if (options.db !== true) {
 		if (!hasSignal) return emptyBranchDatabaseSetupOutcome();
@@ -76,10 +80,10 @@ async function setupBranchDatabase(context, provider, projectId, branch, signal,
 				databaseUrl: database.databaseUrl,
 				directUrl: database.directUrl
 			}).catch((error) => {
-				throw schemaSetupFailedError(error, signal.schema, branch.name);
+				throw schemaSetupFailedError(error, signal.schema, branch.name, context.runtime.cwd);
 			});
 			emitBranchDatabaseProgress(context, "success", "Applied database schema");
-		} else skippedSchemaWarning = "No schema.prisma file was found. Branch database env vars were created, but schema setup was skipped.";
+		} else skippedSchemaWarning = "No supported Prisma schema source was found. Branch database env vars were created, but schema setup was skipped.";
 		const envVars = await upsertBranchDatabaseEnvVars(context, provider, projectId, branch, database, envState);
 		emitBranchDatabaseProgress(context, "success", `Added branch env override${envVars.length === 1 ? "" : "s"} ${envVars.join(", ")}`);
 		if (skippedSchemaWarning) {
@@ -96,6 +100,7 @@ async function setupBranchDatabase(context, provider, projectId, branch, signal,
 				envVars,
 				schema: schemaSetup ? {
 					command: schemaSetup.command,
+					source: schemaSetup.source,
 					path: schemaSetup.schemaPath
 				} : null
 			},
@@ -185,7 +190,7 @@ function hasInlineDatabaseEnvVars(envVars) {
 function maybeRenderBranchDatabaseSignal(context, branchName, signal, envState) {
 	if (context.flags.json || context.flags.quiet) return;
 	const rows = [
-		signal.schema ? `  Schema  ${path.relative(context.runtime.cwd, signal.schema.path) || "schema.prisma"}` : null,
+		signal.schema ? `  Schema  ${path.relative(context.runtime.cwd, signal.schema.path) || defaultSchemaSourcePath(signal.schema)}` : null,
 		signal.databaseUrlReferences.length > 0 ? `  Code    ${signal.databaseUrlReferences.slice(0, 3).join(", ")}` : null,
 		envState.previewDatabaseUrl ? "  Env     preview DATABASE_URL is inherited by this branch" : null
 	].filter((row) => Boolean(row));
@@ -207,7 +212,11 @@ function emptyBranchDatabaseSetupOutcome() {
 	};
 }
 function formatSchemaSetupCommand(command) {
-	return command === "migrate-deploy" ? "prisma migrate deploy" : "prisma db push";
+	switch (command) {
+		case "migrate-deploy": return "prisma migrate deploy";
+		case "db-push": return "prisma db push";
+		case "prisma-next-db-init": return "prisma-next db init";
+	}
 }
 function branchDatabaseSetupFailedError(summary, error, branchName) {
 	return new CliError({
@@ -257,7 +266,7 @@ function branchDatabaseCleanupFailedError(setupError, cleanupError, database, br
 		nextSteps: []
 	});
 }
-function schemaSetupFailedError(error, schema, branchName) {
+function schemaSetupFailedError(error, schema, branchName, cwd) {
 	return new CliError({
 		code: "SCHEMA_SETUP_FAILED",
 		domain: "app",
@@ -268,12 +277,39 @@ function schemaSetupFailedError(error, schema, branchName) {
 		meta: {
 			branch: branchName,
 			schemaPath: schema.path,
+			source: schema.kind,
 			command: schema.command
 		},
 		exitCode: 1,
-		nextSteps: [schema.command === "migrate-deploy" ? "npx --no-install prisma migrate deploy" : "npx --no-install prisma db push --skip-generate", `prisma-cli app deploy --branch ${formatCommandArgument(branchName)} --db`]
+		nextSteps: [...formatSchemaSetupNextSteps(schema, cwd), `prisma-cli app deploy --branch ${formatCommandArgument(branchName)} --db`]
 	});
 }
+function unsupportedBranchDatabaseSchemaError(schema, branchName, context) {
+	return usageError("Branch database setup is not available for this Prisma schema", `${path.relative(context.runtime.cwd, schema.path) || defaultUnsupportedSchemaSourcePath(schema)} targets ${formatUnsupportedSchemaTarget(schema.target)}, but --db creates Prisma Postgres databases.`, "Use project env commands to provide a database URL for this branch, or switch the Prisma schema source to PostgreSQL before using --db.", [`prisma-cli project env add DATABASE_URL=<value> --branch ${formatCommandArgument(branchName)}`, `prisma-cli app deploy --branch ${formatCommandArgument(branchName)}`], "app");
+}
+function formatSchemaSetupNextSteps(schema, cwd) {
+	const sourcePath = path.relative(cwd, schema.path) || defaultSchemaSourcePath(schema);
+	switch (schema.command) {
+		case "migrate-deploy": return [`npx --no-install prisma migrate deploy --schema ${formatCommandArgument(sourcePath)}`];
+		case "db-push": return [`npx --no-install prisma db push --schema ${formatCommandArgument(sourcePath)}`];
+		case "prisma-next-db-init": return [`npx --no-install prisma-next contract emit --config ${formatCommandArgument(sourcePath)}`, `npx --no-install prisma-next db init --config ${formatCommandArgument(sourcePath)} --db <DATABASE_URL>`];
+	}
+}
+function defaultSchemaSourcePath(schema) {
+	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
+}
+function defaultUnsupportedSchemaSourcePath(schema) {
+	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
+}
+function formatUnsupportedSchemaTarget(target) {
+	switch (target) {
+		case "cockroachdb": return "CockroachDB";
+		case "mongodb": return "MongoDB";
+		case "mysql": return "MySQL";
+		case "sqlite": return "SQLite";
+		case "sqlserver": return "SQL Server";
+	}
+}
 function formatDebugDetails(error) {
 	if (error instanceof Error) return error.stack ?? error.message;
 	return typeof error === "string" ? error : null;

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

@@ -10,6 +10,7 @@ const SKIPPED_DIRECTORIES = new Set([
 	".prisma",
 	".turbo",
 	".vercel",
+	".wrangler",
 	"build",
 	"coverage",
 	"dist",
@@ -37,29 +38,41 @@ async function inspectBranchDatabaseSignal(cwd, signal) {
 	const state = {
 		filesVisited: 0,
 		schemaCandidates: [],
+		prismaNextConfigCandidates: [],
 		databaseUrlReferences: []
 	};
 	await scanDirectory(cwd, cwd, 0, state, signal);
-	const schemaPath = selectSchemaPath(cwd, state.schemaCandidates);
-	const hasMigrations = schemaPath ? await hasMigrationsDirectory(path.dirname(schemaPath), signal) : false;
+	const prismaNextConfigs = await Promise.all(state.prismaNextConfigCandidates.map((configPath) => classifyPrismaNextConfig(configPath, signal)));
+	const supportedPrismaNextConfig = selectPrismaNextConfig(cwd, prismaNextConfigs, "supported");
+	const unsupportedPrismaNextConfig = selectPrismaNextConfig(cwd, prismaNextConfigs, "unsupported");
+	const selectedPrismaOrmSchema = await selectPrismaOrmSchema(cwd, state.schemaCandidates, signal);
+	const schema = supportedPrismaNextConfig ? {
+		kind: "prisma-next",
+		path: supportedPrismaNextConfig.path,
+		hasMigrations: false,
+		command: "prisma-next-db-init",
+		target: supportedPrismaNextConfig.target
+	} : selectedPrismaOrmSchema.schema;
 	return {
-		schema: schemaPath ? {
-			path: schemaPath,
-			hasMigrations,
-			command: hasMigrations ? "migrate-deploy" : "db-push"
-		} : null,
+		schema,
+		unsupportedSchema: schema ? null : unsupportedPrismaNextConfig ? {
+			kind: "prisma-next",
+			path: unsupportedPrismaNextConfig.path,
+			target: unsupportedPrismaNextConfig.target
+		} : selectedPrismaOrmSchema.unsupportedSchema,
 		databaseUrlReferences: state.databaseUrlReferences
 	};
 }
 function hasBranchDatabaseSignal(signal) {
+	if (signal.unsupportedSchema) return false;
 	return Boolean(signal.schema || signal.databaseUrlReferences.length > 0);
 }
 async function runBranchDatabaseSchemaSetup(options) {
-	const schemaPath = path.relative(options.context.runtime.cwd, options.schema.path) || "schema.prisma";
-	const args = buildPrismaSchemaCommandArgs(options.schema.command, schemaPath);
-	await runPrismaCommand({
+	const schemaPath = path.relative(options.context.runtime.cwd, options.schema.path) || defaultSchemaSourcePath(options.schema);
+	const commands = buildSchemaSetupCommands(options.schema, schemaPath, options.databaseUrl);
+	for (const command of commands) await runPrismaCommand({
 		context: options.context,
-		args,
+		...command,
 		env: {
 			DATABASE_URL: options.databaseUrl,
 			...options.directUrl ? { DIRECT_URL: options.directUrl } : {}
@@ -67,6 +80,7 @@ async function runBranchDatabaseSchemaSetup(options) {
 	});
 	return {
 		command: options.schema.command,
+		source: options.schema.kind,
 		schemaPath
 	};
 }
@@ -92,18 +106,57 @@ async function scanDirectory(cwd, directory, depth, state, signal) {
 		if (!entry.isFile()) continue;
 		state.filesVisited += 1;
 		if (entry.name === "schema.prisma") state.schemaCandidates.push(entryPath);
+		if (isPrismaNextConfigFile(entry.name)) state.prismaNextConfigCandidates.push(entryPath);
 		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);
 	}
 }
-function selectSchemaPath(cwd, candidates) {
+async function selectPrismaOrmSchema(cwd, candidates, signal) {
+	const sorted = sortByPreferredRelativePath(cwd, candidates, "schema.prisma");
+	for (const schemaPath of sorted) {
+		const target = await classifyPrismaOrmSchemaTarget(schemaPath, signal);
+		if (target === "postgresql" || target === "unknown") {
+			const hasMigrations = await hasMigrationsDirectory(path.dirname(schemaPath), signal);
+			return {
+				schema: {
+					kind: "prisma-orm",
+					path: schemaPath,
+					hasMigrations,
+					command: hasMigrations ? "migrate-deploy" : "db-push",
+					target
+				},
+				unsupportedSchema: null
+			};
+		}
+		return {
+			schema: null,
+			unsupportedSchema: {
+				kind: "prisma-orm",
+				path: schemaPath,
+				target
+			}
+		};
+	}
+	return {
+		schema: null,
+		unsupportedSchema: null
+	};
+}
+function selectPrismaNextConfig(cwd, candidates, mode) {
+	const matches = candidates.filter((candidate) => {
+		const isSupported = candidate.target === "postgresql" || candidate.target === "unknown";
+		return mode === "supported" ? isSupported : !isSupported;
+	});
+	return sortByPreferredRelativePath(cwd, matches.map((candidate) => candidate.path), "prisma-next.config.ts").map((candidatePath) => matches.find((candidate) => candidate.path === candidatePath)).find((candidate) => Boolean(candidate)) ?? null;
+}
+function sortByPreferredRelativePath(cwd, candidates, preferredRootFile) {
 	return candidates.map((candidate) => ({
 		absolute: candidate,
-		relative: path.relative(cwd, candidate) || "schema.prisma"
+		relative: path.relative(cwd, candidate) || preferredRootFile
 	})).sort((left, right) => {
-		if (left.relative === "schema.prisma") return -1;
-		if (right.relative === "schema.prisma") return 1;
+		if (left.relative === preferredRootFile) return -1;
+		if (right.relative === preferredRootFile) return 1;
 		return left.relative.length - right.relative.length || left.relative.localeCompare(right.relative);
-	})[0]?.absolute ?? null;
+	}).map((candidate) => candidate.absolute);
 }
 async function hasMigrationsDirectory(schemaDirectory, signal) {
 	signal.throwIfAborted();
@@ -116,36 +169,115 @@ async function hasMigrationsDirectory(schemaDirectory, signal) {
 		throw error;
 	}
 }
+async function classifyPrismaNextConfig(configPath, signal) {
+	const content = await readTextFileIfSmall(configPath, signal);
+	if (!content) return {
+		path: configPath,
+		target: "unknown"
+	};
+	if (content.includes("@prisma-next/postgres/config")) return {
+		path: configPath,
+		target: "postgresql"
+	};
+	if (content.includes("@prisma-next/mongo/config")) return {
+		path: configPath,
+		target: "mongodb"
+	};
+	if (content.includes("@prisma-next/sqlite/config")) return {
+		path: configPath,
+		target: "sqlite"
+	};
+	return {
+		path: configPath,
+		target: "unknown"
+	};
+}
+async function classifyPrismaOrmSchemaTarget(schemaPath, signal) {
+	switch ((await readTextFileIfSmall(schemaPath, signal))?.match(/\bprovider\s*=\s*"([^"]+)"/)?.[1] ?? null) {
+		case "postgresql": return "postgresql";
+		case "mongodb": return "mongodb";
+		case "mysql": return "mysql";
+		case "sqlite": return "sqlite";
+		case "sqlserver": return "sqlserver";
+		case "cockroachdb": return "cockroachdb";
+		default: return "unknown";
+	}
+}
 function shouldScanForDatabaseUrl(fileName) {
 	if (fileName === ".env" || fileName.startsWith(".env.")) return true;
 	return DATABASE_URL_SCAN_EXTENSIONS.has(path.extname(fileName));
 }
+function isPrismaNextConfigFile(fileName) {
+	if (!fileName.startsWith("prisma-next.config.")) return false;
+	return [
+		".cjs",
+		".cts",
+		".js",
+		".mjs",
+		".mts",
+		".ts"
+	].some((extension) => fileName.endsWith(extension));
+}
 async function fileContainsDatabaseUrl(filePath, signal) {
+	return (await readTextFileIfSmall(filePath, signal))?.includes("DATABASE_URL") ?? false;
+}
+async function readTextFileIfSmall(filePath, signal) {
 	signal.throwIfAborted();
-	if ((await stat(filePath)).size > MAX_TEXT_FILE_BYTES) return false;
-	return (await readFile(filePath, {
+	if ((await stat(filePath)).size > MAX_TEXT_FILE_BYTES) return null;
+	return readFile(filePath, {
 		encoding: "utf8",
 		signal
-	})).includes("DATABASE_URL");
-}
-function buildPrismaSchemaCommandArgs(command, schemaPath) {
-	if (command === "migrate-deploy") return [
-		"--no-install",
-		"prisma",
-		"migrate",
-		"deploy",
-		"--schema",
-		schemaPath
-	];
-	return [
-		"--no-install",
-		"prisma",
-		"db",
-		"push",
-		"--skip-generate",
-		"--schema",
-		schemaPath
-	];
+	});
+}
+function buildSchemaSetupCommands(schema, schemaPath, databaseUrl) {
+	if (schema.command === "migrate-deploy") return [{
+		args: [
+			"--no-install",
+			"prisma",
+			"migrate",
+			"deploy",
+			"--schema",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma migrate deploy"
+	}];
+	if (schema.command === "db-push") return [{
+		args: [
+			"--no-install",
+			"prisma",
+			"db",
+			"push",
+			"--schema",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma db push"
+	}];
+	return [{
+		args: [
+			"--no-install",
+			"prisma-next",
+			"contract",
+			"emit",
+			"--config",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma-next contract emit"
+	}, {
+		args: [
+			"--no-install",
+			"prisma-next",
+			"db",
+			"init",
+			"--config",
+			schemaPath,
+			"--db",
+			databaseUrl
+		],
+		displayCommand: "npx --no-install prisma-next db init"
+	}];
+}
+function defaultSchemaSourcePath(schema) {
+	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
 }
 async function runPrismaCommand(options) {
 	const shouldPipeOutput = !options.context.flags.json && !options.context.flags.quiet;
@@ -177,8 +309,8 @@ async function runPrismaCommand(options) {
 			signal
 		}));
 	});
-	if (exit.signal) throw new Error(`npx prisma was terminated by ${exit.signal}.`);
-	if (exit.code !== 0) throw new Error(`npx prisma exited with code ${exit.code ?? 1}.`);
+	if (exit.signal) throw new Error(`${options.displayCommand} was terminated by ${exit.signal}.`);
+	if (exit.code !== 0) throw new Error(`${options.displayCommand} exited with code ${exit.code ?? 1}.`);
 }
 //#endregion
 export { hasBranchDatabaseSignal, inspectBranchDatabaseSignal, runBranchDatabaseSchemaSetup };

package/dist/presenters/app.js

@@ -55,10 +55,17 @@ function renderBranchDatabaseDeploySummary(context, result) {
 		},
 		...result.branchDatabase.schema ? [{
 			label: "Schema",
-			value: result.branchDatabase.schema.command === "migrate-deploy" ? "prisma migrate deploy" : "prisma db push"
+			value: formatBranchDatabaseSchemaCommand(result.branchDatabase.schema.command)
 		}] : []
 	])];
 }
+function formatBranchDatabaseSchemaCommand(command) {
+	switch (command) {
+		case "migrate-deploy": return "prisma migrate deploy";
+		case "db-push": return "prisma db push";
+		case "prisma-next-db-init": return "prisma-next db init";
+	}
+}
 function formatDuration(durationMs) {
 	if (durationMs < 1e3) return `${durationMs}ms`;
 	return `${(durationMs / 1e3).toFixed(1)}s`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.60.1",
+  "version": "3.0.0-dev.61.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {