prisma-next 0.5.0-dev.9 → 0.5.1

package/dist/commands/db-verify.mjs

@@ -1,322 +1,2 @@
-import { t as loadConfig } from "../config-loader-C25b63rJ.mjs";
-import { _ as errorUnexpected, a as errorContractValidationFailed, c as errorDriverRequired, d as errorMarkerMissing, g as errorTargetMismatch, l as errorFileNotFound, m as errorRuntime, o as errorDatabaseConnectionRequired, t as CliStructuredError, u as errorHashMismatch } from "../cli-errors-Cd79vmTH.mjs";
-import { n as ContractValidationError, t as createControlClient } from "../client-CrsnY58k.mjs";
-import { t as TerminalUI } from "../terminal-ui-C3ZLwQxK.mjs";
-import { _ as formatStyledHeader, a as maskConnectionUrl, d as setCommandExamples, m as parseGlobalFlags, n as addGlobalOptions, s as resolveContractPath, t as handleResult, u as setCommandDescriptions } from "../result-handler-Ba3zWQsI.mjs";
-import { t as createProgressAdapter } from "../progress-adapter-DvQWB1nK.mjs";
-import { c as formatVerifyOutput, i as formatSchemaVerifyOutput, r as formatSchemaVerifyJson, s as formatVerifyJson } from "../verify-Bkycc-Tf.mjs";
-import { Command } from "commander";
-import { notOk, ok } from "@prisma-next/utils/result";
-import { relative, resolve } from "pathe";
-import { ifDefined } from "@prisma-next/utils/defined";
-import { VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH } from "@prisma-next/framework-components/control";
-import { readFile } from "node:fs/promises";
-
-//#region src/commands/db-verify.ts
-/**
-* Maps a VerifyDatabaseResult failure to a CliStructuredError.
-*/
-function mapVerifyFailure(verifyResult) {
-	if (!verifyResult.ok && verifyResult.code) {
-		if (verifyResult.code === VERIFY_CODE_MARKER_MISSING) return errorMarkerMissing();
-		if (verifyResult.code === VERIFY_CODE_HASH_MISMATCH) {
-			const storageMatch = verifyResult.marker?.storageHash === verifyResult.contract.storageHash;
-			const profileMatch = !verifyResult.contract.profileHash || verifyResult.marker?.profileHash === verifyResult.contract.profileHash;
-			if (!storageMatch) return errorHashMismatch({
-				why: "Contract storageHash does not match database marker",
-				expected: verifyResult.contract.storageHash,
-				...ifDefined("actual", verifyResult.marker?.storageHash)
-			});
-			return errorHashMismatch({
-				why: profileMatch ? "Contract hash does not match database marker" : "Contract profileHash does not match database marker",
-				...ifDefined("expected", verifyResult.contract.profileHash),
-				...ifDefined("actual", verifyResult.marker?.profileHash)
-			});
-		}
-		if (verifyResult.code === VERIFY_CODE_TARGET_MISMATCH) return errorTargetMismatch(verifyResult.target.expected, verifyResult.target.actual ?? "unknown");
-	}
-	return errorRuntime(verifyResult.summary);
-}
-function errorInvalidVerifyMode(options) {
-	return new CliStructuredError("4012", "Invalid verify mode", {
-		domain: "CLI",
-		why: options.why,
-		fix: options.fix,
-		docsUrl: "https://pris.ly/db-verify"
-	});
-}
-function resolveDbVerifyMode(options) {
-	if (options.markerOnly && options.schemaOnly) return notOk(errorInvalidVerifyMode({
-		why: "`--marker-only` and `--schema-only` cannot be used together",
-		fix: "Choose one mode: omit both to check the marker and schema, use `--marker-only` to check only the marker, or use `--schema-only` to check only the live schema."
-	}));
-	if (options.markerOnly && options.strict) return notOk(errorInvalidVerifyMode({
-		why: "`--strict` requires schema verification, but `--marker-only` skips it",
-		fix: "Remove `--strict`, or use `db verify` / `db verify --schema-only` when you want to check the live schema in strict mode."
-	}));
-	if (options.schemaOnly) return ok("schema-only");
-	if (options.markerOnly) return ok("marker-only");
-	return ok("full");
-}
-function formatDbVerifyModeLabel(mode, strict) {
-	if (mode === "marker-only") return "marker only";
-	if (mode === "schema-only") return `schema only (${strict ? "strict" : "tolerant"})`;
-	return `full (marker + schema, ${strict ? "strict" : "tolerant"})`;
-}
-function formatDbVerifyInvocation(mode, strict) {
-	const args = ["db verify"];
-	if (mode === "marker-only") args.push("--marker-only");
-	if (mode === "schema-only") args.push("--schema-only");
-	if (strict) args.push("--strict");
-	return args.join(" ");
-}
-function createDbVerifyConnectionRequiredError(options) {
-	const invocation = formatDbVerifyInvocation(options.mode, options.strict);
-	return errorDatabaseConnectionRequired({
-		why: `Database connection is required for ${invocation} (set db.connection in ${options.configPath}, or pass --db <url>)`,
-		retryCommand: `prisma-next ${invocation} --db <url>`
-	});
-}
-function renderVerifyHeader(paths, options, mode, flags, ui) {
-	if (flags.json || flags.quiet) return;
-	const description = mode === "schema-only" ? "Check whether the live database schema matches your contract" : mode === "marker-only" ? "Check whether the database marker matches your contract" : "Check whether the database marker and live schema match your contract";
-	const details = [
-		{
-			label: "config",
-			value: paths.configPath
-		},
-		{
-			label: "contract",
-			value: paths.contractPath
-		},
-		{
-			label: "mode",
-			value: formatDbVerifyModeLabel(mode, options.strict ?? false)
-		}
-	];
-	if (options.db) details.push({
-		label: "database",
-		value: maskConnectionUrl(options.db)
-	});
-	ui.stderr(formatStyledHeader({
-		command: "db verify",
-		description,
-		url: "https://pris.ly/db-verify",
-		details,
-		flags
-	}));
-}
-async function resolveVerifyPaths(options) {
-	const config = await loadConfig(options.config);
-	const configPath = options.config ? relative(process.cwd(), resolve(options.config)) : "prisma-next.config.ts";
-	const contractPathAbsolute = resolveContractPath(config);
-	return {
-		config,
-		configPath,
-		contractPathAbsolute,
-		contractPath: relative(process.cwd(), contractPathAbsolute)
-	};
-}
-async function resolveVerifySetup(paths, options, mode) {
-	const { config, configPath, contractPathAbsolute, contractPath } = paths;
-	let contractJsonContent;
-	try {
-		contractJsonContent = await readFile(contractPathAbsolute, "utf-8");
-	} catch (error) {
-		if (error instanceof Error && error.code === "ENOENT") return notOk(errorFileNotFound(contractPathAbsolute, {
-			why: `Contract file not found at ${contractPathAbsolute}`,
-			fix: `Run \`prisma-next contract emit\` to generate ${contractPath}, or update \`config.contract.output\` in ${configPath}`
-		}));
-		return notOk(errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}` }));
-	}
-	let contractJson;
-	try {
-		contractJson = JSON.parse(contractJsonContent);
-	} catch (error) {
-		return notOk(errorContractValidationFailed(`Contract JSON is invalid: ${error instanceof Error ? error.message : String(error)}`, { where: { path: contractPathAbsolute } }));
-	}
-	const dbConnection = options.db ?? config.db?.connection;
-	if (typeof dbConnection !== "string" || dbConnection.length === 0) return notOk(createDbVerifyConnectionRequiredError({
-		configPath,
-		mode,
-		strict: options.strict ?? false
-	}));
-	if (!config.driver) return notOk(errorDriverRequired({ why: `Config.driver is required for ${formatDbVerifyInvocation(mode, options.strict ?? false)}` }));
-	return ok({
-		...paths,
-		contractJson,
-		dbConnection
-	});
-}
-function createVerifyClient(setup) {
-	return createControlClient({
-		family: setup.config.family,
-		target: setup.config.target,
-		adapter: setup.config.adapter,
-		driver: setup.config.driver,
-		extensionPacks: setup.config.extensionPacks ?? []
-	});
-}
-function wrapVerifyError(error, contractPathAbsolute, modeLabel) {
-	if (error instanceof CliStructuredError) return notOk(error);
-	if (error instanceof ContractValidationError) return notOk(errorContractValidationFailed(`Contract validation failed: ${error.message}`, { where: { path: contractPathAbsolute } }));
-	return notOk(errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Unexpected error during ${modeLabel}: ${error instanceof Error ? error.message : String(error)}` }));
-}
-/**
-* Executes the db verify command and returns a structured Result.
-*/
-async function executeDbVerifyCommand(options, flags, ui, mode) {
-	const startTime = Date.now();
-	const paths = await resolveVerifyPaths(options);
-	renderVerifyHeader(paths, options, mode, flags, ui);
-	const setupResult = await resolveVerifySetup(paths, options, mode);
-	if (!setupResult.ok) return setupResult;
-	const { contractJson, dbConnection, contractPathAbsolute } = setupResult.value;
-	const client = createVerifyClient(setupResult.value);
-	const onProgress = createProgressAdapter({
-		ui,
-		flags
-	});
-	try {
-		const verifyResult = await client.verify({
-			contract: contractJson,
-			connection: dbConnection,
-			onProgress
-		});
-		if (!verifyResult.ok) return notOk(mapVerifyFailure(verifyResult));
-		if (mode === "marker-only") return ok({
-			ok: true,
-			mode: "marker-only",
-			summary: "Database marker matches contract",
-			contract: verifyResult.contract,
-			marker: verifyResult.marker,
-			target: verifyResult.target,
-			...ifDefined("missingCodecs", verifyResult.missingCodecs),
-			...ifDefined("codecCoverageSkipped", verifyResult.codecCoverageSkipped),
-			warning: "Schema verification skipped because --marker-only was provided",
-			meta: {
-				...verifyResult.meta ?? {},
-				schemaVerification: "skipped"
-			},
-			timings: { total: Date.now() - startTime }
-		});
-		const schemaVerifyResult = await client.schemaVerify({
-			contract: contractJson,
-			strict: options.strict ?? false,
-			onProgress
-		});
-		if (!schemaVerifyResult.ok) return notOk(schemaVerifyResult);
-		return ok({
-			ok: true,
-			mode: "full",
-			summary: "Database marker and schema match contract",
-			contract: verifyResult.contract,
-			marker: verifyResult.marker,
-			target: verifyResult.target,
-			...ifDefined("missingCodecs", verifyResult.missingCodecs),
-			...ifDefined("codecCoverageSkipped", verifyResult.codecCoverageSkipped),
-			schema: {
-				summary: schemaVerifyResult.summary,
-				counts: schemaVerifyResult.schema.counts,
-				strict: schemaVerifyResult.meta?.strict ?? false
-			},
-			meta: {
-				...verifyResult.meta ?? {},
-				schemaVerification: "performed"
-			},
-			timings: { total: Date.now() - startTime }
-		});
-	} catch (error) {
-		return wrapVerifyError(error, contractPathAbsolute, "db verify");
-	} finally {
-		await client.close();
-	}
-}
-async function executeDbSchemaOnlyVerifyCommand(options, flags, ui) {
-	const paths = await resolveVerifyPaths(options);
-	renderVerifyHeader(paths, options, "schema-only", flags, ui);
-	const setupResult = await resolveVerifySetup(paths, options, "schema-only");
-	if (!setupResult.ok) return setupResult;
-	const { contractJson, dbConnection, contractPathAbsolute } = setupResult.value;
-	const client = createVerifyClient(setupResult.value);
-	const onProgress = createProgressAdapter({
-		ui,
-		flags
-	});
-	try {
-		return ok(await client.schemaVerify({
-			contract: contractJson,
-			strict: options.strict ?? false,
-			connection: dbConnection,
-			onProgress
-		}));
-	} catch (error) {
-		return wrapVerifyError(error, contractPathAbsolute, "db verify --schema-only");
-	} finally {
-		await client.close();
-	}
-}
-function createDbVerifyCommand() {
-	const command = new Command("verify");
-	setCommandDescriptions(command, "Check whether the database marker and live schema match your contract", "Verifies the database marker first, then checks the database schema matches your contract.\nUse `--marker-only` for marker-only verification, `--schema-only` to skip marker checks and\ninspect only the live schema, and `--strict` to fail if the database includes elements\nnot present in the contract.");
-	setCommandExamples(command, [
-		"prisma-next db verify --db $DATABASE_URL",
-		"prisma-next db verify --db $DATABASE_URL --strict",
-		"prisma-next db verify --db $DATABASE_URL --schema-only",
-		"prisma-next db verify --db $DATABASE_URL --schema-only --strict",
-		"prisma-next db verify --db $DATABASE_URL --marker-only",
-		"prisma-next db verify --db $DATABASE_URL --json"
-	]);
-	addGlobalOptions(command).option("--db <url>", "Database connection string").option("--config <path>", "Path to prisma-next.config.ts").option("--marker-only", "Skip schema verification and only check the database marker").option("--schema-only", "Skip marker verification and only check whether the live schema satisfies the contract").option("--strict", "Strict mode: schema elements not present in the contract are considered an error", false).action(async (options) => {
-		const flags = parseGlobalFlags(options);
-		const ui = new TerminalUI({
-			color: flags.color,
-			interactive: flags.interactive
-		});
-		const modeResult = resolveDbVerifyMode(options);
-		if (!modeResult.ok) {
-			const exitCode = handleResult(modeResult, flags, ui);
-			process.exit(exitCode);
-		}
-		const mode = modeResult.value;
-		if (mode === "schema-only") {
-			const result$1 = await executeDbSchemaOnlyVerifyCommand(options, flags, ui);
-			const exitCode = handleResult(result$1, flags, ui, (schemaVerifyResult) => {
-				if (flags.json) ui.output(formatSchemaVerifyJson(schemaVerifyResult));
-				else {
-					const output = formatSchemaVerifyOutput(schemaVerifyResult, flags);
-					if (output) ui.log(output);
-				}
-			});
-			if (result$1.ok && !result$1.value.ok) process.exit(1);
-			process.exit(exitCode);
-		}
-		const result = await executeDbVerifyCommand(options, flags, ui, mode);
-		if (result.ok) {
-			if (flags.json) ui.output(formatVerifyJson(result.value));
-			else {
-				const output = formatVerifyOutput(result.value, flags);
-				if (output) ui.log(output);
-			}
-			process.exit(0);
-		}
-		if (CliStructuredError.is(result.failure)) {
-			const exitCode = handleResult(result, flags, ui);
-			process.exit(exitCode);
-		}
-		if (flags.json) ui.output(formatSchemaVerifyJson(result.failure));
-		else {
-			const output = formatSchemaVerifyOutput(result.failure, {
-				...flags,
-				quiet: false
-			});
-			if (output) ui.log(output);
-		}
-		process.exit(1);
-	});
-	return command;
-}
-
-//#endregion
+import { t as createDbVerifyCommand } from "../db-verify-Czm5T-J4.mjs";
 export { createDbVerifyCommand };
