@prisma-next/cli 0.12.0-dev.7 → 0.12.0-dev.70

package/README.md

@@ -1420,7 +1420,7 @@ try {
 | `sign(options)` | Writes contract marker to database |
 | `dbInit(options)` | Initializes database schema from contract |
 | `dbUpdate(options)` | Updates database schema to match contract |
-| `migrationApply(options)` | Applies pre-planned migration edges to database |
+| `migrate(options)` | Advances the database to the target contract via the migration graph |
 | `introspect(options)` | Introspects database schema |
 
 ### Result Types
@@ -1433,7 +1433,7 @@ Operations return structured result types:
 - `sign()` → `SignDatabaseResult`
 - `dbInit()` → `Result<DbInitSuccess, DbInitFailure>` (uses Result pattern)
 - `dbUpdate()` → `Result<DbUpdateSuccess, DbUpdateFailure>` (uses Result pattern)
-- `migrationApply()` → `Result<MigrationApplySuccess, MigrationApplyFailure>` (uses Result pattern)
+- `migrate()` → `Result<MigrateSuccess, MigrateFailure>` (uses Result pattern)
 - `introspect()` → Schema IR (family-specific)
 
 ### Error Handling

package/dist/cli.mjs

@@ -1,149 +1,30 @@
 #!/usr/bin/env node
-import { C as formatCommandHelp, S as isCI, g as parseGlobalFlagsOrExit, h as parseGlobalFlags, l as setCommandDescriptions, t as addGlobalOptions, u as setCommandExamples, v as installShutdownHandlers, w as formatRootHelp } from "./command-helpers-Bbw1GbwL.mjs";
-import { t as createContractEmitCommand } from "./contract-emit-DxcGl4Uq.mjs";
-import { t as createContractInferCommand } from "./contract-infer-D8uEbJuu.mjs";
+import { D as isCI, O as formatCommandHelp, g as parseGlobalFlagsOrExit, h as parseGlobalFlags, k as formatRootHelp, l as setCommandDescriptions, m as deriveCanPrompt, t as addGlobalOptions, u as setCommandExamples, v as installShutdownHandlers } from "./command-helpers-DGMvGBeX.mjs";
+import { t as createContractEmitCommand } from "./contract-emit-B_qriF8B.mjs";
+import { t as createContractInferCommand } from "./contract-infer-BYT_ra_U.mjs";
 import { createDbInitCommand } from "./commands/db-init.mjs";
 import { createDbSchemaCommand } from "./commands/db-schema.mjs";
 import { createDbSignCommand } from "./commands/db-sign.mjs";
 import { createDbUpdateCommand } from "./commands/db-update.mjs";
-import { t as createDbVerifyCommand } from "./db-verify-v_vUKXTU.mjs";
+import { t as createDbVerifyCommand } from "./db-verify-C24FKhb7.mjs";
+import { t as createMigrationListCommand } from "./migration-list-CihF6w5z.mjs";
 import { createMigrateCommand } from "./commands/migrate.mjs";
-import { t as createMigrationCheckCommand } from "./migration-check-BiBJoYYW.mjs";
-import { t as createMigrationGraphCommand } from "./migration-graph-BzxEsMZg.mjs";
-import { createMigrationListCommand } from "./commands/migration-list.mjs";
-import { createMigrationLogCommand } from "./commands/migration-log.mjs";
+import { t as createMigrationCheckCommand } from "./migration-check-soB5uZEQ.mjs";
+import { createMigrationGraphCommand } from "./commands/migration-graph.mjs";
+import { t as createMigrationLogCommand } from "./migration-log-B75IArji.mjs";
 import { createMigrationNewCommand } from "./commands/migration-new.mjs";
-import { t as createMigrationPlanCommand } from "./migration-plan-9DJ7q7_z.mjs";
+import { t as createMigrationPlanCommand } from "./migration-plan-z5Ing-TD.mjs";
 import { createMigrationShowCommand } from "./commands/migration-show.mjs";
-import { createMigrationStatusCommand } from "./commands/migration-status.mjs";
+import { r as createMigrationStatusCommand } from "./migration-status-Di82DGvo.mjs";
 import { createRefCommand } from "./commands/ref.mjs";
+import { t as createTelemetryCommand } from "./telemetry-BIM4beEO.mjs";
 import { Command } from "commander";
-import { ifDefined } from "@prisma-next/utils/defined";
 import { DEFAULT_CONTRACT_SOURCE_DIR } from "@prisma-next/config/config-types";
-import { fileURLToPath } from "node:url";
-import { readUserConfig, resolveGating, runTelemetry } from "@prisma-next/cli-telemetry";
+import { ensureInstallationId, readUserConfig, resolveGating, runTelemetry, userConfigPath } from "@prisma-next/cli-telemetry";
 import { distance } from "closest-match";
+import { fileURLToPath } from "node:url";
 //#region package.json
-var version = "0.12.0-dev.7";
-//#endregion
-//#region src/utils/telemetry.ts
-/**
-* Resolve the commander command path from a leaf `Command`, walking up
-* the parent chain. Result is rooted at the program name and ends at
-* the leaf — `['prisma-next', 'migration', 'new']` for
-* `prisma-next migration new …`.
-*/
-function commandPathFor(actionCommand) {
-	const path = [];
-	let cursor = actionCommand;
-	while (cursor !== null) {
-		path.unshift(cursor.name());
-		cursor = cursor.parent;
-	}
-	return path;
-}
-function commanderOptionSnapshots(actionCommand) {
-	return actionCommand.options.map((option) => {
-		const attributeName = option.attributeName();
-		return {
-			attributeName,
-			longName: option.long ?? null,
-			source: actionCommand.getOptionValueSource(attributeName) ?? null
-		};
-	});
-}
-/**
-* Project commander's leaf `Command` into the wire-shape snapshot the
-* telemetry sanitiser consumes. Pure projection — no env, no I/O.
-*/
-function commanderSnapshotForTelemetry(actionCommand) {
-	return {
-		commandPath: commandPathFor(actionCommand),
-		positionalArgs: actionCommand.args,
-		options: commanderOptionSnapshots(actionCommand)
-	};
-}
-function resolveTelemetryGate() {
-	if (isCI()) return {
-		enabled: false,
-		outcome: {
-			spawned: false,
-			reason: "ci"
-		}
-	};
-	const userConfig = readUserConfig();
-	if (!resolveGating({
-		env: process.env,
-		config: userConfig
-	}).enabled) return {
-		enabled: false,
-		outcome: {
-			spawned: false,
-			reason: "gated-off"
-		}
-	};
-	return {
-		enabled: true,
-		userConfig
-	};
-}
-/**
-* Path to the compiled sender script inside `@prisma-next/cli-telemetry`'s
-* `dist/`. Resolved off this module's `import.meta.url` via the package
-* specifier `@prisma-next/cli-telemetry/sender`, so the consumer pays
-* no attention to internal package layout.
-*/
-function senderPath() {
-	return fileURLToPath(new URL(import.meta.resolve("@prisma-next/cli-telemetry/sender")));
-}
-function fireTelemetry(actionCommand, userConfig, overrides = {}) {
-	return runTelemetry({
-		command: commanderSnapshotForTelemetry(actionCommand),
-		version,
-		projectRoot: process.cwd(),
-		senderPath: senderPath(),
-		isCI: isCI(),
-		env: process.env,
-		userConfig,
-		...ifDefined("databaseTarget", overrides.databaseTarget)
-	});
-}
-/**
-* preAction-stage entry point. Synchronous by construction: resolve
-* env/CI/user-consent gates (cheap, all in-memory and a single tiny
-* user-config read), then — only when enabled — `fork()` the detached
-* sender script. The forked child loads `prisma-next.config.*` via
-* c12 on its own (see `loadProjectConfig` in cli-telemetry); the
-* parent does no project-config I/O on the command's hot path.
-*
-* Privacy invariant: gate resolution always happens before any project
-* config touches disk. The child loading user TS code is acceptable
-* only because it's gated behind the same resolved-enabled signal.
-*/
-function fireTelemetryFromPreAction(actionCommand) {
-	const gate = resolveTelemetryGate();
-	if (!gate.enabled) return gate.outcome;
-	return fireTelemetry(actionCommand, gate.userConfig);
-}
-/**
-* Manual one-shot telemetry path for the first `init` run where the user
-* explicitly answers Yes to the consent prompt. The preAction hook for
-* that same run has already resolved before consent existed, so it is
-* default-off. After consent is persisted, `runInit` calls this helper
-* exactly for that first affirmative answer; subsequent init runs skip
-* it because the prompt is not shown again.
-*
-* The child's c12 load would return `databaseTarget: null` for this
-* specific invocation because `prisma-next.config.*` is not yet on
-* disk (init writes it later in the same run). To preserve the
-* prompt-chosen target in the first-init telemetry event, this
-* helper forwards the value as a parent-side IPC override on
-* `ParentToSenderPayload.databaseTarget` — the child consults the
-* override first and falls back to its c12 result when absent.
-*/
-function fireTelemetryAfterInitConsent(actionCommand, inputs) {
-	return fireTelemetry(actionCommand, readUserConfig(), { databaseTarget: inputs.databaseTarget });
-}
+var version = "0.12.0-dev.70";
 //#endregion
 //#region src/commands/init/templates/code-templates.ts
 function targetPackageName(target) {
@@ -411,8 +292,8 @@ Exit codes (see CLI Style Guide § Exit Codes):
 		"prisma-next init --no-install                                       # skip pnpm/npm install + emit",
 		"prisma-next init --no-skill                                         # skip the skills install (air-gapped / restricted env)"
 	]);
