@prisma/cli 3.0.0-beta.1 → 3.0.0-beta.11

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

@@ -0,0 +1,325 @@
+import { CliError, usageError } from "../../shell/errors.js";
+import { confirmPrompt } from "../../shell/prompt.js";
+import { renderSummaryLine } from "../../shell/ui.js";
+import { canPrompt } from "../../shell/runtime.js";
+import { formatCommandArgument } from "../../shell/command-arguments.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,
+			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,215 @@
+import { access, readFile, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+//#region src/lib/app/branch-database.ts
+const SKIPPED_DIRECTORIES = new Set([
+	".git",
+	".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 };

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

@@ -1,11 +1,15 @@
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 //#region src/lib/app/bun-project.ts
-async function readBunPackageJson(appPath) {
+async function readBunPackageJson(appPath, signal) {
 	const packageJsonPath = path.join(appPath, "package.json");
 	let content;
+	signal?.throwIfAborted();
 	try {
-		content = await readFile(packageJsonPath, "utf8");
+		content = await readFile(packageJsonPath, {
+			encoding: "utf8",
+			signal
+		});
 	} catch (error) {
 		if (error.code === "ENOENT") return null;
 		throw new Error(`Failed to read ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`);
@@ -20,17 +24,20 @@ function readBunPackageEntrypoint(packageJson) {
 	if (typeof packageJson?.main === "string") return packageJson.main;
 	if (typeof packageJson?.module === "string") return packageJson.module;
 }
-async function resolveBunEntrypoint(appPath, explicitEntrypoint) {
-	const packageJson = await readBunPackageJson(appPath);
+async function resolveBunEntrypoint(appPath, explicitEntrypoint, signal) {
+	const packageJson = await readBunPackageJson(appPath, signal);
 	const candidate = explicitEntrypoint ?? readBunPackageEntrypoint(packageJson);
 	if (!candidate) throw new Error("Entrypoint is required. Pass --entry or define package.json main or module.");
 	if (path.isAbsolute(candidate)) throw new Error("Entrypoint must be a relative path.");
 	const normalized = path.normalize(candidate);
 	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized.includes(`${path.sep}..${path.sep}`)) throw new Error("Entrypoint must not escape the app directory.");
 	const entrypointPath = path.join(appPath, normalized);
+	signal?.throwIfAborted();
 	try {
 		await access(entrypointPath);
-	} catch {
+		signal?.throwIfAborted();
+	} catch (error) {
+		if (signal?.aborted) throw error;
 		throw new Error(`Entrypoint file does not exist: ${entrypointPath}`);
 	}
 	return normalized.split(path.sep).join("/");