prisma-next 0.5.0-dev.9 → 0.5.0

package/dist/migration-cli.mjs

@@ -1,12 +1,13 @@
-import { t as loadConfig } from "./config-loader-C25b63rJ.mjs";
-import { readFileSync, writeFileSync } from "node:fs";
-import { CliStructuredError, errorMigrationCliInvalidConfigArg } from "@prisma-next/errors/control";
+import { t as loadConfig } from "./config-loader-B6sJjXTv.mjs";
+import { CliStructuredError, errorMigrationCliInvalidConfigArg, errorMigrationCliUnknownFlag } from "@prisma-next/errors/control";
 import { dirname, join } from "pathe";
 import { createControlStack } from "@prisma-next/framework-components/control";
 import { errorMigrationTargetMismatch } from "@prisma-next/errors/migration";
+import { readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { MigrationToolsError, errorInvalidJson } from "@prisma-next/migration-tools/errors";
 import { fileURLToPath } from "node:url";
-import { buildMigrationArtifacts, isDirectEntrypoint, printMigrationHelp } from "@prisma-next/migration-tools/migration";
-
+import { buildMigrationArtifacts } from "@prisma-next/migration-tools/migration";
+import { Cli, Command, Option, UsageError } from "clipanion";
 //#region src/migration-cli.ts
 /**
 * The migration-file CLI interface: the actor invoked when the author runs
@@ -25,7 +26,8 @@ import { buildMigrationArtifacts, isDirectEntrypoint, printMigrationHelp } from
 * entrypoint (`node migration.ts`), the CLI:
 *
 * 1. Detects whether the file is the direct entrypoint (no-op when imported).
-* 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`).
+* 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`) via
+*    [clipanion](https://github.com/arcanis/clipanion).
 * 3. Loads the project's `prisma-next.config.ts` via the same `loadConfig`
 *    the CLI commands use, walking up from the migration file's directory.
 * 4. Probe-instantiates the migration class without a stack so it can read
@@ -44,44 +46,62 @@ import { buildMigrationArtifacts, isDirectEntrypoint, printMigrationHelp } from
 * on-disk persistence. `@prisma-next/migration-tools` owns the pure
 * conversion from a `Migration` instance to artifact strings; `Migration`
 * stays a pure abstract class.
+*
+* Parser library: clipanion (chosen over Commander/citty/`node:util.parseArgs`
+* for its in-process testability and runtime-agnostic execution surface; see
+* `docs/architecture docs/research/commander-friction-points.md` for the
+* evaluation rubric and the durable rationale that drove the choice).
 */
 /**
-* Parse the subset of `process.argv` that `MigrationCLI.run` cares about.
-* Recognised flags: `--help`, `--dry-run`, `--config <path>` /
-* `--config=<path>`. Unknown flags are ignored to keep the surface
-* forgiving for ad-hoc tooling that wraps a migration file.
+* Flags exposed by the migration-file CLI.
 *
-* Throws `errorMigrationCliInvalidConfigArg` (`PN-CLI-4012`) when
-* `--config` is missing its path argument or is followed by another flag
-* (e.g. `--config --dry-run`); silently consuming the next flag would
-* either drop dry-run handling or serialize against the wrong project.
-*
-* NOTE: this hand-rolled parser is a known wart, tracked separately by
-* TML-2318 ("Migration CLI: replace handrolled arg parser with shared
-* CLI library"). Until that lands the surface is intentionally tiny.
+* Must stay in sync with the `Option` declarations on
+* `MigrationFileCommand` below. This list is rendered in the
+* `errorMigrationCliUnknownFlag` envelope's `fix` text and `meta`,
+* so order matters for user-visible output (declaration order is the
+* order users see when they run `--help`).
+*/
+const KNOWN_FLAGS = [
+	"--help",
+	"--dry-run",
+	"--config"
+];
+/**
+* The clipanion command that owns the migration-file CLI's option
+* declarations. The class is internal — `MigrationCLI.run` is the
+* stable public surface. Adding a flag here automatically updates
+* `--help` rendering and the `KNOWN_FLAGS` list (the latter must be
+* updated in tandem).
 */
-function parseArgs(argv) {
-	let help = false;
-	let dryRun = false;
-	let configPath;
-	for (let i = 0; i < argv.length; i++) {
-		const arg = argv[i];
-		if (arg === "--help" || arg === "-h") help = true;
-		else if (arg === "--dry-run") dryRun = true;
-		else if (arg === "--config") {
-			const next = argv[i + 1];
-			if (next === void 0) throw errorMigrationCliInvalidConfigArg();
-			if (next.startsWith("-")) throw errorMigrationCliInvalidConfigArg({ nextToken: next });
-			configPath = next;
-			i++;
-		} else if (arg.startsWith("--config=")) configPath = arg.slice(9);
+var MigrationFileCommand = class extends Command {
+	static paths = [Command.Default];
+	static usage = Command.Usage({
+		description: "Self-emit ops.json and migration.json from a class-flow migration",
+		details: `
+      Loads the project's prisma-next.config.ts, assembles a ControlStack
+      from the configured target/adapter/extensions, and serializes the
+      migration's operations + metadata next to this file.
+    `,
+		examples: [
+			["Self-emit ops.json + migration.json next to migration.ts", "$0"],
+			["Preview without writing files", "$0 --dry-run"],
+			["Use a non-default config path", "$0 --config ./custom.config.ts"]
+		]
+	});
+	dryRun = Option.Boolean("--dry-run", false, { description: "Print operations to stdout without writing files" });
+	config = Option.String("--config", { description: "Path to prisma-next.config.ts" });
+	/**
+	* Unused: orchestration runs inside `MigrationCLI.run` so error
+	* routing stays under our control (clipanion's `cli.run` writes
+	* error output to `context.stdout`, but our contract requires
+	* structured errors on stderr). `cli.process` is used to parse
+	* argv into a populated `MigrationFileCommand` instance whose
+	* fields drive the orchestration directly.
+	*/
+	async execute() {
+		return 0;
 	}
-	return {
-		help,
-		dryRun,
-		configPath
-	};
-}
+};
 /**
 * The CLI surface invoked by an authored `migration.ts` file. Exposed as
 * a class with a static `run` method (rather than a free function) to
@@ -96,59 +116,243 @@ function parseArgs(argv) {
 */
 var MigrationCLI = class {
 	/**
-	* Orchestrates a class-flow `migration.ts` script run. Awaitable:
-	* callers may `await MigrationCLI.run(...)` to surface async failures
-	* from config loading, but the typical usage pattern (top-level call
-	* after the class definition) does not require awaiting because
-	* node's module evaluation keeps the promise alive until completion.
+	* Orchestrates a class-flow `migration.ts` script run.
+	*
+	* The third argument is the in-process testability surface: callers
+	* (and tests) may inject `argv`, `stdout`, and `stderr` instead of
+	* relying on `process.argv` / `process.stdout` / `process.stderr`.
+	* Each option defaults to its `process` global when omitted, so
+	* existing two-argument call sites
+	* (`MigrationCLI.run(import.meta.url, MyMigration)`) continue to
+	* compile and behave identically.
 	*
-	* Any throwable inside this function must surface through the internal
-	* try/catch — script callers do not await, so an unhandled rejection
-	* would silently exit 0. Treat the try/catch as load-bearing for the
-	* no-await usage pattern.
+	* Returns the exit code so the caller can branch on it. Also writes
+	* the same code to `process.exitCode` so script-style callers that
+	* don't await the return value still surface a non-zero exit when
+	* something fails.
+	*
+	* Exit codes:
+	* - 0 — success, or `--help`, or imported-not-entrypoint no-op.
+	* - 1 — runtime/orchestration error (config not found, target
+	*   mismatch, etc.).
+	* - 2 — usage error (unknown flag, malformed `--config`). Aligns
+	*   with `docs/CLI Style Guide.md` § Exit Codes.
 	*/
-	static async run(importMetaUrl, MigrationClass) {
-		if (!importMetaUrl) return;
-		if (!isDirectEntrypoint(importMetaUrl)) return;
-		try {
-			const args = parseArgs(process.argv.slice(2));
-			if (args.help) {
-				printMigrationHelp();
-				return;
+	static async run(importMetaUrl, MigrationClass, options = {}) {
+		if (!importMetaUrl) return 0;
+		const argv = options.argv ?? process.argv;
+		const stdout = options.stdout ?? process.stdout;
+		const stderr = options.stderr ?? process.stderr;
+		if (!isDirectEntrypoint(importMetaUrl, argv)) return 0;
+		const exitCode = await orchestrate(importMetaUrl, MigrationClass, {
+			argv,
+			stdout,
+			stderr
+		});
+		if (exitCode !== 0 || !process.exitCode) process.exitCode = exitCode;
+		return exitCode;
+	}
+};
+/**
+* Argv-aware variant of the entrypoint guard. The shared
+* `@prisma-next/migration-tools` helper of the same name reads
+* `process.argv[1]` directly, which doesn't compose with the new
+* in-process testability surface (tests inject `argv` without mutating
+* the process global). Inlined here so the migration-file CLI's check
+* follows the injected `argv[1]` consistently.
+*/
+function isDirectEntrypoint(importMetaUrl, argv) {
+	const argv1 = argv[1];
+	if (!argv1) return false;
+	try {
+		return realpathSync(fileURLToPath(importMetaUrl)) === realpathSync(argv1);
+	} catch {
+		return false;
+	}
+}
+/**
+* Argv-and-stream-driven orchestration body. Pulled out of the static
+* method so the entrypoint guard / process-default plumbing stays
+* separate from the parse + load + serialize steps.
+*/
+async function orchestrate(importMetaUrl, MigrationClass, ctx) {
+	const cli = Cli.from([MigrationFileCommand], {
+		binaryName: "migration.ts",
+		binaryLabel: "Migration file CLI"
+	});
+	const input = ctx.argv.slice(2);
+	const configError = detectInvalidConfig(input);
+	if (configError) {
+		writeStructuredError(ctx.stderr, configError);
+		return 2;
+	}
+	let parsed;
+	try {
+		const command = cli.process({
+			input: [...input],
+			context: {
+				stdout: ctx.stdout,
+				stderr: ctx.stderr
 			}
-			const migrationDir = dirname(fileURLToPath(importMetaUrl));
-			const config = await loadConfig(args.configPath);
-			const probe = new MigrationClass();
-			if (probe.targetId !== config.target.targetId) throw errorMigrationTargetMismatch({
-				migrationTargetId: probe.targetId,
-				configTargetId: config.target.targetId
-			});
-			serializeMigrationToDisk(new MigrationClass(createControlStack(config)), migrationDir, args.dryRun);
-		} catch (err) {
-			if (CliStructuredError.is(err)) process.stderr.write(`${err.message}: ${err.why}\n`);
-			else process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
-			process.exitCode = 1;
+		});
+		if (!(command instanceof MigrationFileCommand)) {
+			ctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));
+			return 0;
 		}
+		parsed = command;
+	} catch (err) {
+		return renderParseError(err, input, ctx.stderr);
 	}
-};
+	if (parsed.help) {
+		ctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));
+		return 0;
+	}
+	try {
+		await runMigration(importMetaUrl, MigrationClass, parsed, ctx);
+		return 0;
+	} catch (err) {
+		if (CliStructuredError.is(err)) writeStructuredError(ctx.stderr, err);
+		else if (MigrationToolsError.is(err)) {
+			const fix = err.fix ? `\n${err.fix}` : "";
+			ctx.stderr.write(`${err.code}: ${err.message}\n${err.why}${fix}\n`);
+		} else ctx.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+		return 1;
+	}
+}
+/**
+* Returns an `errorMigrationCliInvalidConfigArg` envelope when `input`
+* contains a malformed `--config`:
+*
+* - `--config` as the last token (no value follows).
+* - `--config <flag>` where `<flag>` starts with `-` (silently
+*   consuming the next flag would either drop the flag or serialize
+*   against the wrong project).
+* - `--config <empty>` where the value is the empty string. Shells
+*   expand `--config ""` (or `--config "$UNSET_VAR"`) into a real
+*   empty argv token; treating that as a usage error here surfaces
+*   `PN-CLI-4012` instead of a less actionable loader error on an
+*   empty path.
+* - `--config=` (the equals form with an empty value). Same shape as
+*   the empty-string case above; the user expressed intent to override
+*   the config path but the override is empty.
+*
+* `--config=<value>` and `--config <value>` with a non-empty value are
+* both valid (and the equals form's value is allowed to start with
+* `-` — the `=` makes the binding explicit).
+*/
+function detectInvalidConfig(input) {
+	for (let i = 0; i < input.length; i++) {
+		const token = input[i];
+		if (token === "--config") {
+			const next = input[i + 1];
+			if (next === void 0 || next === "") return errorMigrationCliInvalidConfigArg();
+			if (next.startsWith("-")) return errorMigrationCliInvalidConfigArg({ nextToken: next });
+			continue;
+		}
+		if (token === "--config=") return errorMigrationCliInvalidConfigArg();
+	}
+	return null;
+}
+/**
+* Translate clipanion's parse-time errors into the project's structured
+* error envelopes.
+*
+* - `UnknownSyntaxError` covers both unknown flags (`--frobnicate`) and
+*   the bare-trailing `--config` case (where arity-1 needs a value but
+*   none was supplied). Distinguished by inspecting the input array.
+* - `UsageError` covers schema/validator failures from typanion. None
+*   of the migration-file CLI's options have validators today, but we
+*   still translate it as a usage error (exit 2) for forward-compat.
+* - Anything else re-throws — caller's outer catch will surface it as
+*   exit 1 (runtime error).
+*/
+function renderParseError(err, input, stderr) {
+	if (isUnknownSyntaxError(err)) {
+		writeStructuredError(stderr, errorMigrationCliUnknownFlag({
+			flag: findOffendingFlag(input),
+			knownFlags: KNOWN_FLAGS
+		}));
+		return 2;
+	}
+	if (err instanceof UsageError) {
+		writeStructuredError(stderr, errorMigrationCliInvalidConfigArg({ nextToken: err.message }));
+		return 2;
+	}
+	throw err;
+}
+/**
+* Duck-type check for clipanion's `UnknownSyntaxError`: the class is
+* thrown by the parser but is not re-exported from the package's main
+* entry (only `UsageError` is — see clipanion's `advanced/index.d.ts`).
+* Identified by `name === 'UnknownSyntaxError'` and the
+* `clipanion.type === 'none'` discriminator that clipanion's
+* `ErrorWithMeta` interface guarantees.
+*/
+function isUnknownSyntaxError(err) {
+	if (!(err instanceof Error) || err.name !== "UnknownSyntaxError") return false;
+	const meta = err.clipanion;
+	return typeof meta === "object" && meta !== null && meta.type === "none";
+}
+/**
+* Best-effort: pull the first input token that doesn't match a known
+* flag. Falls back to the first token when we can't pinpoint it. The
+* returned name is rendered into the user-visible PN-CLI-4013 envelope
+* (`Unknown flag \`<name>\``) and round-tripped via `meta.flag` so
+* agent consumers can render their own "did you mean" suggestions.
+*/
+function findOffendingFlag(input) {
+	for (const token of input) {
+		if (!token.startsWith("-")) continue;
+		const head = token.split("=", 1)[0] ?? token;
+		if (!KNOWN_FLAGS.includes(head) && head !== "-h") return head;
+	}
+	return input[0] ?? "";
+}
+/**
+* Write a `CliStructuredError` envelope to the given stream. Format
+* matches the legacy hand-rolled writer (`message: why`) so the rest of
+* the project's error rendering stays consistent across surfaces. The
+* full PN code (`PN-<domain>-<code>`) is included so consumers can
+* grep for stable identifiers.
+*/
+function writeStructuredError(stream, err) {
+	const envelope = err.toEnvelope();
+	const why = envelope.why ?? envelope.summary;
+	const fix = envelope.fix ? `\n${envelope.fix}` : "";
+	stream.write(`${envelope.code}: ${envelope.summary}\n${why}${fix}\n`);
+}
 /**
 * Read a previously-scaffolded `migration.json` from disk, returning
-* `null` when the file is missing or unparseable. The CLI feeds this into
-* `buildMigrationArtifacts` so the pure builder can preserve fields owned
-* by `migration plan` (contract bookends, hints, labels, `createdAt`)
-* across re-emits.
+* `null` when the file is missing and throwing `MIGRATION.INVALID_JSON`
+* when the file is present but cannot be parsed as JSON. The CLI feeds
+* this into `buildMigrationArtifacts` so the pure builder can preserve
+* fields owned by `migration plan` (contract bookends, hints, labels,
+* `createdAt`) across re-emits.
+*
+* Author-time path: this loader still does not verify the manifest hash
+* or schema — that is the apply-time loader's job. Hash mismatch is the
+* *expected* outcome of a re-author (the developer's source changes
+* invalidate the prior hash by construction), and verification here
+* would block legitimate regenerations. Syntactic JSON-parse failure,
+* however, is now surfaced rather than swallowed: a malformed
+* `migration.json` indicates either a hand-edit gone wrong or partial
+* write, and silently rebuilding from `describe()` would discard the
+* user's on-disk content (preserved bookends, hints, labels,
+* `createdAt`) without any indication something was wrong on disk.
+* Apply-time consumers always route through the verifying
+* `readMigrationPackage` in `@prisma-next/migration-tools/io` instead.
 */