-//# sourceMappingURL=db-verify.mjs.map

package/dist/commands/migration-apply.d.mts

@@ -1,31 +1,46 @@
+import { T as MigrationApplyPathDecision, t as AggregatePerSpaceExecutionEntry } from "../types-LItU7E4l.mjs";
 import { Command } from "commander";
 
 //#region src/commands/migration-apply.d.ts
+/**
+ * Per-space breakdown of an apply run. The CLI command surfaces these
+ * for both the JSON shape (`appliedSpaces[]`) and the human-readable
+ * formatter (per-space block — same shape `db init` / `db update`
+ * use, M6 sub-spec § Output shape contract).
+ */
 interface MigrationApplyResult {
   readonly ok: boolean;
+  /** Number of contract spaces that had non-zero pending operations applied. */
   readonly migrationsApplied: number;
+  /** Total contract spaces visible in the aggregate (pending + already-up-to-date). */
   readonly migrationsTotal: number;
+  /**
+   * Marker hash for the **app member** post-apply. Surfaced for
+   * back-compat with single-space callers; per-space markers live on
+   * `perSpace[].marker.storageHash`.
+   */
   readonly markerHash: string;
   readonly applied: readonly {
+    readonly spaceId: string;
     readonly dirName: string;
+    readonly migrationHash: string;
     readonly from: string;
     readonly to: string;
     readonly operationsExecuted: number;
   }[];
   readonly summary: string;
-  readonly pathDecision?: {
-    readonly fromHash: string;
-    readonly toHash: string;
-    readonly alternativeCount: number;
-    readonly tieBreakReasons: readonly string[];
-    readonly refName?: string;
-    readonly selectedPath: readonly {
-      readonly dirName: string;
-      readonly migrationId: string;
-      readonly from: string;
-      readonly to: string;
-    }[];
-  };
+  /**
+   * Per-space breakdown in canonical schedule order (extensions
+   * alphabetically, then app). Always present for the aggregate-walking
+   * apply path.
+   */
+  readonly perSpace: readonly AggregatePerSpaceExecutionEntry[];
+  /**
+   * Path-decision data for the app member. Surfaced for back-compat
+   * with single-space callers (cli-journeys invariant tests).
+   * Absent for no-op applies where the app had nothing to do.
+   */
+  readonly pathDecision?: MigrationApplyPathDecision;
   readonly timings: {
     readonly total: number;
   };

package/dist/commands/migration-apply.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"migration-apply.d.mts","names":[],"sources":["../../src/commands/migration-apply.ts"],"sourcesContent":[],"mappings":";;;UA8CiB,oBAAA;;EAAA,SAAA,iBAAoB,EAAA,MAAA;EAiWrB,SAAA,eAAA,EAAA,MAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA3B,2BAAA,CAAA,GAA+B"}
+{"version":3,"file":"migration-apply.d.mts","names":[],"sources":["../../src/commands/migration-apply.ts"],"mappings":";;;;;;AA0DA;;;;UAAiB,oBAAA;EAAA,SACN,EAAA;EAIA;EAAA,SAFA,iBAAA;EASA;EAAA,SAPA,eAAA;EASE;;;;;EAAA,SAHF,UAAA;EAAA,SACA,OAAA;IAAA,SACE,OAAA;IAAA,SACA,OAAA;IAAA,SACA,aAAA;IAAA,SACA,IAAA;IAAA,SACA,EAAA;IAAA,SACA,kBAAA;EAAA;EAAA,SAEF,OAAA;EA8NgC;;;;;EAAA,SAxNhC,QAAA,WAAmB,+BAAA;;;;;;WAMnB,YAAA,GAAe,0BAAA;EAAA,SACf,OAAA;IAAA,SACE,KAAA;EAAA;AAAA;AAAA,iBAgNG,2BAAA,CAAA,GAA+B,OAAA"}