prisma-next 0.11.0-dev.5 → 0.11.0-dev.51

package/dist/{command-helpers-DtavI0wJ.mjs → command-helpers-4UNsRRc4.mjs}

@@ -1,6 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-twds-ZHy.mjs";
-import { d as errorInvalidOutputFormat, g as errorRuntime, m as errorOutputFormatMutex, t as CliStructuredError } from "./cli-errors-Djtz98Vm.mjs";
-import { a as isCI, i as formatErrorOutput, o as createColorFormatter, r as formatErrorJson, s as formatDim, t as createTerminalUI } from "./terminal-ui-BiB_8KNo.mjs";
+import { C as errorRuntime, d as errorInvalidOutputFormat, g as errorOutputFormatMutex, t as CliStructuredError } from "./cli-errors-DFF1LlfU.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk } from "@prisma-next/utils/result";
 import { relative, resolve } from "pathe";
@@ -9,10 +8,33 @@ import { hasMigrations } from "@prisma-next/framework-components/control";
 import { readMigrationsDir } from "@prisma-next/migration-tools/io";
 import { reconstructGraph } from "@prisma-next/migration-tools/migration-graph";
 import { APP_SPACE_ID as APP_SPACE_ID$1, spaceMigrationDirectory } from "@prisma-next/migration-tools/spaces";
-import { blue, bold, cyan, dim, green, magenta } from "colorette";
+import { blue, bold, cyan, dim, green, magenta, red, yellow } from "colorette";
 import wrapAnsi from "wrap-ansi";
 import stringWidth from "string-width";
 import stripAnsi from "strip-ansi";