-	return addGlobalOptions(command).option("--target <db>", "Database target: postgres or mongodb").option("--authoring <style>", "Schema authoring style: psl or typescript").option("--schema-path <path>", `Where to write the starter schema (default: ${defaultSchemaPath("psl")})`).option("--force", "Overwrite an existing scaffold without prompting").option("--write-env", "Write a .env file from .env.example (gitignored; default: only .env.example)").option("--probe-db", "Connect to DATABASE_URL once and check the server version against the target minimum (opt-in; off by default)").option("--strict-probe", "Treat a failed --probe-db as fatal (no-op without --probe-db; init is offline-by-default)").option("--no-install", "Skip dependency installation and contract emission").option("--no-skill", "Skip Prisma Next skills install (air-gapped CI, restricted registries, etc.)").action(async (options, actionCommand) => {
-		const { runInit } = await import("./init-Cv9UzWL5.mjs");
+	return addGlobalOptions(command).option("--target <db>", "Database target: postgres or mongodb").option("--authoring <style>", "Schema authoring style: psl or typescript").option("--schema-path <path>", `Where to write the starter schema (default: ${defaultSchemaPath("psl")})`).option("--force", "Overwrite an existing scaffold without prompting").option("--write-env", "Write a .env file from .env.example (gitignored; default: only .env.example)").option("--probe-db", "Connect to DATABASE_URL once and check the server version against the target minimum (opt-in; off by default)").option("--strict-probe", "Treat a failed --probe-db as fatal (no-op without --probe-db; init is offline-by-default)").option("--no-install", "Skip dependency installation and contract emission").option("--no-skill", "Skip Prisma Next skills install (air-gapped CI, restricted registries, etc.)").action(async (options) => {
+		const { runInit } = await import("./init-0HwB-Vh8.mjs");
 		const flags = parseGlobalFlagsOrExit(options);
 		const canPrompt = deriveCanPrompt({
 			flagsInteractive: flags.interactive,
@@ -422,38 +303,11 @@ Exit codes (see CLI Style Guide § Exit Codes):
 		const exitCode = await runInit(process.cwd(), {
 			options,
 			flags,
-			canPrompt,
-			afterFirstTelemetryConsent: (inputs) => {
-				fireTelemetryAfterInitConsent(actionCommand, { databaseTarget: inputs.target });
-			}
+			canPrompt
 		});
 		process.exit(exitCode);
 	});
 }
-/**
-* Bridges the action handler's two TTY checks (stdout via `flags`, stdin
-* via `process.stdin.isTTY`) into the `canPrompt` boolean `runInit`
-* consumes.
-*
-* Per the [Style Guide § Interactivity](../../../../../../../docs/CLI%20Style%20Guide.md#interactivity):
-*
-* - `flags.interactive` governs *decoration* (TerminalUI, intro/outro,
-*   spinners) and is derived from stdout-TTY by `parseGlobalFlags`,
-*   honouring `--interactive` / `--no-interactive`.
-* - Prompting additionally requires a stdin TTY — closing stdin is a
-*   common signal in CI / agent environments even when stdout stays
-*   attached.
-* - `--interactive` is the explicit override: when the user passes it,
-*   we honour it (e.g. testing flows where stdin is stubbed).
-*
-* Exported so callers and tests can derive the same value without
-* touching `process` globals.
-*/
-function deriveCanPrompt(opts) {
-	if (opts.optionInteractive === true) return true;
-	if (opts.flagsInteractive === false) return false;
-	return opts.stdinIsTTY;
-}
 //#endregion
 //#region src/utils/suggest-command.ts
 /**
@@ -477,6 +331,167 @@ function suggestCommands(input, candidates) {
 	return scored.filter((entry) => entry.dist === bestDist).slice(0, 3).map((entry) => entry.name);
 }
 //#endregion
+//#region src/utils/telemetry.ts
+/**
+* Resolve the commander command path from a leaf `Command`, walking up
+* the parent chain. Result is rooted at the program name and ends at
+* the leaf — `['prisma-next', 'migration', 'new']` for
+* `prisma-next migration new …`.
+*/
+function commandPathFor(actionCommand) {
+	const path = [];
+	let cursor = actionCommand;
+	while (cursor !== null) {
+		path.unshift(cursor.name());
+		cursor = cursor.parent;
+	}
+	return path;
+}
+function commanderOptionSnapshots(actionCommand) {
+	return actionCommand.options.map((option) => {
+		const attributeName = option.attributeName();
+		return {
+			attributeName,
+			longName: option.long ?? null,
+			source: actionCommand.getOptionValueSource(attributeName) ?? null
+		};
+	});
+}
+/**
+* Project commander's leaf `Command` into the wire-shape snapshot the
+* telemetry sanitiser consumes. Pure projection — no env, no I/O.
+*/
+function commanderSnapshotForTelemetry(actionCommand) {
+	return {
+		commandPath: commandPathFor(actionCommand),
+		positionalArgs: actionCommand.args,
+		options: commanderOptionSnapshots(actionCommand)
+	};
+}
+function resolveTelemetryGate() {
+	if (isCI()) return {
+		enabled: false,
+		outcome: {
+			spawned: false,
+			reason: "ci"
+		}
+	};
+	const userConfig = readUserConfig();
+	if (!resolveGating({
+		env: process.env,
+		config: userConfig
+	}).enabled) return {
+		enabled: false,
+		outcome: {
+			spawned: false,
+			reason: "gated-off"
+		}
+	};
+	return {
+		enabled: true,
+		userConfig
+	};
+}
+/**
+* Path to the compiled sender script inside `@prisma-next/cli-telemetry`'s
+* `dist/`. Resolved off this module's `import.meta.url` via the package
+* specifier `@prisma-next/cli-telemetry/sender`, so the consumer pays
+* no attention to internal package layout.
+*/
+function senderPath() {
+	return fileURLToPath(new URL(import.meta.resolve("@prisma-next/cli-telemetry/sender")));
+}
+function fireTelemetry(actionCommand, userConfig) {
+	return runTelemetry({
+		command: commanderSnapshotForTelemetry(actionCommand),
+		version,
+		projectRoot: process.cwd(),
+		senderPath: senderPath(),
+		isCI: isCI(),
+		env: process.env,
+		userConfig
+	});
+}
+/**
+* preAction-stage entry point. Synchronous by construction: resolve
+* env/CI/user-consent gates (cheap, all in-memory and a single tiny
+* user-config read), then — only when enabled — `fork()` the detached
+* sender script. The forked child loads `prisma-next.config.*` via
+* c12 on its own (see `loadProjectConfig` in cli-telemetry); the
+* parent does no project-config I/O on the command's hot path.
+*
+* Privacy invariant: gate resolution always happens before any project
+* config touches disk. The child loading user TS code is acceptable
+* only because it's gated behind the same resolved-enabled signal.
+*/
+/**
+* Builds the one-time first-run disclosure. The resolved absolute path to
+* the user-level config file is substituted in so the user can see exactly
+* which file to edit (it must not be confused with `prisma-next.config.ts`).
+* `prisma-next telemetry disable` is named as the primary, friendliest
+* opt-out, alongside the env vars and the config edit.
+*/
+function firstRunNotice(configPath) {
+	return [
+		"Prisma Next collects anonymous CLI usage data, enabled by default.",
+		"What's collected and why: https://prisma-next.dev/docs/cli/telemetry.",
+		"Opt out: run \"prisma-next telemetry disable\", set DO_NOT_TRACK=1 or",
+		`PRISMA_NEXT_DISABLE_TELEMETRY=1, or set "enableTelemetry": false in ${configPath}.`
+	].join(" ");
+}
+/**
+* Best-effort first-run disclosure + installationId mint. Runs only on the
+* gating-enabled path. Prints the notice to stderr (never stdout) and mints
+* a persistent id without touching `enableTelemetry`, so the opt-out default
+* stays intact and no unasked-for consent is recorded.
+*
+* Every step is wrapped so an un-writable config dir (or any other failure)
+* never throws and never blocks the command. Returns the minted (or
+* pre-existing) id so the caller can forward it to `runTelemetry` without a
+* redundant disk read. On mint failure it returns `undefined`: the notice may
+* reprint next run, and `runTelemetry` no-ops on the missing id.
+*/
+function discloseAndMintOnFirstRun() {
+	try {
+		process.stderr.write(`${firstRunNotice(userConfigPath())}\n`);
+	} catch {}
+	try {
+		return ensureInstallationId();
+	} catch {}
+}
+/**
+* True when the run is the `telemetry` command (or one of its
+* subcommands). The usage-telemetry preAction fire is exempted for it:
+* it would be absurd for `telemetry disable` to send a usage event before
+* disabling, or for `telemetry status` to mint an id + send while merely
+* reporting state. This is the only command-specific exemption.
+*
+* The check is rooted at the program: the path must be
+* `['prisma-next', 'telemetry', …]`, so it matches the top-level
+* `telemetry` command and its subcommands without matching a hypothetical
+* nested `… telemetry` elsewhere.
+*/
+function isTelemetryCommand(actionCommand) {
+	return commandPathFor(actionCommand)[1] === "telemetry";
+}
+function fireTelemetryFromPreAction(actionCommand) {
+	if (isTelemetryCommand(actionCommand)) return {
+		spawned: false,
+		reason: "gated-off"
+	};
+	const gate = resolveTelemetryGate();
+	if (!gate.enabled) return gate.outcome;
+	const storedId = gate.userConfig.installationId;
+	if (typeof storedId !== "string" || storedId.length === 0) {
+		const installationId = discloseAndMintOnFirstRun();
+		return fireTelemetry(actionCommand, installationId === void 0 ? gate.userConfig : {
+			...gate.userConfig,
+			installationId
+		});
+	}
+	return fireTelemetry(actionCommand, gate.userConfig);
+}
+//#endregion
 //#region src/cli.ts
 installShutdownHandlers();
 /**
@@ -642,6 +657,7 @@ const migrationCheckCommand = createMigrationCheckCommand();
 migrationCommand.addCommand(migrationCheckCommand);
 const migrateCommand = createMigrateCommand();
 const refCommand = createRefCommand();
+const telemetryCommand = createTelemetryCommand();
 const initCommand = createInitCommand();
 program.addCommand(initCommand);
 program.addCommand(migrateCommand);
@@ -649,6 +665,7 @@ program.addCommand(contractCommand);
 program.addCommand(dbCommand);
 program.addCommand(migrationCommand);
 program.addCommand(refCommand);
+program.addCommand(telemetryCommand);
 const TELEMETRY_CRASH_TEST_SLEEP_MS = 200;
 if (process.env["PRISMA_NEXT_ENABLE_TEST_COMMANDS"] === "1") {
 	const telemetryCrashTestCommand = new Command("__telemetry-crash-test").description("Internal: deliberately throw for the telemetry e2e suite.").action(async () => {