@prisma/cli 3.0.0-beta.2 → 3.0.0-beta.20

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

@@ -0,0 +1,102 @@
+//#region src/lib/app/branch-database-api.ts
+async function createBranchDatabase(client, options) {
+	const result = await client.POST("/v1/databases", {
+		body: {
+			projectId: options.projectId,
+			branchId: options.branchId,
+			name: options.branchName,
+			source: { type: "empty" }
+		},
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError(`Failed to create database for branch "${options.branchName}"`, result.response, result.error);
+	return normalizeBranchDatabaseRecord(result.data.data);
+}
+async function listEnvironmentVariables(client, options) {
+	const variables = [];
+	let cursor;
+	while (true) {
+		const result = await client.GET("/v1/environment-variables", {
+			params: { query: {
+				projectId: options.projectId,
+				class: options.className,
+				key: options.key,
+				branchId: options.branchId,
+				cursor
+			} },
+			signal: options.signal
+		});
+		if (result.error || !result.data) throw apiCallError("Failed to list environment variables", result.response, result.error);
+		variables.push(...result.data.data);
+		if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
+		cursor = result.data.pagination.nextCursor;
+	}
+	return variables.map((variable) => normalizeEnvironmentVariable(variable));
+}
+async function createEnvironmentVariable(client, options) {
+	const result = await client.POST("/v1/environment-variables", {
+		body: {
+			projectId: options.projectId,
+			class: options.className,
+			key: options.key,
+			value: options.value,
+			...options.branchId ? { branchId: options.branchId } : {}
+		},
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError(`Failed to add ${options.key}`, result.response, result.error);
+	return normalizeEnvironmentVariable(result.data.data);
+}
+async function deleteBranchDatabase(client, options) {
+	const result = await client.DELETE("/v1/databases/{databaseId}", {
+		params: { path: { databaseId: options.databaseId } },
+		signal: options.signal
+	});
+	if (result.error) throw apiCallError("Failed to delete branch database", result.response, result.error);
+}
+async function updateEnvironmentVariable(client, options) {
+	const result = await client.PATCH("/v1/environment-variables/{envVarId}", {
+		params: { path: { envVarId: options.envVarId } },
+		body: { value: options.value },
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError("Failed to update environment variable", result.response, result.error);
+	return normalizeEnvironmentVariable(result.data.data);
+}
+async function deleteEnvironmentVariable(client, options) {
+	const result = await client.DELETE("/v1/environment-variables/{envVarId}", {
+		params: { path: { envVarId: options.envVarId } },
+		signal: options.signal
+	});
+	if (result.error) throw apiCallError("Failed to delete environment variable", result.response, result.error);
+}
+function normalizeEnvironmentVariable(variable) {
+	return {
+		id: variable.id,
+		key: variable.key,
+		branchId: variable.branchId,
+		className: variable.class,
+		isManagedBySystem: variable.isManagedBySystem
+	};
+}
+function normalizeBranchDatabaseRecord(database) {
+	const connection = database.connections?.[0];
+	const databaseUrl = connection?.endpoints?.pooled?.connectionString;
+	const directUrl = connection?.endpoints?.direct?.connectionString ?? null;
+	if (!databaseUrl) throw new Error("Created database did not return a pooled connection string.");
+	return {
+		id: database.id,
+		name: database.name,
+		branchId: database.branchId,
+		databaseUrl,
+		directUrl
+	};
+}
+function apiCallError(summary, response, error) {
+	if (response.status === 404) return /* @__PURE__ */ new Error("Resource Not Found");
+	const message = error.error?.message ?? `Management API returned HTTP ${response.status}.`;
+	const hint = error.error?.hint ? ` ${error.error.hint}` : "";
+	return /* @__PURE__ */ new Error(`${summary}: ${message}${hint}`);
+}
+//#endregion
+export { createBranchDatabase, createEnvironmentVariable, deleteBranchDatabase, deleteEnvironmentVariable, listEnvironmentVariables, updateEnvironmentVariable };

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

@@ -0,0 +1,326 @@
+import { formatCommandArgument } from "../../shell/command-arguments.js";
+import { CliError, usageError } from "../../shell/errors.js";
+import { renderSummaryLine } from "../../shell/ui.js";
+import { canPrompt } from "../../shell/runtime.js";
+import { confirmPrompt } from "../../shell/prompt.js";
+import "../project/setup.js";
+import { hasBranchDatabaseSignal, inspectBranchDatabaseSignal } from "./branch-database.js";
+import path from "node:path";
+//#region src/lib/app/branch-database-deploy.ts
+async function maybeSetupBranchDatabase(context, provider, projectId, branch, options) {
+	if (options.db === false) return emptyBranchDatabaseSetupOutcome();
+	if (hasProvidedDatabaseEnvVars(options.providedEnvVars)) {
+		if (options.db === true) throw usageError("Database setup cannot be combined with provided database env vars", "The deploy command received --db and a DATABASE_URL or DIRECT_URL value from --env.", "Remove the --env database value to let --db create and wire a database, or remove --db to deploy with the provided value.", ["prisma-cli app deploy --db", "prisma-cli app deploy --env DATABASE_URL=postgresql://example"], "app");
+		return emptyBranchDatabaseSetupOutcome();
+	}
+	if (branch.kind === "production" && !options.firstProductionDeploy) {
+		if (options.db === true) throw productionDatabaseSetupAfterFirstDeployError();
+		return emptyBranchDatabaseSetupOutcome();
+	}
+	const envState = await inspectBranchDatabaseEnv(provider, projectId, branch, context.runtime.signal);
+	const targetEnvVars = getTargetDatabaseEnvVarKeys(envState);
+	if (hasExistingDatabaseEnvForTarget(branch, envState)) {
+		const warning = options.db === true ? existingDatabaseEnvWarning(branch, targetEnvVars) : null;
+		if (warning) emitBranchDatabaseWarning(context, warning);
+		return {
+			result: options.db === true ? {
+				status: "skipped",
+				reason: existingDatabaseEnvReason(branch),
+				envVars: targetEnvVars
+			} : void 0,
+			warnings: warning ? [warning] : []
+		};
+	}
+	const localSignal = await inspectBranchDatabaseSignal(options.projectDir, context.runtime.signal);
+	if (localSignal.unsupportedSchema) {
+		if (options.db === true) throw unsupportedBranchDatabaseSchemaError(localSignal.unsupportedSchema, branch, context);
+		return emptyBranchDatabaseSetupOutcome();
+	}
+	const hasSignal = hasBranchDatabaseSignal(localSignal) || Boolean(envState.inheritedPreviewDatabaseUrl);
+	if (options.db !== true) {
+		if (!hasSignal) return emptyBranchDatabaseSetupOutcome();
+		if (!canPrompt(context) || context.flags.yes) {
+			const warning = databasePromptSuppressedWarning(branch);
+			emitBranchDatabaseWarning(context, warning);
+			return {
+				result: void 0,
+				warnings: [warning]
+			};
+		}
+		maybeRenderBranchDatabaseSignal(context, branch, localSignal, envState);
+		if (!await confirmPrompt({
+			input: context.runtime.stdin,
+			output: context.output.stderr,
+			signal: context.runtime.signal,
+			message: databasePromptMessage(branch),
+			initialValue: false
+		})) return emptyBranchDatabaseSetupOutcome();
+	} else if (!canPrompt(context) && !context.flags.yes) throw nonInteractiveDatabaseSetupRequiresYesError(branch);
+	return setupBranchDatabase(context, provider, projectId, branch, localSignal, envState, options.projectDir);
+}
+async function setupBranchDatabase(context, provider, projectId, branch, signal, envState, projectDir) {
+	emitBranchDatabaseProgress(context, "pending", "Creating database");
+	const database = await provider.createBranchDatabase({
+		projectId,
+		branchId: branch.id,
+		branchName: branch.name,
+		signal: context.runtime.signal
+	}).catch((error) => {
+		throw branchDatabaseSetupFailedError("Failed to create database", error, branch);
+	});
+	emitBranchDatabaseProgress(context, "success", "Created database");
+	try {
+		const envVars = await upsertBranchDatabaseEnvVars(context, provider, projectId, branch, database, envState);
+		emitBranchDatabaseProgress(context, "success", `Added ${envScopeLabel(branch)} env var${envVars.length === 1 ? "" : "s"} ${envVars.join(", ")} — shared by every app on ${envScopeLabel(branch) === "production" ? "production" : `branch "${branch.name}"`}`);
+		const schemaCommand = signal.schema ? `DATABASE_URL=<url> npx ${formatSchemaSetupCommand(signal.schema.command)} (detected ${path.relative(projectDir, signal.schema.path) || signal.schema.path})` : "your own migration tooling";
+		const schemaSuggestion = `The new database is empty. Get a connection URL with \`prisma-cli database connection create ${database.id}\`, then apply your schema with ${schemaCommand}.`;
+		emitBranchDatabaseWarning(context, schemaSuggestion);
+		return {
+			result: {
+				status: "created",
+				database: {
+					id: database.id,
+					name: database.name
+				},
+				envVars
+			},
+			warnings: [schemaSuggestion]
+		};
+	} catch (error) {
+		throw await cleanupCreatedBranchDatabaseAfterFailure(context, provider, database, branch, error);
+	}
+}
+async function upsertBranchDatabaseEnvVars(context, provider, projectId, branch, database, envState) {
+	const scope = envScopeForBranch(branch);
+	const written = [];
+	await upsertBranchDatabaseEnvVar(context, provider, {
+		projectId,
+		...scope,
+		key: "DATABASE_URL",
+		value: database.databaseUrl,
+		existing: envState.targetDatabaseUrl,
+		branch
+	});
+	written.push("DATABASE_URL");
+	if (database.directUrl) {
+		await upsertBranchDatabaseEnvVar(context, provider, {
+			projectId,
+			...scope,
+			key: "DIRECT_URL",
+			value: database.directUrl,
+			existing: envState.targetDirectUrl,
+			branch
+		});
+		written.push("DIRECT_URL");
+	} else if (branch.kind === "preview" && envState.targetDirectUrl) await provider.deleteEnvironmentVariable({
+		envVarId: envState.targetDirectUrl.id,
+		signal: context.runtime.signal
+	}).catch((error) => {
+		throw branchDatabaseSetupFailedError("Failed to remove stale DIRECT_URL", error, branch);
+	});
+	return written;
+}
+async function upsertBranchDatabaseEnvVar(context, provider, options) {
+	if (options.existing) {
+		await provider.updateEnvironmentVariable({
+			envVarId: options.existing.id,
+			value: options.value,
+			signal: context.runtime.signal
+		}).catch((error) => {
+			throw branchDatabaseSetupFailedError(`Failed to update ${options.key}`, error, options.branch);
+		});
+		return;
+	}
+	await provider.createEnvironmentVariable({
+		projectId: options.projectId,
+		className: options.className,
+		key: options.key,
+		value: options.value,
+		...options.branchId ? { branchId: options.branchId } : {},
+		signal: context.runtime.signal
+	}).catch((error) => {
+		throw branchDatabaseSetupFailedError(`Failed to write ${options.key}`, error, options.branch);
+	});
+}
+async function inspectBranchDatabaseEnv(provider, projectId, branch, signal) {
+	const scope = envScopeForBranch(branch);
+	const [databaseUrlRows, directUrlRows] = await Promise.all([provider.listEnvironmentVariables({
+		projectId,
+		className: scope.className,
+		key: "DATABASE_URL",
+		signal
+	}), provider.listEnvironmentVariables({
+		projectId,
+		className: scope.className,
+		key: "DIRECT_URL",
+		signal
+	})]);
+	const targetBranchId = branch.kind === "preview" ? branch.id : null;
+	return {
+		targetDatabaseUrl: findEnvVar(databaseUrlRows, { branchId: targetBranchId }),
+		targetDirectUrl: findEnvVar(directUrlRows, { branchId: targetBranchId }),
+		inheritedPreviewDatabaseUrl: branch.kind === "preview" ? findEnvVar(databaseUrlRows, { branchId: null }) : null
+	};
+}
+function findEnvVar(rows, options) {
+	return rows.find((row) => row.branchId === options.branchId) ?? null;
+}
+function hasProvidedDatabaseEnvVars(envVars) {
+	return Boolean(envVars && ("DATABASE_URL" in envVars || "DIRECT_URL" in envVars));
+}
+function envScopeForBranch(branch) {
+	return branch.kind === "production" ? { className: "production" } : {
+		className: "preview",
+		branchId: branch.id
+	};
+}
+function envScopeLabel(branch) {
+	return branch.kind === "production" ? "production" : "branch";
+}
+function getTargetDatabaseEnvVarKeys(envState) {
+	return [envState.targetDatabaseUrl, envState.targetDirectUrl].filter((variable) => Boolean(variable)).map((variable) => variable.key).sort();
+}
+function hasExistingDatabaseEnvForTarget(branch, envState) {
+	if (branch.kind === "production") return Boolean(envState.targetDatabaseUrl || envState.targetDirectUrl);
+	return Boolean(envState.targetDatabaseUrl);
+}
+function existingDatabaseEnvReason(branch) {
+	return branch.kind === "production" ? "production-env-exists" : "branch-env-exists";
+}
+function existingDatabaseEnvWarning(branch, envVars) {
+	if (branch.kind === "production") return `Production already has ${envVars.join(" and ")}. Treating it as BYO database configuration and leaving env vars unchanged.`;
+	return `Branch "${branch.name}" already has DATABASE_URL. Leaving branch database env vars unchanged.`;
+}
+function databasePromptSuppressedWarning(branch) {
+	if (branch.kind === "production") return "This app appears to use DATABASE_URL. Run prisma-cli app deploy --db --yes to create and wire a Prisma Postgres database for this first production deploy.";
+	return "This app appears to use DATABASE_URL. Run prisma-cli app deploy --db to create an isolated database for this preview branch.";
+}
+function databasePromptMessage(branch) {
+	return branch.kind === "production" ? "Create a Prisma Postgres database for production?" : `Create an isolated database for branch "${branch.name}"?`;
+}
+function maybeRenderBranchDatabaseSignal(context, branch, signal, envState) {
+	if (context.flags.json || context.flags.quiet) return;
+	const rows = [
+		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.inheritedPreviewDatabaseUrl ? "  Env     preview DATABASE_URL is inherited by this branch" : null
+	].filter((row) => Boolean(row));
+	context.output.stderr.write(`Database signal found for ${databaseTargetLabel(branch)}\n${rows.join("\n")}\n\n`);
+}
+function databaseTargetLabel(branch) {
+	return branch.kind === "production" ? `production branch "${branch.name}"` : `branch "${branch.name}"`;
+}
+function emitBranchDatabaseProgress(context, status, message) {
+	if (context.flags.json || context.flags.quiet) return;
+	const line = status === "pending" ? `${context.ui.warning("◇")} ${message}...` : renderSummaryLine(context.ui, "success", message);
+	context.output.stderr.write(`${line}\n`);
+}
+function emitBranchDatabaseWarning(context, warning) {
+	if (context.flags.json || context.flags.quiet) return;
+	context.output.stderr.write(`${renderSummaryLine(context.ui, "warning", warning)}\n`);
+}
+function emptyBranchDatabaseSetupOutcome() {
+	return {
+		result: void 0,
+		warnings: []
+	};
+}
+function productionDatabaseSetupAfterFirstDeployError() {
+	return usageError("Database setup is only available during the first production deploy", "The selected production app already has a live deployment.", "Use project env commands to manage production DATABASE_URL, or deploy a preview branch with --db.", ["prisma-cli project env add DATABASE_URL=<value> --role production", "prisma-cli app deploy --branch feature/db --db"], "app");
+}
+function nonInteractiveDatabaseSetupRequiresYesError(branch) {
+	return usageError("Database setup requires --yes in non-interactive mode", "The deploy command received --db, but prompts are not available and --yes was not passed.", "Pass --yes together with --db to confirm non-interactive database creation.", [branch.kind === "production" ? "prisma-cli app deploy --prod --db --yes" : `prisma-cli app deploy --branch ${formatCommandArgument(branch.name)} --db --yes`], "app");
+}
+function formatSchemaSetupCommand(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 branchDatabaseSetupFailedError(summary, error, branch) {
+	return new CliError({
+		code: "BRANCH_DATABASE_SETUP_FAILED",
+		domain: "app",
+		summary,
+		why: error instanceof Error ? error.message : String(error),
+		fix: "Retry the command, or create the database and env vars manually with project env commands.",
+		debug: formatDebugDetails(error),
+		meta: { branch: branch.name },
+		exitCode: 1,
+		nextSteps: [formatAppDeployWithDbNextStep(branch), formatProjectEnvListNextStep(branch)]
+	});
+}
+async function cleanupCreatedBranchDatabaseAfterFailure(context, provider, database, branch, error) {
+	const setupError = error instanceof CliError ? error : branchDatabaseSetupFailedError("Database setup failed", error, branch);
+	emitBranchDatabaseProgress(context, "pending", "Removing database after setup failed");
+	try {
+		await provider.deleteBranchDatabase({
+			databaseId: database.id,
+			signal: context.runtime.signal
+		});
+		emitBranchDatabaseProgress(context, "success", "Removed database after setup failed");
+	} catch (cleanupError) {
+		return branchDatabaseCleanupFailedError(setupError, cleanupError, database, branch);
+	}
+	return setupError;
+}
+function branchDatabaseCleanupFailedError(setupError, cleanupError, database, branch) {
+	const cleanupWhy = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+	const setupWhy = setupError.why ?? "Database setup failed.";
+	return new CliError({
+		code: setupError.code,
+		domain: setupError.domain,
+		summary: setupError.summary,
+		why: `${setupWhy} Prisma could not delete the created database "${database.name}" (${database.id}): ${cleanupWhy}`,
+		fix: "Delete the created database from Console or contact Prisma support, then rerun deploy with --db.",
+		debug: formatCombinedDebugDetails(setupError, cleanupError),
+		meta: {
+			...setupError.meta,
+			branch: branch.name,
+			databaseId: database.id,
+			databaseName: database.name,
+			cleanupFailed: true
+		},
+		exitCode: setupError.exitCode,
+		nextSteps: []
+	});
+}
+function unsupportedBranchDatabaseSchemaError(schema, branch, context) {
+	return usageError("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, or switch the Prisma schema source to PostgreSQL before using --db.", [formatProjectEnvAddNextStep(branch), `prisma-cli app deploy --branch ${formatCommandArgument(branch.name)}`], "app");
+}
+function formatAppDeployWithDbNextStep(branch) {
+	return `prisma-cli app deploy --branch ${formatCommandArgument(branch.name)} --db`;
+}
+function formatProjectEnvListNextStep(branch) {
+	return branch.kind === "production" ? "prisma-cli project env list --role production" : `prisma-cli project env list --branch ${formatCommandArgument(branch.name)}`;
+}
+function formatProjectEnvAddNextStep(branch) {
+	return branch.kind === "production" ? "prisma-cli project env add DATABASE_URL=<value> --role production" : `prisma-cli project env add DATABASE_URL=<value> --branch ${formatCommandArgument(branch.name)}`;
+}
+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;
+}
+function formatCombinedDebugDetails(setupError, cleanupError) {
+	const setupDebug = setupError.debug ?? setupError.stack ?? setupError.message;
+	const cleanupDebug = formatDebugDetails(cleanupError);
+	return [setupDebug ? `Setup error:\n${setupDebug}` : null, cleanupDebug ? `Cleanup error:\n${cleanupDebug}` : null].filter((line) => Boolean(line)).join("\n\n") || null;
+}
+//#endregion
+export { maybeSetupBranchDatabase };

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

@@ -0,0 +1,216 @@
+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",
+	".prisma",
+	".turbo",
+	".vercel",
+	".wrangler",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules",
+	"out"
+]);
+const DATABASE_URL_SCAN_EXTENSIONS = new Set([
+	".cjs",
+	".cts",
+	".env",
+	".js",
+	".json",
+	".jsx",
+	".mjs",
+	".mts",
+	".prisma",
+	".ts",
+	".tsx"
+]);
+const MAX_SCAN_DEPTH = 6;
+const MAX_SCAN_FILES = 1e3;
+const MAX_DATABASE_URL_REFERENCE_FILES = 10;
+const MAX_TEXT_FILE_BYTES = 1024 * 1024;
+async function inspectBranchDatabaseSignal(cwd, signal) {
+	const state = {
+		filesVisited: 0,
+		schemaCandidates: [],
+		prismaNextConfigCandidates: [],
+		databaseUrlReferences: []
+	};
+	await scanDirectory(cwd, cwd, 0, state, signal);
+	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,
+		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 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));
+	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);
+			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);
+		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 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) || 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);
+	}).map((candidate) => candidate.absolute);
+}
+async function hasMigrationsDirectory(schemaDirectory, signal) {
+	signal.throwIfAborted();
+	const migrationsPath = path.join(schemaDirectory, "migrations");
+	try {
+		await access(migrationsPath);
+		return (await readdir(migrationsPath)).length > 0;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		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 null;
+	return readFile(filePath, {
+		encoding: "utf8",
+		signal
+	});
+}
+//#endregion
+export { hasBranchDatabaseSignal, inspectBranchDatabaseSignal };