-function readExistingManifest(manifestPath) {
+function readExistingMetadata(metadataPath) {
 	let raw;
 	try {
-		raw = readFileSync(manifestPath, "utf-8");
+		raw = readFileSync(metadataPath, "utf-8");
 	} catch {
 		return null;
 	}
 	try {
 		return JSON.parse(raw);
-	} catch {
-		return null;
+	} catch (e) {
+		throw errorInvalidJson(metadataPath, e instanceof Error ? e.message : String(e));
 	}
 }
 /**
@@ -165,20 +369,39 @@ function readExistingManifest(manifestPath) {
 * legitimate site for combining config loading, stack assembly, and
 * filesystem persistence.
 */
-function serializeMigrationToDisk(instance, migrationDir, dryRun) {
-	const manifestPath = join(migrationDir, "migration.json");
-	const { opsJson, manifestJson } = buildMigrationArtifacts(instance, readExistingManifest(manifestPath));
+function serializeMigrationToDisk(instance, migrationDir, dryRun, stdout) {
+	const metadataPath = join(migrationDir, "migration.json");
+	const { opsJson, metadataJson } = buildMigrationArtifacts(instance, readExistingMetadata(metadataPath));
 	if (dryRun) {
-		process.stdout.write(`--- migration.json ---\n${manifestJson}\n`);
-		process.stdout.write("--- ops.json ---\n");
-		process.stdout.write(`${opsJson}\n`);
+		stdout.write(`--- migration.json ---\n${metadataJson}\n`);
+		stdout.write("--- ops.json ---\n");
+		stdout.write(`${opsJson}\n`);
 		return;
 	}
 	writeFileSync(join(migrationDir, "ops.json"), opsJson);
-	writeFileSync(manifestPath, manifestJson);
-	process.stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\n`);
+	writeFileSync(metadataPath, metadataJson);
+	stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\n`);
+}
+/**
+* Inner orchestration: load config, probe-construct the migration,
+* verify target, assemble the stack, construct with the stack, persist.
+*
+* Throws `CliStructuredError` for known failure modes (config not
+* found, target mismatch); the outer `orchestrate` translates those to
+* exit 1.
+*/
+async function runMigration(importMetaUrl, MigrationClass, parsed, ctx) {
+	const migrationDir = dirname(fileURLToPath(importMetaUrl));
+	const config = await loadConfig(parsed.config);
+	const probe = new MigrationClass();
+	if (probe.targetId !== config.target.targetId) throw errorMigrationTargetMismatch({
+		migrationTargetId: probe.targetId,
+		configTargetId: config.target.targetId
+	});
+	serializeMigrationToDisk(new MigrationClass(createControlStack(config)), migrationDir, parsed.dryRun, ctx.stdout);
+	ctx.stderr;
 }
-
 //#endregion
 export { MigrationCLI };
+
 //# sourceMappingURL=migration-cli.mjs.map

package/dist/migration-cli.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"migration-cli.mjs","names":["configPath: string | undefined","raw: string"],"sources":["../src/migration-cli.ts"],"sourcesContent":["/**\n * The migration-file CLI interface: the actor invoked when the author runs\n * `node migration.ts` directly.\n *\n * Naming: this is *not* a \"migration runner\" in the apply-time sense. The\n * apply-time runner is the thing `prisma-next migration apply` uses to\n * execute migration JSON ops against a database. `MigrationCLI` is the\n * tiny CLI surface owned by an authored `migration.ts` file: parse the\n * file's argv, load the project's `prisma-next.config.ts`, assemble a\n * `ControlStack`, instantiate the migration class, and serialize.\n *\n * The user authors a migration class, then calls\n * `MigrationCLI.run(import.meta.url, MigrationClass)` at module scope\n * after the class definition. When the file is invoked as a node\n * entrypoint (`node migration.ts`), the CLI:\n *\n * 1. Detects whether the file is the direct entrypoint (no-op when imported).\n * 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`).\n * 3. Loads the project's `prisma-next.config.ts` via the same `loadConfig`\n *    the CLI commands use, walking up from the migration file's directory.\n * 4. Probe-instantiates the migration class without a stack so it can read\n *    `targetId` and verify it matches `config.target.targetId`\n *    (`PN-MIG-2006` on mismatch) before any stack-driven adapter\n *    construction runs.\n * 5. Assembles a `ControlStack` from the loaded config descriptors and\n *    constructs the migration with that stack.\n * 6. Reads any previously-scaffolded `migration.json`, then calls\n *    `buildMigrationArtifacts` from `@prisma-next/migration-tools` to\n *    produce in-memory `ops.json` + `migration.json` content. Persists\n *    the result to disk (or prints in dry-run mode).\n *\n * File I/O lives here, in `@prisma-next/cli`: this is the only place\n * that legitimately combines config loading, stack assembly, and\n * on-disk persistence. `@prisma-next/migration-tools` owns the pure\n * conversion from a `Migration` instance to artifact strings; `Migration`\n * stays a pure abstract class.\n */\n\nimport { readFileSync, writeFileSync } from 'node:fs';\nimport { fileURLToPath } from 'node:url';\nimport { CliStructuredError, errorMigrationCliInvalidConfigArg } from '@prisma-next/errors/control';\nimport { errorMigrationTargetMismatch } from '@prisma-next/errors/migration';\nimport { createControlStack } from '@prisma-next/framework-components/control';\nimport {\n  buildMigrationArtifacts,\n  isDirectEntrypoint,\n  type Migration,\n  printMigrationHelp,\n} from '@prisma-next/migration-tools/migration';\nimport type { MigrationManifest } from '@prisma-next/migration-tools/types';\nimport { dirname, join } from 'pathe';\nimport { loadConfig } from './config-loader';\n\n/**\n * Constructor shape accepted by `MigrationCLI.run`. `Migration` subclasses\n * accept an optional `ControlStack` in their constructor (each subclass\n * narrows the stack to its own family/target generics); the CLI always\n * passes one assembled from the loaded config. We use a rest-args `any[]`\n * constructor signature so that subclass constructors with narrower\n * parameter types remain assignable - constructor type compatibility in\n * TS is contravariant in the parameter, and a wider `unknown` parameter\n * on the alias side would reject any narrower subclass signature.\n *\n * The CLI only ever passes one argument (`new MigrationClass(stack)`);\n * the rest-arity is purely a type-compatibility concession for subclass\n * constructors that declare narrower parameter types, not an extension\n * point for additional construction arguments.\n */\n// biome-ignore lint/suspicious/noExplicitAny: see JSDoc - rest args with any are the idiomatic TS pattern for accepting arbitrary subclass constructor signatures\nexport type MigrationConstructor = new (...args: any[]) => Migration;\n\ninterface ParsedArgs {\n  readonly help: boolean;\n  readonly dryRun: boolean;\n  readonly configPath: string | undefined;\n}\n\n/**\n * Parse the subset of `process.argv` that `MigrationCLI.run` cares about.\n * Recognised flags: `--help`, `--dry-run`, `--config <path>` /\n * `--config=<path>`. Unknown flags are ignored to keep the surface\n * forgiving for ad-hoc tooling that wraps a migration file.\n *\n * Throws `errorMigrationCliInvalidConfigArg` (`PN-CLI-4012`) when\n * `--config` is missing its path argument or is followed by another flag\n * (e.g. `--config --dry-run`); silently consuming the next flag would\n * either drop dry-run handling or serialize against the wrong project.\n *\n * NOTE: this hand-rolled parser is a known wart, tracked separately by\n * TML-2318 (\"Migration CLI: replace handrolled arg parser with shared\n * CLI library\"). Until that lands the surface is intentionally tiny.\n */\nfunction parseArgs(argv: readonly string[]): ParsedArgs {\n  let help = false;\n  let dryRun = false;\n  let configPath: string | undefined;\n\n  for (let i = 0; i < argv.length; i++) {\n    const arg = argv[i]!;\n    if (arg === '--help' || arg === '-h') {\n      help = true;\n    } else if (arg === '--dry-run') {\n      dryRun = true;\n    } else if (arg === '--config') {\n      const next = argv[i + 1];\n      if (next === undefined) {\n        throw errorMigrationCliInvalidConfigArg();\n      }\n      if (next.startsWith('-')) {\n        throw errorMigrationCliInvalidConfigArg({ nextToken: next });\n      }\n      configPath = next;\n      i++;\n    } else if (arg.startsWith('--config=')) {\n      configPath = arg.slice('--config='.length);\n    }\n  }\n\n  return { help, dryRun, configPath };\n}\n\n/**\n * The CLI surface invoked by an authored `migration.ts` file. Exposed as\n * a class with a static `run` method (rather than a free function) to\n * give the concept a stable identity in the ubiquitous language: this is\n * the \"migration-file CLI\", distinct from the apply-time runner that\n * executes migration JSON ops.\n *\n * Currently a single static method. Future surface (e.g. a programmatic\n * `MigrationCLI.serializeOnly(...)` for tests, or extra subcommands) can\n * land here without changing the import shape used by every authored\n * migration.\n */\n// biome-ignore lint/complexity/noStaticOnlyClass: see JSDoc - intentional class facade for the migration-file CLI surface; future methods will share state derived from argv/config.\nexport class MigrationCLI {\n  /**\n   * Orchestrates a class-flow `migration.ts` script run. Awaitable:\n   * callers may `await MigrationCLI.run(...)` to surface async failures\n   * from config loading, but the typical usage pattern (top-level call\n   * after the class definition) does not require awaiting because\n   * node's module evaluation keeps the promise alive until completion.\n   *\n   * Any throwable inside this function must surface through the internal\n   * try/catch — script callers do not await, so an unhandled rejection\n   * would silently exit 0. Treat the try/catch as load-bearing for the\n   * no-await usage pattern.\n   */\n  static async run(importMetaUrl: string, MigrationClass: MigrationConstructor): Promise<void> {\n    if (!importMetaUrl) return;\n    if (!isDirectEntrypoint(importMetaUrl)) return;\n\n    try {\n      const args = parseArgs(process.argv.slice(2));\n\n      if (args.help) {\n        printMigrationHelp();\n        return;\n      }\n\n      const migrationFile = fileURLToPath(importMetaUrl);\n      const migrationDir = dirname(migrationFile);\n\n      const config = await loadConfig(args.configPath);\n\n      // Probe-instantiate without a stack so we can read `targetId` before\n      // any target-specific constructor side effects (e.g.\n      // `PostgresMigration`'s `stack.adapter.create(stack)`) run. Concrete\n      // subclasses are required to accept the no-arg form; the abstract\n      // `Migration` constructor declares `stack?` and target subclasses\n      // (Postgres, Mongo) propagate that optionality. This makes the\n      // target-mismatch guard fail fast with `PN-MIG-2006` before any\n      // stack-driven adapter construction begins, even if the wrong-target\n      // adapter's `create` would otherwise succeed and silently misshapen\n      // the stored adapter cast.\n      const probe = new MigrationClass();\n\n      if (probe.targetId !== config.target.targetId) {\n        throw errorMigrationTargetMismatch({\n          migrationTargetId: probe.targetId,\n          configTargetId: config.target.targetId,\n        });\n      }\n\n      const stack = createControlStack(config);\n      const instance = new MigrationClass(stack);\n\n      serializeMigrationToDisk(instance, migrationDir, args.dryRun);\n    } catch (err) {\n      if (CliStructuredError.is(err)) {\n        process.stderr.write(`${err.message}: ${err.why}\\n`);\n      } else {\n        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\\n`);\n      }\n      process.exitCode = 1;\n    }\n  }\n}\n\n/**\n * Read a previously-scaffolded `migration.json` from disk, returning\n * `null` when the file is missing or unparseable. The CLI feeds this into\n * `buildMigrationArtifacts` so the pure builder can preserve fields owned\n * by `migration plan` (contract bookends, hints, labels, `createdAt`)\n * across re-emits.\n */\nfunction readExistingManifest(manifestPath: string): Partial<MigrationManifest> | null {\n  let raw: string;\n  try {\n    raw = readFileSync(manifestPath, 'utf-8');\n  } catch {\n    return null;\n  }\n  try {\n    return JSON.parse(raw) as Partial<MigrationManifest>;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Persist a migration instance's artifacts to `migrationDir`. In\n * `dryRun` mode the artifacts are printed to stdout (with the same\n * `--- migration.json --- / --- ops.json ---` framing the legacy\n * `serializeMigration` helper used) and no files are written. Otherwise\n * `ops.json` and `migration.json` are written next to `migration.ts` and\n * a confirmation line is printed.\n *\n * File I/O lives in the CLI rather than `@prisma-next/migration-tools`\n * so the migration-tools package stays focused on the pure\n * `Migration` → in-memory artifact conversion. The CLI is the only\n * legitimate site for combining config loading, stack assembly, and\n * filesystem persistence.\n */\nfunction serializeMigrationToDisk(\n  instance: Migration,\n  migrationDir: string,\n  dryRun: boolean,\n): void {\n  const manifestPath = join(migrationDir, 'migration.json');\n  const existing = readExistingManifest(manifestPath);\n  const { opsJson, manifestJson } = buildMigrationArtifacts(instance, existing);\n\n  if (dryRun) {\n    process.stdout.write(`--- migration.json ---\\n${manifestJson}\\n`);\n    process.stdout.write('--- ops.json ---\\n');\n    process.stdout.write(`${opsJson}\\n`);\n    return;\n  }\n\n  writeFileSync(join(migrationDir, 'ops.json'), opsJson);\n  writeFileSync(manifestPath, manifestJson);\n\n  process.stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\\n`);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4FA,SAAS,UAAU,MAAqC;CACtD,IAAI,OAAO;CACX,IAAI,SAAS;CACb,IAAIA;AAEJ,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,MAAM,KAAK;AACjB,MAAI,QAAQ,YAAY,QAAQ,KAC9B,QAAO;WACE,QAAQ,YACjB,UAAS;WACA,QAAQ,YAAY;GAC7B,MAAM,OAAO,KAAK,IAAI;AACtB,OAAI,SAAS,OACX,OAAM,mCAAmC;AAE3C,OAAI,KAAK,WAAW,IAAI,CACtB,OAAM,kCAAkC,EAAE,WAAW,MAAM,CAAC;AAE9D,gBAAa;AACb;aACS,IAAI,WAAW,YAAY,CACpC,cAAa,IAAI,MAAM,EAAmB;;AAI9C,QAAO;EAAE;EAAM;EAAQ;EAAY;;;;;;;;;;;;;;AAgBrC,IAAa,eAAb,MAA0B;;;;;;;;;;;;;CAaxB,aAAa,IAAI,eAAuB,gBAAqD;AAC3F,MAAI,CAAC,cAAe;AACpB,MAAI,CAAC,mBAAmB,cAAc,CAAE;AAExC,MAAI;GACF,MAAM,OAAO,UAAU,QAAQ,KAAK,MAAM,EAAE,CAAC;AAE7C,OAAI,KAAK,MAAM;AACb,wBAAoB;AACpB;;GAIF,MAAM,eAAe,QADC,cAAc,cAAc,CACP;GAE3C,MAAM,SAAS,MAAM,WAAW,KAAK,WAAW;GAYhD,MAAM,QAAQ,IAAI,gBAAgB;AAElC,OAAI,MAAM,aAAa,OAAO,OAAO,SACnC,OAAM,6BAA6B;IACjC,mBAAmB,MAAM;IACzB,gBAAgB,OAAO,OAAO;IAC/B,CAAC;AAMJ,4BAFiB,IAAI,eADP,mBAAmB,OAAO,CACE,EAEP,cAAc,KAAK,OAAO;WACtD,KAAK;AACZ,OAAI,mBAAmB,GAAG,IAAI,CAC5B,SAAQ,OAAO,MAAM,GAAG,IAAI,QAAQ,IAAI,IAAI,IAAI,IAAI;OAEpD,SAAQ,OAAO,MAAM,GAAG,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,CAAC,IAAI;AAE/E,WAAQ,WAAW;;;;;;;;;;;AAYzB,SAAS,qBAAqB,cAAyD;CACrF,IAAIC;AACJ,KAAI;AACF,QAAM,aAAa,cAAc,QAAQ;SACnC;AACN,SAAO;;AAET,KAAI;AACF,SAAO,KAAK,MAAM,IAAI;SAChB;AACN,SAAO;;;;;;;;;;;;;;;;;AAkBX,SAAS,yBACP,UACA,cACA,QACM;CACN,MAAM,eAAe,KAAK,cAAc,iBAAiB;CAEzD,MAAM,EAAE,SAAS,iBAAiB,wBAAwB,UADzC,qBAAqB,aAAa,CAC0B;AAE7E,KAAI,QAAQ;AACV,UAAQ,OAAO,MAAM,2BAA2B,aAAa,IAAI;AACjE,UAAQ,OAAO,MAAM,qBAAqB;AAC1C,UAAQ,OAAO,MAAM,GAAG,QAAQ,IAAI;AACpC;;AAGF,eAAc,KAAK,cAAc,WAAW,EAAE,QAAQ;AACtD,eAAc,cAAc,aAAa;AAEzC,SAAQ,OAAO,MAAM,sCAAsC,aAAa,IAAI"}
+{"version":3,"file":"migration-cli.mjs","names":[],"sources":["../src/migration-cli.ts"],"sourcesContent":["/**\n * The migration-file CLI interface: the actor invoked when the author runs\n * `node migration.ts` directly.\n *\n * Naming: this is *not* a \"migration runner\" in the apply-time sense. The\n * apply-time runner is the thing `prisma-next migration apply` uses to\n * execute migration JSON ops against a database. `MigrationCLI` is the\n * tiny CLI surface owned by an authored `migration.ts` file: parse the\n * file's argv, load the project's `prisma-next.config.ts`, assemble a\n * `ControlStack`, instantiate the migration class, and serialize.\n *\n * The user authors a migration class, then calls\n * `MigrationCLI.run(import.meta.url, MigrationClass)` at module scope\n * after the class definition. When the file is invoked as a node\n * entrypoint (`node migration.ts`), the CLI:\n *\n * 1. Detects whether the file is the direct entrypoint (no-op when imported).\n * 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`) via\n *    [clipanion](https://github.com/arcanis/clipanion).\n * 3. Loads the project's `prisma-next.config.ts` via the same `loadConfig`\n *    the CLI commands use, walking up from the migration file's directory.\n * 4. Probe-instantiates the migration class without a stack so it can read\n *    `targetId` and verify it matches `config.target.targetId`\n *    (`PN-MIG-2006` on mismatch) before any stack-driven adapter\n *    construction runs.\n * 5. Assembles a `ControlStack` from the loaded config descriptors and\n *    constructs the migration with that stack.\n * 6. Reads any previously-scaffolded `migration.json`, then calls\n *    `buildMigrationArtifacts` from `@prisma-next/migration-tools` to\n *    produce in-memory `ops.json` + `migration.json` content. Persists\n *    the result to disk (or prints in dry-run mode).\n *\n * File I/O lives here, in `@prisma-next/cli`: this is the only place\n * that legitimately combines config loading, stack assembly, and\n * on-disk persistence. `@prisma-next/migration-tools` owns the pure\n * conversion from a `Migration` instance to artifact strings; `Migration`\n * stays a pure abstract class.\n *\n * Parser library: clipanion (chosen over Commander/citty/`node:util.parseArgs`\n * for its in-process testability and runtime-agnostic execution surface; see\n * `docs/architecture docs/research/commander-friction-points.md` for the\n * evaluation rubric and the durable rationale that drove the choice).\n */\n\nimport { readFileSync, realpathSync, writeFileSync } from 'node:fs';\nimport type { Writable } from 'node:stream';\nimport { fileURLToPath } from 'node:url';\nimport {\n  CliStructuredError,\n  errorMigrationCliInvalidConfigArg,\n  errorMigrationCliUnknownFlag,\n} from '@prisma-next/errors/control';\nimport { errorMigrationTargetMismatch } from '@prisma-next/errors/migration';\nimport { createControlStack } from '@prisma-next/framework-components/control';\nimport { errorInvalidJson, MigrationToolsError } from '@prisma-next/migration-tools/errors';\nimport type { MigrationMetadata } from '@prisma-next/migration-tools/metadata';\nimport { buildMigrationArtifacts, type Migration } from '@prisma-next/migration-tools/migration';\nimport { Cli, Command, Option, UsageError } from 'clipanion';\nimport { dirname, join } from 'pathe';\nimport { loadConfig } from './config-loader';\n\n/**\n * Constructor shape accepted by `MigrationCLI.run`. `Migration` subclasses\n * accept an optional `ControlStack` in their constructor (each subclass\n * narrows the stack to its own family/target generics); the CLI always\n * passes one assembled from the loaded config. We use a rest-args `any[]`\n * constructor signature so that subclass constructors with narrower\n * parameter types remain assignable - constructor type compatibility in\n * TS is contravariant in the parameter, and a wider `unknown` parameter\n * on the alias side would reject any narrower subclass signature.\n *\n * The CLI only ever passes one argument (`new MigrationClass(stack)`);\n * the rest-arity is purely a type-compatibility concession for subclass\n * constructors that declare narrower parameter types, not an extension\n * point for additional construction arguments.\n */\n// biome-ignore lint/suspicious/noExplicitAny: see JSDoc - rest args with any are the idiomatic TS pattern for accepting arbitrary subclass constructor signatures\nexport type MigrationConstructor = new (...args: any[]) => Migration;\n\n/**\n * Stream surface accepted by `MigrationCLI.run`'s `options.stdout` /\n * `options.stderr`. Aliases node's `Writable` because clipanion's\n * `BaseContext.stdout`/`stderr` are typed as `Writable`, and the CLI\n * forwards the injected streams into clipanion's context.\n *\n * `process.stdout` and `process.stderr` are `Writable`-shaped, so the\n * default-fallback path remains a no-op for existing two-argument\n * callers like `MigrationCLI.run(import.meta.url, MyMigration)`.\n *\n * Tests inject a `Writable` subclass that captures chunks for\n * assertions.\n */\nexport type MigrationCliWritable = Writable;\n\n/**\n * Flags exposed by the migration-file CLI.\n *\n * Must stay in sync with the `Option` declarations on\n * `MigrationFileCommand` below. This list is rendered in the\n * `errorMigrationCliUnknownFlag` envelope's `fix` text and `meta`,\n * so order matters for user-visible output (declaration order is the\n * order users see when they run `--help`).\n */\nconst KNOWN_FLAGS: readonly string[] = ['--help', '--dry-run', '--config'];\n\n/**\n * The clipanion command that owns the migration-file CLI's option\n * declarations. The class is internal — `MigrationCLI.run` is the\n * stable public surface. Adding a flag here automatically updates\n * `--help` rendering and the `KNOWN_FLAGS` list (the latter must be\n * updated in tandem).\n */\nclass MigrationFileCommand extends Command {\n  static override paths = [Command.Default];\n\n  static override usage = Command.Usage({\n    description: 'Self-emit ops.json and migration.json from a class-flow migration',\n    details: `\n      Loads the project's prisma-next.config.ts, assembles a ControlStack\n      from the configured target/adapter/extensions, and serializes the\n      migration's operations + metadata next to this file.\n    `,\n    examples: [\n      ['Self-emit ops.json + migration.json next to migration.ts', '$0'],\n      ['Preview without writing files', '$0 --dry-run'],\n      ['Use a non-default config path', '$0 --config ./custom.config.ts'],\n    ],\n  });\n\n  dryRun = Option.Boolean('--dry-run', false, {\n    description: 'Print operations to stdout without writing files',\n  });\n\n  config = Option.String('--config', {\n    description: 'Path to prisma-next.config.ts',\n  });\n\n  /**\n   * Unused: orchestration runs inside `MigrationCLI.run` so error\n   * routing stays under our control (clipanion's `cli.run` writes\n   * error output to `context.stdout`, but our contract requires\n   * structured errors on stderr). `cli.process` is used to parse\n   * argv into a populated `MigrationFileCommand` instance whose\n   * fields drive the orchestration directly.\n   */\n  override async execute(): Promise<number> {\n    return 0;\n  }\n}\n\n/**\n * The CLI surface invoked by an authored `migration.ts` file. Exposed as\n * a class with a static `run` method (rather than a free function) to\n * give the concept a stable identity in the ubiquitous language: this is\n * the \"migration-file CLI\", distinct from the apply-time runner that\n * executes migration JSON ops.\n *\n * Currently a single static method. Future surface (e.g. a programmatic\n * `MigrationCLI.serializeOnly(...)` for tests, or extra subcommands) can\n * land here without changing the import shape used by every authored\n * migration.\n */\n// biome-ignore lint/complexity/noStaticOnlyClass: see JSDoc - intentional class facade for the migration-file CLI surface; future methods will share state derived from argv/config.\nexport class MigrationCLI {\n  /**\n   * Orchestrates a class-flow `migration.ts` script run.\n   *\n   * The third argument is the in-process testability surface: callers\n   * (and tests) may inject `argv`, `stdout`, and `stderr` instead of\n   * relying on `process.argv` / `process.stdout` / `process.stderr`.\n   * Each option defaults to its `process` global when omitted, so\n   * existing two-argument call sites\n   * (`MigrationCLI.run(import.meta.url, MyMigration)`) continue to\n   * compile and behave identically.\n   *\n   * Returns the exit code so the caller can branch on it. Also writes\n   * the same code to `process.exitCode` so script-style callers that\n   * don't await the return value still surface a non-zero exit when\n   * something fails.\n   *\n   * Exit codes:\n   * - 0 — success, or `--help`, or imported-not-entrypoint no-op.\n   * - 1 — runtime/orchestration error (config not found, target\n   *   mismatch, etc.).\n   * - 2 — usage error (unknown flag, malformed `--config`). Aligns\n   *   with `docs/CLI Style Guide.md` § Exit Codes.\n   */\n  static async run(\n    importMetaUrl: string,\n    MigrationClass: MigrationConstructor,\n    options: {\n      readonly argv?: readonly string[];\n      readonly stdout?: MigrationCliWritable;\n      readonly stderr?: MigrationCliWritable;\n    } = {},\n  ): Promise<number> {\n    if (!importMetaUrl) {\n      return 0;\n    }\n\n    const argv = options.argv ?? process.argv;\n    const stdout = options.stdout ?? process.stdout;\n    const stderr = options.stderr ?? process.stderr;\n\n    if (!isDirectEntrypoint(importMetaUrl, argv)) {\n      return 0;\n    }\n\n    const exitCode = await orchestrate(importMetaUrl, MigrationClass, {\n      argv,\n      stdout,\n      stderr,\n    });\n    // Preserve any pre-existing non-zero `process.exitCode` set by code\n    // running alongside `MigrationCLI.run` (an unhandled rejection\n    // upstream, an explicit `process.exitCode = N` from another\n    // module). Overwriting it with our success would mask the upstream\n    // failure for script-style callers that don't await the return\n    // value. Failures we return here are still surfaced — non-zero\n    // codes always win over the prior status — but successes never\n    // clear it.\n    if (exitCode !== 0 || !process.exitCode) {\n      process.exitCode = exitCode;\n    }\n    return exitCode;\n  }\n}\n\n/**\n * Argv-aware variant of the entrypoint guard. The shared\n * `@prisma-next/migration-tools` helper of the same name reads\n * `process.argv[1]` directly, which doesn't compose with the new\n * in-process testability surface (tests inject `argv` without mutating\n * the process global). Inlined here so the migration-file CLI's check\n * follows the injected `argv[1]` consistently.\n */\nfunction isDirectEntrypoint(importMetaUrl: string, argv: readonly string[]): boolean {\n  const argv1 = argv[1];\n  if (!argv1) {\n    return false;\n  }\n  try {\n    return realpathSync(fileURLToPath(importMetaUrl)) === realpathSync(argv1);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Argv-and-stream-driven orchestration body. Pulled out of the static\n * method so the entrypoint guard / process-default plumbing stays\n * separate from the parse + load + serialize steps.\n */\nasync function orchestrate(\n  importMetaUrl: string,\n  MigrationClass: MigrationConstructor,\n  ctx: {\n    readonly argv: readonly string[];\n    readonly stdout: MigrationCliWritable;\n    readonly stderr: MigrationCliWritable;\n  },\n): Promise<number> {\n  const cli = Cli.from([MigrationFileCommand], {\n    binaryName: 'migration.ts',\n    binaryLabel: 'Migration file CLI',\n  });\n\n  const input = ctx.argv.slice(2);\n\n  // Pre-scan for malformed `--config` (no value, or value-shaped-as-flag)\n  // before delegating to clipanion. The legacy parser surfaced both as\n  // `errorMigrationCliInvalidConfigArg` (`PN-CLI-4012`); pre-scanning\n  // here keeps that contract independent of how clipanion classifies\n  // the error internally (it variably throws `UnknownSyntaxError` or\n  // accepts the flag-shaped token as the value depending on what other\n  // options are registered).\n  const configError = detectInvalidConfig(input);\n  if (configError) {\n    writeStructuredError(ctx.stderr, configError);\n    return 2;\n  }\n\n  let parsed: MigrationFileCommand;\n  try {\n    const command = cli.process({\n      input: [...input],\n      context: { stdout: ctx.stdout, stderr: ctx.stderr },\n    });\n    if (!(command instanceof MigrationFileCommand)) {\n      // The only registered command class is `MigrationFileCommand`;\n      // any other concrete type indicates clipanion emitted its\n      // built-in `HelpCommand`. Render usage directly so we don't\n      // depend on calling `cli.run` (which routes errors to stdout —\n      // wrong stream for our contract).\n      ctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));\n      return 0;\n    }\n    parsed = command;\n  } catch (err) {\n    return renderParseError(err, input, ctx.stderr);\n  }\n\n  if (parsed.help) {\n    ctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));\n    return 0;\n  }\n\n  try {\n    await runMigration(importMetaUrl, MigrationClass, parsed, ctx);\n    return 0;\n  } catch (err) {\n    if (CliStructuredError.is(err)) {\n      writeStructuredError(ctx.stderr, err);\n    } else if (MigrationToolsError.is(err)) {\n      // Migration-tools errors (e.g. `errorInvalidJson` thrown by\n      // `readExistingMetadata` when migration.json is malformed) carry\n      // their own `code`/`why`/`fix` shape. Render them with the same\n      // visual structure as `CliStructuredError` so consumers grepping\n      // for `MIGRATION.<CODE>` see consistent output across surfaces.\n      const fix = err.fix ? `\\n${err.fix}` : '';\n      ctx.stderr.write(`${err.code}: ${err.message}\\n${err.why}${fix}\\n`);\n    } else {\n      ctx.stderr.write(`${err instanceof Error ? err.message : String(err)}\\n`);\n    }\n    return 1;\n  }\n}\n\n/**\n * Returns an `errorMigrationCliInvalidConfigArg` envelope when `input`\n * contains a malformed `--config`:\n *\n * - `--config` as the last token (no value follows).\n * - `--config <flag>` where `<flag>` starts with `-` (silently\n *   consuming the next flag would either drop the flag or serialize\n *   against the wrong project).\n * - `--config <empty>` where the value is the empty string. Shells\n *   expand `--config \"\"` (or `--config \"$UNSET_VAR\"`) into a real\n *   empty argv token; treating that as a usage error here surfaces\n *   `PN-CLI-4012` instead of a less actionable loader error on an\n *   empty path.\n * - `--config=` (the equals form with an empty value). Same shape as\n *   the empty-string case above; the user expressed intent to override\n *   the config path but the override is empty.\n *\n * `--config=<value>` and `--config <value>` with a non-empty value are\n * both valid (and the equals form's value is allowed to start with\n * `-` — the `=` makes the binding explicit).\n */\nfunction detectInvalidConfig(input: readonly string[]): CliStructuredError | null {\n  for (let i = 0; i < input.length; i++) {\n    const token = input[i];\n    if (token === '--config') {\n      const next = input[i + 1];\n      if (next === undefined || next === '') {\n        return errorMigrationCliInvalidConfigArg();\n      }\n      if (next.startsWith('-')) {\n        return errorMigrationCliInvalidConfigArg({ nextToken: next });\n      }\n      continue;\n    }\n    if (token === '--config=') {\n      return errorMigrationCliInvalidConfigArg();\n    }\n  }\n  return null;\n}\n\n/**\n * Translate clipanion's parse-time errors into the project's structured\n * error envelopes.\n *\n * - `UnknownSyntaxError` covers both unknown flags (`--frobnicate`) and\n *   the bare-trailing `--config` case (where arity-1 needs a value but\n *   none was supplied). Distinguished by inspecting the input array.\n * - `UsageError` covers schema/validator failures from typanion. None\n *   of the migration-file CLI's options have validators today, but we\n *   still translate it as a usage error (exit 2) for forward-compat.\n * - Anything else re-throws — caller's outer catch will surface it as\n *   exit 1 (runtime error).\n */\nfunction renderParseError(\n  err: unknown,\n  input: readonly string[],\n  stderr: MigrationCliWritable,\n): number {\n  if (isUnknownSyntaxError(err)) {\n    const flag = findOffendingFlag(input);\n    writeStructuredError(stderr, errorMigrationCliUnknownFlag({ flag, knownFlags: KNOWN_FLAGS }));\n    return 2;\n  }\n  if (err instanceof UsageError) {\n    // typanion validator failures and similar usage errors. None of\n    // the migration-file CLI's options have validators today, so this\n    // branch is forward-compat scaffolding — kept so that a future\n    // option declaration with a validator routes through the same PN\n    // envelope path rather than escaping as exit 1.\n    writeStructuredError(stderr, errorMigrationCliInvalidConfigArg({ nextToken: err.message }));\n    return 2;\n  }\n  throw err;\n}\n\n/**\n * Duck-type check for clipanion's `UnknownSyntaxError`: the class is\n * thrown by the parser but is not re-exported from the package's main\n * entry (only `UsageError` is — see clipanion's `advanced/index.d.ts`).\n * Identified by `name === 'UnknownSyntaxError'` and the\n * `clipanion.type === 'none'` discriminator that clipanion's\n * `ErrorWithMeta` interface guarantees.\n */\nfunction isUnknownSyntaxError(err: unknown): err is Error {\n  if (!(err instanceof Error) || err.name !== 'UnknownSyntaxError') {\n    return false;\n  }\n  // clipanion's `ErrorWithMeta` interface guarantees a `clipanion` field with\n  // a `type` discriminator on every error it throws. Read it via a structural\n  // shape rather than importing the class (it's not re-exported from the\n  // package main).\n  const meta = (err as { clipanion?: { type?: string } }).clipanion;\n  return typeof meta === 'object' && meta !== null && meta.type === 'none';\n}\n\n/**\n * Best-effort: pull the first input token that doesn't match a known\n * flag. Falls back to the first token when we can't pinpoint it. The\n * returned name is rendered into the user-visible PN-CLI-4013 envelope\n * (`Unknown flag \\`<name>\\``) and round-tripped via `meta.flag` so\n * agent consumers can render their own \"did you mean\" suggestions.\n */\nfunction findOffendingFlag(input: readonly string[]): string {\n  for (const token of input) {\n    if (!token.startsWith('-')) {\n      continue;\n    }\n    const head = token.split('=', 1)[0] ?? token;\n    if (!KNOWN_FLAGS.includes(head) && head !== '-h') {\n      return head;\n    }\n  }\n  return input[0] ?? '';\n}\n\n/**\n * Write a `CliStructuredError` envelope to the given stream. Format\n * matches the legacy hand-rolled writer (`message: why`) so the rest of\n * the project's error rendering stays consistent across surfaces. The\n * full PN code (`PN-<domain>-<code>`) is included so consumers can\n * grep for stable identifiers.\n */\nfunction writeStructuredError(stream: MigrationCliWritable, err: CliStructuredError): void {\n  const envelope = err.toEnvelope();\n  const why = envelope.why ?? envelope.summary;\n  const fix = envelope.fix ? `\\n${envelope.fix}` : '';\n  stream.write(`${envelope.code}: ${envelope.summary}\\n${why}${fix}\\n`);\n}\n\n/**\n * Read a previously-scaffolded `migration.json` from disk, returning\n * `null` when the file is missing and throwing `MIGRATION.INVALID_JSON`\n * when the file is present but cannot be parsed as JSON. The CLI feeds\n * this into `buildMigrationArtifacts` so the pure builder can preserve\n * fields owned by `migration plan` (contract bookends, hints, labels,\n * `createdAt`) across re-emits.\n *\n * Author-time path: this loader still does not verify the manifest hash\n * or schema — that is the apply-time loader's job. Hash mismatch is the\n * *expected* outcome of a re-author (the developer's source changes\n * invalidate the prior hash by construction), and verification here\n * would block legitimate regenerations. Syntactic JSON-parse failure,\n * however, is now surfaced rather than swallowed: a malformed\n * `migration.json` indicates either a hand-edit gone wrong or partial\n * write, and silently rebuilding from `describe()` would discard the\n * user's on-disk content (preserved bookends, hints, labels,\n * `createdAt`) without any indication something was wrong on disk.\n * Apply-time consumers always route through the verifying\n * `readMigrationPackage` in `@prisma-next/migration-tools/io` instead.\n */\nfunction readExistingMetadata(metadataPath: string): Partial<MigrationMetadata> | null {\n  let raw: string;\n  try {\n    raw = readFileSync(metadataPath, 'utf-8');\n  } catch {\n    return null;\n  }\n  try {\n    return JSON.parse(raw) as Partial<MigrationMetadata>;\n  } catch (e) {\n    throw errorInvalidJson(metadataPath, e instanceof Error ? e.message : String(e));\n  }\n}\n\n/**\n * Persist a migration instance's artifacts to `migrationDir`. In\n * `dryRun` mode the artifacts are printed to stdout (with the same\n * `--- migration.json --- / --- ops.json ---` framing the legacy\n * `serializeMigration` helper used) and no files are written. Otherwise\n * `ops.json` and `migration.json` are written next to `migration.ts` and\n * a confirmation line is printed.\n *\n * File I/O lives in the CLI rather than `@prisma-next/migration-tools`\n * so the migration-tools package stays focused on the pure\n * `Migration` → in-memory artifact conversion. The CLI is the only\n * legitimate site for combining config loading, stack assembly, and\n * filesystem persistence.\n */\nfunction serializeMigrationToDisk(\n  instance: Migration,\n  migrationDir: string,\n  dryRun: boolean,\n  stdout: MigrationCliWritable,\n): void {\n  const metadataPath = join(migrationDir, 'migration.json');\n  const existing = readExistingMetadata(metadataPath);\n  const { opsJson, metadataJson } = buildMigrationArtifacts(instance, existing);\n\n  if (dryRun) {\n    stdout.write(`--- migration.json ---\\n${metadataJson}\\n`);\n    stdout.write('--- ops.json ---\\n');\n    stdout.write(`${opsJson}\\n`);\n    return;\n  }\n\n  writeFileSync(join(migrationDir, 'ops.json'), opsJson);\n  writeFileSync(metadataPath, metadataJson);\n\n  stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\\n`);\n}\n\n/**\n * Inner orchestration: load config, probe-construct the migration,\n * verify target, assemble the stack, construct with the stack, persist.\n *\n * Throws `CliStructuredError` for known failure modes (config not\n * found, target mismatch); the outer `orchestrate` translates those to\n * exit 1.\n */\nasync function runMigration(\n  importMetaUrl: string,\n  MigrationClass: MigrationConstructor,\n  parsed: MigrationFileCommand,\n  ctx: {\n    readonly stdout: MigrationCliWritable;\n    readonly stderr: MigrationCliWritable;\n  },\n): Promise<void> {\n  const migrationFile = fileURLToPath(importMetaUrl);\n  const migrationDir = dirname(migrationFile);\n\n  const config = await loadConfig(parsed.config);\n\n  // Probe-instantiate without a stack so we can read `targetId` before\n  // any target-specific constructor side effects (e.g.\n  // `PostgresMigration`'s `stack.adapter.create(stack)`) run. Concrete\n  // subclasses are required to accept the no-arg form; the abstract\n  // `Migration` constructor declares `stack?` and target subclasses\n  // (Postgres, Mongo) propagate that optionality. This makes the\n  // target-mismatch guard fail fast with `PN-MIG-2006` before any\n  // stack-driven adapter construction begins, even if the wrong-target\n  // adapter's `create` would otherwise succeed and silently misshapen\n  // the stored adapter cast.\n  const probe = new MigrationClass();\n\n  if (probe.targetId !== config.target.targetId) {\n    throw errorMigrationTargetMismatch({\n      migrationTargetId: probe.targetId,\n      configTargetId: config.target.targetId,\n    });\n  }\n\n  const stack = createControlStack(config);\n  const instance = new MigrationClass(stack);\n\n  serializeMigrationToDisk(instance, migrationDir, parsed.dryRun, ctx.stdout);\n  void ctx.stderr;\n}\n"],"mappings":"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"}

package/dist/{migration-command-scaffold-B3B09et6.mjs → migration-command-scaffold-B5dORFEv.mjs}

@@ -1,13 +1,12 @@
-import { t as loadConfig } from "./config-loader-C25b63rJ.mjs";
-import { _ as errorUnexpected, a as errorContractValidationFailed, c as errorDriverRequired, h as errorTargetMigrationNotSupported, l as errorFileNotFound, o as errorDatabaseConnectionRequired } from "./cli-errors-Cd79vmTH.mjs";
-import { t as createControlClient } from "./client-CrsnY58k.mjs";
-import { _ as formatStyledHeader, a as maskConnectionUrl, n as addGlobalOptions, s as resolveContractPath } from "./result-handler-Ba3zWQsI.mjs";
-import { t as createProgressAdapter } from "./progress-adapter-DvQWB1nK.mjs";
+import { t as loadConfig } from "./config-loader-B6sJjXTv.mjs";
+import { _ as errorUnexpected, a as errorContractValidationFailed, c as errorDriverRequired, h as errorTargetMigrationNotSupported, l as errorFileNotFound, o as errorDatabaseConnectionRequired } from "./cli-errors-D3_sMh2K.mjs";
+import { c as resolveContractPath, o as maskConnectionUrl, t as addGlobalOptions, y as formatStyledHeader } from "./command-helpers-BeZHkxV8.mjs";
+import { t as createProgressAdapter } from "./progress-adapter-DFfvZcYL.mjs";
+import { t as createControlClient } from "./client-qVH-rEgd.mjs";
 import { notOk, ok } from "@prisma-next/utils/result";
-import { hasMigrations } from "@prisma-next/framework-components/control";
 import { readFile } from "node:fs/promises";
+import { hasMigrations } from "@prisma-next/framework-components/control";
 import { relative, resolve } from "node:path";
-
 //#region src/utils/migration-command-scaffold.ts
 /**
 * Prepares the shared context for migration commands (db init, db update).
@@ -99,7 +98,7 @@ function addMigrationCommandOptions(command) {
 	addGlobalOptions(command);
 	return command.option("--db <url>", "Database connection string").option("--config <path>", "Path to prisma-next.config.ts").option("--dry-run", "Preview planned operations without applying", false);
 }
-
 //#endregion
 export { prepareMigrationContext as n, addMigrationCommandOptions as t };
-//# sourceMappingURL=migration-command-scaffold-B3B09et6.mjs.map
+
+//# sourceMappingURL=migration-command-scaffold-B5dORFEv.mjs.map

package/dist/migration-command-scaffold-B5dORFEv.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-command-scaffold-B5dORFEv.mjs","names":[],"sources":["../src/utils/migration-command-scaffold.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport { relative, resolve } from 'node:path';\nimport { hasMigrations } from '@prisma-next/framework-components/control';\nimport { notOk, ok, type Result } from '@prisma-next/utils/result';\nimport type { Command } from 'commander';\nimport { loadConfig } from '../config-loader';\nimport { createControlClient } from '../control-api/client';\nimport type { ControlClient } from '../control-api/types';\nimport {\n  type CliStructuredError,\n  errorContractValidationFailed,\n  errorDatabaseConnectionRequired,\n  errorDriverRequired,\n  errorFileNotFound,\n  errorTargetMigrationNotSupported,\n  errorUnexpected,\n} from './cli-errors';\nimport { addGlobalOptions, maskConnectionUrl, resolveContractPath } from './command-helpers';\nimport { formatStyledHeader } from './formatters/styled';\nimport type { GlobalFlags } from './global-flags';\nimport { createProgressAdapter } from './progress-adapter';\nimport type { TerminalUI } from './terminal-ui';\n\n/**\n * Resolved context for a migration command.\n * Contains everything needed to invoke a control-api operation.\n */\nexport interface MigrationContext {\n  readonly client: ControlClient;\n  readonly contractJson: Record<string, unknown>;\n  readonly dbConnection: unknown;\n  readonly onProgress: ReturnType<typeof createProgressAdapter>;\n  readonly configPath: string;\n  readonly contractPath: string;\n  readonly contractPathAbsolute: string;\n  readonly config: Awaited<ReturnType<typeof loadConfig>>;\n}\n\n/**\n * Command-specific configuration for the shared scaffold.\n */\nexport interface MigrationCommandDescriptor {\n  readonly commandName: string;\n  readonly description: string;\n  readonly url: string;\n}\n\n/**\n * Prepares the shared context for migration commands (db init, db update).\n *\n * Handles: config loading, contract file reading, JSON parsing, connection resolution,\n * driver/migration-support validation, client creation, and header output.\n *\n * Returns a Result with either the resolved context or a structured error.\n */\nexport async function prepareMigrationContext(\n  options: { readonly db?: string; readonly config?: string; readonly dryRun?: boolean },\n  flags: GlobalFlags,\n  ui: TerminalUI,\n  descriptor: MigrationCommandDescriptor,\n): Promise<Result<MigrationContext, CliStructuredError>> {\n  // Load config\n  const config = await loadConfig(options.config);\n  const configPath = options.config\n    ? relative(process.cwd(), resolve(options.config))\n    : 'prisma-next.config.ts';\n  const contractPathAbsolute = resolveContractPath(config);\n  const contractPath = relative(process.cwd(), contractPathAbsolute);\n\n  // Output header to stderr (decoration)\n  if (!flags.json && !flags.quiet) {\n    const details: Array<{ label: string; value: string }> = [\n      { label: 'config', value: configPath },\n      { label: 'contract', value: contractPath },\n    ];\n    if (options.db) {\n      details.push({ label: 'database', value: maskConnectionUrl(options.db) });\n    }\n    if (options.dryRun) {\n      details.push({ label: 'mode', value: 'dry run' });\n    }\n    const header = formatStyledHeader({\n      command: descriptor.commandName,\n      description: descriptor.description,\n      url: descriptor.url,\n      details,\n      flags,\n    });\n    ui.stderr(header);\n  }\n\n  // Load contract file\n  let contractJsonContent: string;\n  try {\n    contractJsonContent = await readFile(contractPathAbsolute, 'utf-8');\n  } catch (error) {\n    if (error instanceof Error && (error as { code?: string }).code === 'ENOENT') {\n      return notOk(\n        errorFileNotFound(contractPathAbsolute, {\n          why: `Contract file not found at ${contractPathAbsolute}`,\n          fix: `Run \\`prisma-next contract emit\\` to generate ${contractPath}, or update \\`config.contract.output\\` in ${configPath}`,\n        }),\n      );\n    }\n    return notOk(\n      errorUnexpected(error instanceof Error ? error.message : String(error), {\n        why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}`,\n      }),\n    );\n  }\n\n  // Parse contract JSON\n  let contractJson: Record<string, unknown>;\n  try {\n    contractJson = JSON.parse(contractJsonContent) as Record<string, unknown>;\n  } catch (error) {\n    return notOk(\n      errorContractValidationFailed(\n        `Contract JSON is invalid: ${error instanceof Error ? error.message : String(error)}`,\n        { where: { path: contractPathAbsolute } },\n      ),\n    );\n  }\n\n  // Resolve database connection (--db flag or config.db.connection)\n  const dbConnection = options.db ?? config.db?.connection;\n  if (!dbConnection) {\n    return notOk(\n      errorDatabaseConnectionRequired({\n        why: `Database connection is required for ${descriptor.commandName} (set db.connection in ${configPath}, or pass --db <url>)`,\n        commandName: descriptor.commandName,\n      }),\n    );\n  }\n\n  // Check for driver\n  if (!config.driver) {\n    return notOk(\n      errorDriverRequired({ why: `Config.driver is required for ${descriptor.commandName}` }),\n    );\n  }\n\n  if (!hasMigrations(config.target)) {\n    return notOk(\n      errorTargetMigrationNotSupported({\n        why: `Target \"${config.target.id}\" does not support migrations`,\n      }),\n    );\n  }\n\n  // Create control client\n  const client = createControlClient({\n    family: config.family,\n    target: config.target,\n    adapter: config.adapter,\n    driver: config.driver,\n    extensionPacks: config.extensionPacks ?? [],\n  });\n\n  // Create progress adapter\n  const onProgress = createProgressAdapter({ ui, flags });\n\n  return ok({\n    client,\n    contractJson,\n    dbConnection,\n    onProgress,\n    configPath,\n    contractPath,\n    contractPathAbsolute,\n    config,\n  });\n}\n\n/**\n * Registers the shared CLI options for migration commands (db init, db update).\n */\nexport function addMigrationCommandOptions(command: Command): Command {\n  addGlobalOptions(command);\n  return command\n    .option('--db <url>', 'Database connection string')\n    .option('--config <path>', 'Path to prisma-next.config.ts')\n    .option('--dry-run', 'Preview planned operations without applying', false);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuDA,eAAsB,wBACpB,SACA,OACA,IACA,YACuD;CAEvD,MAAM,SAAS,MAAM,WAAW,QAAQ,OAAO;CAC/C,MAAM,aAAa,QAAQ,SACvB,SAAS,QAAQ,KAAK,EAAE,QAAQ,QAAQ,OAAO,CAAC,GAChD;CACJ,MAAM,uBAAuB,oBAAoB,OAAO;CACxD,MAAM,eAAe,SAAS,QAAQ,KAAK,EAAE,qBAAqB;CAGlE,IAAI,CAAC,MAAM,QAAQ,CAAC,MAAM,OAAO;EAC/B,MAAM,UAAmD,CACvD;GAAE,OAAO;GAAU,OAAO;GAAY,EACtC;GAAE,OAAO;GAAY,OAAO;GAAc,CAC3C;EACD,IAAI,QAAQ,IACV,QAAQ,KAAK;GAAE,OAAO;GAAY,OAAO,kBAAkB,QAAQ,GAAG;GAAE,CAAC;EAE3E,IAAI,QAAQ,QACV,QAAQ,KAAK;GAAE,OAAO;GAAQ,OAAO;GAAW,CAAC;EAEnD,MAAM,SAAS,mBAAmB;GAChC,SAAS,WAAW;GACpB,aAAa,WAAW;GACxB,KAAK,WAAW;GAChB;GACA;GACD,CAAC;EACF,GAAG,OAAO,OAAO;;CAInB,IAAI;CACJ,IAAI;EACF,sBAAsB,MAAM,SAAS,sBAAsB,QAAQ;UAC5D,OAAO;EACd,IAAI,iBAAiB,SAAU,MAA4B,SAAS,UAClE,OAAO,MACL,kBAAkB,sBAAsB;GACtC,KAAK,8BAA8B;GACnC,KAAK,iDAAiD,aAAa,4CAA4C;GAChH,CAAC,CACH;EAEH,OAAO,MACL,gBAAgB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,EAAE,EACtE,KAAK,iCAAiC,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,IAC7F,CAAC,CACH;;CAIH,IAAI;CACJ,IAAI;EACF,eAAe,KAAK,MAAM,oBAAoB;UACvC,OAAO;EACd,OAAO,MACL,8BACE,6BAA6B,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,IACnF,EAAE,OAAO,EAAE,MAAM,sBAAsB,EAAE,CAC1C,CACF;;CAIH,MAAM,eAAe,QAAQ,MAAM,OAAO,IAAI;CAC9C,IAAI,CAAC,cACH,OAAO,MACL,gCAAgC;EAC9B,KAAK,uCAAuC,WAAW,YAAY,yBAAyB,WAAW;EACvG,aAAa,WAAW;EACzB,CAAC,CACH;CAIH,IAAI,CAAC,OAAO,QACV,OAAO,MACL,oBAAoB,EAAE,KAAK,iCAAiC,WAAW,eAAe,CAAC,CACxF;CAGH,IAAI,CAAC,cAAc,OAAO,OAAO,EAC/B,OAAO,MACL,iCAAiC,EAC/B,KAAK,WAAW,OAAO,OAAO,GAAG,gCAClC,CAAC,CACH;CAIH,MAAM,SAAS,oBAAoB;EACjC,QAAQ,OAAO;EACf,QAAQ,OAAO;EACf,SAAS,OAAO;EAChB,QAAQ,OAAO;EACf,gBAAgB,OAAO,kBAAkB,EAAE;EAC5C,CAAC;CAGF,MAAM,aAAa,sBAAsB;EAAE;EAAI;EAAO,CAAC;CAEvD,OAAO,GAAG;EACR;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAAC;;;;;AAMJ,SAAgB,2BAA2B,SAA2B;CACpE,iBAAiB,QAAQ;CACzB,OAAO,QACJ,OAAO,cAAc,6BAA6B,CAClD,OAAO,mBAAmB,gCAAgC,CAC1D,OAAO,aAAa,+CAA+C,MAAM"}