@prisma/cli 8.0.0-rc.1 → 8.0.0-rc.10

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

@@ -1,102 +0,0 @@
-//#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

@@ -1,353 +0,0 @@
-import { formatCommandArgument } from "../../command-arguments.js";
-import { CliError, usageError } from "../../errors.js";
-import { renderSummaryLine } from "../../shell/ui.js";
-import { canPrompt } from "../../shell/runtime.js";
-import { confirmPrompt } from "../../shell/prompt.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();
-	const databaseRequested = options.db === true;
-	const conflict = findBranchDatabaseSetupConflict(branch, options);
-	if (conflict) {
-		if (databaseRequested) throw branchDatabaseSetupConflictError(conflict);
-		return emptyBranchDatabaseSetupOutcome();
-	}
-	const envState = await inspectBranchDatabaseEnv(provider, projectId, branch, context.runtime.signal);
-	if (hasExistingDatabaseEnvForTarget(branch, envState)) return existingDatabaseEnvOutcome(context, branch, envState, databaseRequested);
-	const localSignal = await inspectBranchDatabaseSignal(options.projectDir, context.runtime.signal);
-	if (localSignal.unsupportedSchema) {
-		if (databaseRequested) throw unsupportedBranchDatabaseSchemaError(localSignal.unsupportedSchema, branch, context);
-		return emptyBranchDatabaseSetupOutcome();
-	}
-	const confirmation = await confirmBranchDatabaseSetup(context, branch, localSignal, envState, databaseRequested);
-	if (!confirmation.confirmed) return confirmation.outcome;
-	return setupBranchDatabase(context, provider, projectId, branch, localSignal, envState, options.projectDir);
-}
-function findBranchDatabaseSetupConflict(branch, options) {
-	if (hasProvidedDatabaseEnvVars(options.providedEnvVars)) return "provided-env-vars";
-	if (branch.kind === "production" && !options.firstProductionDeploy) return "production-after-first-deploy";
-	return null;
-}
-function branchDatabaseSetupConflictError(conflict) {
-	switch (conflict) {
-		case "provided-env-vars": return providedDatabaseEnvVarsError();
-		case "production-after-first-deploy": return productionDatabaseSetupAfterFirstDeployError();
-	}
-}
-function existingDatabaseEnvOutcome(context, branch, envState, databaseRequested) {
-	if (!databaseRequested) return emptyBranchDatabaseSetupOutcome();
-	const envVars = getTargetDatabaseEnvVarKeys(envState);
-	const warning = existingDatabaseEnvWarning(branch, envVars);
-	emitBranchDatabaseWarning(context, warning);
-	return {
-		result: {
-			status: "skipped",
-			reason: existingDatabaseEnvReason(branch),
-			envVars
-		},
-		warnings: [warning]
-	};
-}
-async function confirmBranchDatabaseSetup(context, branch, signal, envState, databaseRequested) {
-	if (databaseRequested) {
-		if (!canPrompt(context) && !context.flags.yes) throw nonInteractiveDatabaseSetupRequiresYesError(branch);
-		return { confirmed: true };
-	}
-	if (!(hasBranchDatabaseSignal(signal) || Boolean(envState.inheritedPreviewDatabaseUrl))) return {
-		confirmed: false,
-		outcome: emptyBranchDatabaseSetupOutcome()
-	};
-	if (!canPrompt(context) || context.flags.yes) {
-		const warning = databasePromptSuppressedWarning(branch);
-		emitBranchDatabaseWarning(context, warning);
-		return {
-			confirmed: false,
-			outcome: {
-				result: void 0,
-				warnings: [warning]
-			}
-		};
-	}
-	maybeRenderBranchDatabaseSignal(context, branch, signal, envState);
-	return await confirmPrompt({
-		input: context.runtime.stdin,
-		output: context.output.stderr,
-		signal: context.runtime.signal,
-		message: databasePromptMessage(branch),
-		initialValue: false
-	}) ? { confirmed: true } : {
-		confirmed: false,
-		outcome: emptyBranchDatabaseSetupOutcome()
-	};
-}
-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 providedDatabaseEnvVarsError() {
-	return 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");
-}
-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

@@ -1,234 +0,0 @@
-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 : 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);
-}
-async function scanDirectory(cwd, directory, depth, state, signal) {
-	signal.throwIfAborted();
-	if (depth > MAX_SCAN_DEPTH || state.filesVisited >= MAX_SCAN_FILES) return;
-	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 (isScannableDirectory(entry)) {
-			await scanDirectory(cwd, entryPath, depth + 1, state, signal);
-			continue;
-		}
-		if (!entry.isFile()) continue;
-		state.filesVisited += 1;
-		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) {
-		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 || compareCodeUnits(left.relative, 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"
-	};
-}
-const SCHEMA_PROVIDER = /\bprovider\s*=\s*"([^"]+)"/;
-async function classifyPrismaOrmSchemaTarget(schemaPath, signal) {
-	switch ((await readTextFileIfSmall(schemaPath, signal))?.match(SCHEMA_PROVIDER)?.[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 };