+import { isCI } from "ci-info";
+import * as clack from "@clack/prompts";
+//#region src/utils/formatters/helpers.ts
+/**
+* Checks if verbose output is enabled at the specified level.
+*/
+function isVerbose(flags, level) {
+	return (flags.verbose ?? 0) >= level;
+}
+/**
+* Creates a color-aware formatter function.
+* Returns a function that applies the color only if colors are enabled.
+*/
+function createColorFormatter(useColor, colorFn) {
+	return useColor ? colorFn : (text) => text;
+}
+/**
+* Formats text with dim styling if colors are enabled.
+*/
+function formatDim(useColor, text) {
+	return useColor ? dim(text) : text;
+}
+//#endregion
 //#region src/utils/formatters/styled.ts
 /**
 * Fixed width for left column in help output.
@@ -417,6 +439,75 @@ function formatRootHelp(options) {
 	return `${lines.join("\n")}\n`;
 }
 //#endregion
+//#region src/utils/is-ci.ts
+/**
+* Returns true when the process is running in any CI environment recognised
+* by the `ci-info` package. The single source of truth for CI detection
+* across this CLI — colour-output suppression and telemetry-skip both call
+* this helper, so neither path drifts from the other when a new CI provider
+* is added upstream.
+*
+* `ci-info` checks the standard `CI=true` marker plus dozens of
+* provider-specific environment variables (Buildkite, Jenkins, Drone,
+* Bitbucket Pipelines, Azure Pipelines, AWS CodeBuild, …) that the raw
+* `process.env.CI` read misses.
+*
+*/
+function isCI$1() {
+	return isCI;
+}
+//#endregion
+//#region src/utils/formatters/errors.ts
+/**
+* Formats error output for human-readable display.
+*/
+function formatErrorOutput(error, flags) {
+	const lines = [];
+	const useColor = flags.color !== false;
+	const formatRed = createColorFormatter(useColor, red);
+	const formatDimText = (text) => formatDim(useColor, text);
+	lines.push(`${formatRed("✖")} ${error.summary} (${error.code})`);
+	if (error.why) lines.push(`${formatDimText(`  Why: ${error.why}`)}`);
+	if (error.fix) lines.push(`${formatDimText(`  Fix: ${error.fix}`)}`);
+	if (error.where?.path) {
+		const whereLine = error.where.line ? `${error.where.path}:${error.where.line}` : error.where.path;
+		lines.push(`${formatDimText(`  Where: ${whereLine}`)}`);
+	}
+	if (error.meta?.["conflicts"]) {
+		const conflicts = error.meta["conflicts"];
+		if (conflicts.length > 0) {
+			const maxToShow = isVerbose(flags, 1) ? conflicts.length : Math.min(3, conflicts.length);
+			const header = isVerbose(flags, 1) ? "  Conflicts:" : `  Conflicts (showing ${maxToShow} of ${conflicts.length}):`;
+			lines.push(`${formatDimText(header)}`);
+			for (const conflict of conflicts.slice(0, maxToShow)) lines.push(`${formatDimText(`    - [${conflict.kind}] ${conflict.summary}`)}`);
+			if (!isVerbose(flags, 1) && conflicts.length > maxToShow) lines.push(`${formatDimText("  Re-run with -v/--verbose to see all conflicts")}`);
+		}
+	}
+	if (error.meta?.["issues"]) {
+		const issues = error.meta["issues"];
+		if (issues.length > 0) {
+			const maxToShow = isVerbose(flags, 1) ? issues.length : Math.min(3, issues.length);
+			const header = isVerbose(flags, 1) ? "  Issues:" : `  Issues (showing ${maxToShow} of ${issues.length}):`;
+			lines.push(`${formatDimText(header)}`);
+			for (const issue of issues.slice(0, maxToShow)) {
+				const kind = issue.kind ?? "issue";
+				const message = issue.message ?? "";
+				lines.push(`${formatDimText(`    - [${kind}] ${message}`)}`);
+			}
+			if (!isVerbose(flags, 1) && issues.length > maxToShow) lines.push(`${formatDimText("  Re-run with -v/--verbose to see all issues")}`);
+		}
+	}
+	if (error.docsUrl && isVerbose(flags, 1)) lines.push(formatDimText(error.docsUrl));
+	if (isVerbose(flags, 2) && error.meta) lines.push(`${formatDimText(`  Meta: ${JSON.stringify(error.meta, null, 2)}`)}`);
+	return lines.join("\n");
+}
+/**
+* Formats error output as JSON.
+*/
+function formatErrorJson(error) {
+	return JSON.stringify(error, null, 2);
+}
+//#endregion
 //#region src/utils/result-handler.ts
 /**
 * Processes a CLI command result, handling both success and error cases.
@@ -438,6 +529,333 @@ function handleResult(result, flags, ui, onSuccess) {
 	return result.failure.domain === "CLI" ? 2 : 1;
 }
 //#endregion
+//#region src/utils/glyph-mode.ts
+function localeString(env) {
+	return env["LC_ALL"] ?? env["LC_CTYPE"] ?? env["LANG"] ?? "";
+}
+function isUtf8Locale(env) {
+	const locale = localeString(env);
+	if (locale.length === 0) return false;
+	return /UTF-8|utf8/i.test(locale);
+}
+function detectGlyphMode(input) {
+	if (!input.isTTY) return "ascii";
+	if (!isUtf8Locale(input.env)) return "ascii";
+	return "unicode";
+}
+//#endregion
+//#region src/utils/shutdown.ts
+function createShutdownHandler(options) {
+	const exit = options?.exit ?? ((code) => process.exit(code));
+	const gracePeriodMs = options?.gracePeriodMs ?? 3e3;
+	const controller = new AbortController();
+	let shuttingDown = false;
+	let graceTimer;
+	const onSignal = () => {
+		if (shuttingDown) {
+			exit(130);
+			return;
+		}
+		shuttingDown = true;
+		controller.abort();
+		graceTimer = setTimeout(() => exit(130), gracePeriodMs);
+		graceTimer.unref();
+	};
+	return {
+		signal: controller.signal,
+		isShuttingDown: () => shuttingDown,
+		onSignal,
+		clearGraceTimer: () => {
+			if (graceTimer !== void 0) {
+				clearTimeout(graceTimer);
+				graceTimer = void 0;
+			}
+		}
+	};
+}
+const globalHandler = createShutdownHandler();
+/**
+* The global AbortSignal. Pass this to any async operation that should
+* be cancellable on Ctrl+C (e.g., DB queries, long-running emit).
+*/
+const shutdownSignal = globalHandler.signal;
+/**
+* Installs SIGINT and SIGTERM handlers. Call once at CLI startup.
+*
+* - First signal: aborts the controller, starts a 3s grace timer.
+* - Second signal: force-exits immediately.
+*/
+let installed = false;
+function installShutdownHandlers() {
+	if (installed) return;
+	installed = true;
+	process.on("SIGINT", globalHandler.onSignal);
+	process.on("SIGTERM", globalHandler.onSignal);
+}
+//#endregion
+//#region src/utils/terminal-ui.ts
+/**
+* Composable CLI output abstraction.
+*
+* Follows the Unix convention of separating data from decoration:
+* - **stdout** — data output only (`ui.output()`). This is what scripts and pipes capture.
+* - **stderr** — all decoration (spinners, logs, notes, intro/outro). Visible in terminal, invisible in pipes.
+*
+* Rules:
+* 1. All methods except `output()` and `error()` write to stderr only in interactive mode.
+* 2. `output(data)` always writes to stdout — if a command calls it, there is data to emit.
+* 3. `error()` always writes to stderr — errors matter even when piped.
+* 4. Decoration is suppressed when piped unless `--format pretty` was explicit (`forcePretty`).
+* 5. Never write data to stderr — decoration methods are for human context only.
+* 6. Never write decoration to stdout — it breaks pipes, `$(...)` captures, and `> file` redirects.
+*/
+var TerminalUI = class TerminalUI {
+	/**
+	* True when stdout is a TTY (interactive terminal).
+	* False when piped (e.g., `prisma-next db verify | jq`).
+	*/
+	isInteractive;
+	/**
+	* Whether color output is enabled.
+	*/
+	useColor;
+	/**
+	* When true, decoration methods write even on non-TTY stdout
+	* (explicit `--format pretty`).
+	*/
+	forcePretty;
+	/**
+	* Whether stdout is a TTY — used for migration-list graph glyph detection.
+	*/
+	stdoutIsTTY;
+	/**
+	* Process environment snapshot for locale-aware glyph detection.
+	*/
+	env;
+	static stderrOpts = { output: process.stderr };
+	constructor(options) {
+		this.isInteractive = options?.interactive ?? !!process.stdout.isTTY;
+		this.forcePretty = options?.forcePretty ?? false;
+		this.useColor = options?.color ?? (this.isInteractive || this.forcePretty);
+		this.stdoutIsTTY = options?.stdoutIsTTY ?? !!process.stdout.isTTY;
+		this.env = options?.env ?? process.env;
+	}
+	get isTTY() {
+		return this.stdoutIsTTY;
+	}
+	/**
+	* Resolve graph glyph mode for `migration list --graph`. `--ascii` forces
+	* ASCII; otherwise delegates to the pure {@link detectGlyphMode} helper.
+	*/
+	resolveGlyphMode(forceAscii) {
+		if (forceAscii) return "ascii";
+		return detectGlyphMode(this.glyphModeInput());
+	}
+	glyphModeInput() {
+		return {
+			isTTY: this.stdoutIsTTY,
+			env: this.env
+		};
+	}
+	get shouldDecorate() {
+		return this.isInteractive || this.forcePretty;
+	}
+	/**
+	* Log a message line to stderr. No-op when piped unless forcePretty.
+	*/
+	log(message) {
+		if (!this.shouldDecorate) return;
+		clack.log.message(message, TerminalUI.stderrOpts);
+	}
+	/**
+	* Log a success message to stderr. No-op when piped unless forcePretty.
+	*/
+	success(message) {
+		if (!this.shouldDecorate) return;
+		clack.log.success(message, TerminalUI.stderrOpts);
+	}
+	/**
+	* Log a warning message to stderr. No-op when piped unless forcePretty.
+	*/
+	warn(message) {
+		if (!this.shouldDecorate) return;
+		clack.log.warn(message, TerminalUI.stderrOpts);
+	}
+	/**
+	* Log an error message to stderr. Always writes (errors matter even in pipes).
+	*/
+	error(message) {
+		clack.log.error(message, TerminalUI.stderrOpts);
+	}
+	/**
+	* Log an info message to stderr. No-op when piped unless forcePretty.
+	*/
+	info(message) {
+		if (!this.shouldDecorate) return;
+		clack.log.info(message, TerminalUI.stderrOpts);
+	}
+	/**
+	* Log a step message to stderr. No-op when piped unless forcePretty.
+	*/
+	step(message) {
+		if (!this.shouldDecorate) return;
+		clack.log.step(message, TerminalUI.stderrOpts);
+	}
+	/**
+	* Display a note box on stderr. No-op when piped unless forcePretty.
+	*/
+	note(message, title) {
+		if (!this.shouldDecorate) return;
+		clack.note(message, title, TerminalUI.stderrOpts);
+	}
+	/**
+	* Display intro banner on stderr. No-op when piped unless forcePretty.
+	*/
+	intro(title) {
+		if (!this.shouldDecorate) return;
+		clack.intro(title, TerminalUI.stderrOpts);
+	}
+	/**
+	* Display outro banner on stderr. No-op when piped unless forcePretty.
+	*/
+	outro(message) {
+		if (!this.shouldDecorate) return;
+		clack.outro(message, TerminalUI.stderrOpts);
+	}
+	/**
+	* Create a Clack spinner on stderr with a 100ms delay threshold.
+	* The spinner only appears if the operation takes longer than the threshold,
+	* avoiding flicker for fast operations. Returns a no-op spinner when not decorating.
+	*/
+	spinner(delayMs = 100) {
+		const noop = {
+			start: () => {},
+			stop: () => {},
+			cancel: () => {},
+			error: () => {},
+			message: () => {},
+			clear: () => {},
+			get isCancelled() {
+				return false;
+			}
+		};
+		if (!this.shouldDecorate) return noop;
+		let inner;
+		let timer;
+		let pendingMsg;
+		let settled = false;
+		const ensureCleared = () => {
+			if (timer !== void 0) {
+				clearTimeout(timer);
+				timer = void 0;
+			}
+		};
+		const onAbort = () => {
+			if (!settled) {
+				settled = true;
+				ensureCleared();
+				if (inner) inner.cancel("Interrupted");
+			}
+		};
+		if (!shutdownSignal.aborted) shutdownSignal.addEventListener("abort", onAbort, { once: true });
+		return {
+			start(msg) {
+				pendingMsg = msg;
+				timer = setTimeout(() => {
+					if (!settled) {
+						inner = clack.spinner(TerminalUI.stderrOpts);
+						inner.start(pendingMsg);
+					}
+				}, delayMs);
+			},
+			stop(msg) {
+				settled = true;
+				ensureCleared();
+				if (inner) inner.stop(msg);
+			},
+			cancel(msg) {
+				settled = true;
+				ensureCleared();
+				if (inner) inner.cancel(msg);
+			},
+			error(msg) {
+				settled = true;
+				ensureCleared();
+				if (inner) inner.error(msg);
+			},
+			message(msg) {
+				pendingMsg = msg;
+				if (inner) inner.message(msg);
+			},
+			clear() {
+				settled = true;
+				ensureCleared();
+				if (inner) inner.clear();
+			},
+			get isCancelled() {
+				return inner?.isCancelled ?? false;
+			}
+		};
+	}
+	/**
+	* Prompt for yes/no confirmation on stderr. Returns true if confirmed.
+	* In non-interactive mode or when cancelled (Ctrl-C), returns false.
+	*/
+	async confirm(message) {
+		if (!this.isInteractive) return false;
+		const result = await clack.confirm({
+			message,
+			...TerminalUI.stderrOpts
+		});
+		if (clack.isCancel(result)) return false;
+		return result;
+	}
+	/**
+	* Write a raw line to stderr. No-op when piped unless forcePretty.
+	* Use for decoration that doesn't fit Clack's log format (e.g. styled headers).
+	*/
+	stderr(message) {
+		if (!this.shouldDecorate) return;
+		process.stderr.write(`${message}\n`);
+	}
+	/**
+	* Write machine-readable data to stdout.
+	* Always writes — if a command calls output(), there is data to emit.
+	*
+	* This is what scripts and pipes capture: `prisma-next db verify --json | jq .ok`
+	*/
+	output(data) {
+		process.stdout.write(`${data}\n`);
+	}
+	green(text) {
+		return this.useColor ? green(text) : text;
+	}
+	red(text) {
+		return this.useColor ? red(text) : text;
+	}
+	cyan(text) {
+		return this.useColor ? cyan(text) : text;
+	}
+	dim(text) {
+		return this.useColor ? dim(text) : text;
+	}
+	bold(text) {
+		return this.useColor ? bold(text) : text;
+	}
+	yellow(text) {
+		return this.useColor ? yellow(text) : text;
+	}
+};
+function createTerminalUI(flags, runtime) {
+	return new TerminalUI({
+		color: flags.color,
+		interactive: flags.interactive,
+		forcePretty: flags.format === "pretty" && flags.explicitFormat,
+		stdoutIsTTY: runtime?.isTTY,
+		env: runtime?.env
+	});
+}
+//#endregion
 //#region src/utils/global-flags.ts
 function isJsonFlagSet(json) {
 	return json === true;
@@ -525,7 +943,7 @@ function parseGlobalFlags(options) {
 	if (process.env["NO_COLOR"] || flags.json) flags.color = false;
 	else if (options["no-color"]) flags.color = false;
 	else if (options.color !== void 0) flags.color = options.color;
-	else flags.color = process.stdout.isTTY && !isCI();
+	else flags.color = process.stdout.isTTY && !isCI$1();
 	if (options["no-interactive"]) flags.interactive = false;
 	else if (options.interactive !== void 0) flags.interactive = options.interactive;
 	else flags.interactive = !!process.stdout.isTTY;
@@ -693,10 +1111,10 @@ function getTargetMigrations(target) {
 * string); there is no draft state to filter out.
 */
 async function loadMigrationPackages(migrationsDir) {
-	const bundles = await readMigrationsDir(migrationsDir);
+	const { packages } = await readMigrationsDir(migrationsDir);
 	return {
-		bundles,
-		graph: reconstructGraph(bundles)
+		bundles: packages,
+		graph: reconstructGraph(packages)
 	};
 }
 /**
@@ -773,6 +1191,6 @@ function addGlobalOptions(command) {
 	} }).option("--format <pretty|json>", "Output format (default: pretty, or json when stdout is not a TTY)").option("--json", "Output as JSON (alias for --format json)").option("-q, --quiet", "Quiet mode: errors only").option("-v, --verbose", "Verbose output: debug info, timings").option("--trace", "Trace output: deep internals, stack traces").option("--color", "Force color output").option("--no-color", "Disable color output").option("--interactive", "Force interactive mode").option("--no-interactive", "Disable interactive prompts").option("-y, --yes", "Auto-accept prompts");
 }
 //#endregion
-export { formatSuccessMessage as C, formatStyledHeader as S, parseGlobalFlags as _, loadMigrationPackages as a, formatCommandHelp as b, resolveContractPath as c, setCommandDescriptions as d, setCommandExamples as f, toStructuralEdge as g, toPathDecisionResult as h, getTargetMigrations as i, resolveMigrationPaths as l, targetSupportsMigrations as m, collectDeclaredInvariants as n, maskConnectionUrl as o, setCommandSeeAlso as p, command_helpers_exports as r, readContractEnvelope as s, addGlobalOptions as t, sanitizeErrorMessage as u, parseGlobalFlagsOrExit as v, formatRootHelp as x, handleResult as y };
+export { formatDim as A, formatErrorOutput as C, formatStyledHeader as D, formatRootHelp as E, formatSuccessMessage as O, formatErrorJson as S, formatCommandHelp as T, parseGlobalFlags as _, loadMigrationPackages as a, installShutdownHandlers as b, resolveContractPath as c, setCommandDescriptions as d, setCommandExamples as f, toStructuralEdge as g, toPathDecisionResult as h, getTargetMigrations as i, isVerbose as j, createColorFormatter as k, resolveMigrationPaths as l, targetSupportsMigrations as m, collectDeclaredInvariants as n, maskConnectionUrl as o, setCommandSeeAlso as p, command_helpers_exports as r, readContractEnvelope as s, addGlobalOptions as t, sanitizeErrorMessage as u, parseGlobalFlagsOrExit as v, isCI$1 as w, handleResult as x, createTerminalUI as y };
 
-//# sourceMappingURL=command-helpers-DtavI0wJ.mjs.map
+//# sourceMappingURL=command-helpers-4UNsRRc4.mjs.map