prisma-next 0.11.0 → 0.12.0-dev.10

package/dist/{client-oXO2WCPD.mjs → client-CDr4o07S.mjs}

@@ -1,15 +1,16 @@
-import { h as errorRunnerFailed, t as CliStructuredError } from "./cli-errors-Djtz98Vm.mjs";
-import { t as assertFrameworkComponentsCompatible } from "./framework-components-65gOHkHB.mjs";
-import { t as enrichContract } from "./contract-enrichment-Dani0mMW.mjs";
-import { t as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-BmNQwlws.mjs";
+import { A as CliStructuredError } from "./command-helpers-Bbw1GbwL.mjs";
+import { t as assertFrameworkComponentsCompatible } from "./framework-components-fYXjz_in.mjs";
+import { t as enrichContract } from "./contract-enrichment-a0V5Y_mL.mjs";
+import { n as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-DvZwdkrr.mjs";
 import { emit } from "@prisma-next/emitter";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok } from "@prisma-next/utils/result";
-import { APP_SPACE_ID, createControlStack, hasMigrations, hasMultiSpaceRunner, hasOperationPreview, hasPslContractInfer, hasSchemaView } from "@prisma-next/framework-components/control";
-import { findPathWithDecision } from "@prisma-next/migration-tools/migration-graph";
-import { graphWalkStrategy, planAggregate, verifyAggregate } from "@prisma-next/migration-tools/aggregate";
+import { APP_SPACE_ID, createControlStack, hasMigrations, hasOperationPreview, hasPslContractInfer, hasSchemaView } from "@prisma-next/framework-components/control";
+import { buildSynthMigrationEdge, graphWalkStrategy, planMigration, requireHeadRef, verifyMigration } from "@prisma-next/migration-tools/aggregate";
 import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
 import { errorNoInvariantPath } from "@prisma-next/migration-tools/errors";
+import { castAs } from "@prisma-next/utils/casts";
+import { findPathWithDecision } from "@prisma-next/migration-tools/migration-graph";
 //#region src/control-api/errors.ts
 var ContractValidationError = class extends Error {
 	cause;
@@ -20,33 +21,32 @@ var ContractValidationError = class extends Error {
 	}
 };
 //#endregion
-//#region src/control-api/operations/apply-aggregate.ts
+//#region src/control-api/operations/apply.ts
 /**
 * Span id emitted via `onProgress` for the apply phase. Stable
 * identifier consumed by the structured-output renderer and by tests.
 */
 const APPLY_SPAN_ID = "apply";
 /**
-* Runner-driving tail shared by every aggregate apply caller — `db init`,
+* Runner-driving tail shared by every apply caller — `db init`,
 * `db update`, and `migrate`. Consumes already-resolved per-space
 * plans (the planner-vs-replay distinction is owned by the caller) and
-* dispatches them to the multi-space runner in canonical order.
+* dispatches them to the runner in canonical order.
 *
 * Marker advancement is part of the runner's per-space transaction
 * (the SQL family runner writes the marker as the last step of each
 * space's transaction), so this primitive does not advance markers
-* separately — by the time `executeAcrossSpaces` returns ok, every
+* separately — by the time `execute` returns ok, every
 * space's marker has been advanced to its plan's destination.
 *
 * Span emission (`spanStart 'apply'` / `spanEnd 'apply'`) is owned here
 * so callers don't have to duplicate it; the `action` field on each
 * progress event is taken from the caller's `action` argument.
 */
-async function applyAggregate(inputs) {
+async function applyMigration(inputs) {
 	const { aggregate, perSpacePlans, applyOrder, driver, familyInstance, migrations, frameworkComponents, policy, action, onProgress } = inputs;
 	const orderedResolutions = collectOrdered(applyOrder, perSpacePlans);
 	const runner = migrations.createRunner(familyInstance);
-	if (!hasMultiSpaceRunner(runner)) throw errorRunnerFailed(`Runner for target "${aggregate.targetId}" does not implement \`executeAcrossSpaces\``, { why: `${labelForAction(action)} requires multi-space-capable runners (today: every SQL family runner).` });
 	onProgress?.({
 		action,
 		kind: "spanStart",
@@ -60,9 +60,10 @@ async function applyAggregate(inputs) {
 		destinationContract: r.entry.destinationContract,
 		policy,
 		frameworkComponents,
+		migrationEdges: r.entry.migrationEdges,
 		strictVerification: false
 	}));
-	const runnerResult = await runner.executeAcrossSpaces({
+	const runnerResult = await runner.execute({
 		driver,
 		perSpaceOptions
 	});
@@ -98,14 +99,14 @@ async function applyAggregate(inputs) {
 }
 /**
 * Project the planner's per-space resolutions into the
-* `AggregatePerSpaceExecutionEntry[]` shape the CLI surfaces.
+* `PerSpaceExecutionEntry[]` shape the CLI surfaces.
 *
 * `includeMarkers` is `true` for apply-mode (each space's marker is
 * the `destination.storageHash` of its plan, which the runner
 * advances as the last step of each space's transaction) and `false`
 * for plan-mode (no marker has been written yet).
 *
-* Exported alongside {@link applyAggregate} so plan-mode callers can
+* Exported alongside {@link applyMigration} so plan-mode callers can
 * assemble the same per-space block without going through the runner.
 */
 function buildPerSpaceBreakdown(orderedResolutions, appSpaceId, options) {
@@ -138,7 +139,7 @@ function buildPerSpaceBreakdown(orderedResolutions, appSpaceId, options) {
 function collectOrdered(applyOrder, perSpace) {
 	return applyOrder.map((spaceId) => {
 		const entry = perSpace.get(spaceId);
-		if (!entry) throw new Error(`Aggregate planner output missing per-space plan for "${spaceId}"`);
+		if (!entry) throw new Error(`planner output missing per-space plan for "${spaceId}"`);
 		return {
 			spaceId,
 			entry
@@ -147,7 +148,7 @@ function collectOrdered(applyOrder, perSpace) {
 }
 /**
 * Action-appropriate label for the `spanStart` event the apply
-* primitive emits. `applyAggregate` is shared by `db init`, `db update`,
+* primitive emits. `applyMigration` is shared by `db init`, `db update`,
 * and `migrate`; the span label tracks the user-visible action
 * so structured-progress output reads naturally for each surface.
 */
@@ -158,13 +159,6 @@ function progressLabelForAction(action) {
 		case "migrationApply": return "Applying migration plan across spaces";
 	}
 }
-function labelForAction(action) {
-	switch (action) {
-		case "dbInit": return "db init";
-		case "dbUpdate": return "db update";
-		case "migrationApply": return "migrate";
-	}
-}
 //#endregion
 //#region src/control-api/operations/migration-helpers.ts
 /**
@@ -179,12 +173,12 @@ function stripOperations(operations) {
 	}));
 }
 //#endregion
-//#region src/control-api/operations/db-apply-aggregate.ts
+//#region src/control-api/operations/db-apply.ts
 /**
-* Span IDs emitted via `onProgress` during the aggregate apply flow.
+* Span IDs emitted via `onProgress` during the apply flow.
 * Stable identifiers consumed by the structured-output renderer and by
 * tests asserting on span ids. The `apply` span itself is owned by
-* the {@link applyAggregate} primitive — only the introspect / plan
+* the {@link applyMigration} primitive — only the introspect / plan
 * spans are emitted directly here.
 */
 const SPAN_IDS$1 = {
@@ -201,16 +195,16 @@ const SPAN_IDS$1 = {
 *    integrity violation short-circuits with a structured error.
 * 2. **Read DB state**: marker rows (`familyInstance.readAllMarkers`)
 *    + introspected schema (`familyInstance.introspect`).
-* 3. **Plan**: {@link planAggregate} chooses graph-walk vs synth per
+* 3. **Plan**: {@link planMigration} chooses graph-walk vs synth per
 *    member according to `callerPolicy.ignoreGraphFor`. The app member
 *    is forced through synth (today's daily-driver behaviour); every
 *    extension member walks its on-disk graph.
 * 4. **Apply** (when `mode === 'apply'`): every per-space `MigrationPlan`
-*    feeds into the runner's `executeAcrossSpaces` — one outer
+*    feeds into the runner's `execute` — one outer
 *    transaction across every space; failure on any space rolls back
 *    every space's writes.
 */
-async function executeAggregateApply(options) {
+async function executeApply(options) {
 	const { driver, familyInstance, contract, mode, migrations, frameworkComponents, migrationsDir, extensionPacks, targetId, policy, action, onProgress } = options;
 	const loaded = await buildContractSpaceAggregate({
 		targetId,
@@ -245,7 +239,7 @@ async function executeAggregateApply(options) {
 		spanId: SPAN_IDS$1.plan,
 		label: "Planning migration"
 	});
-	const planResult = await planAggregate({
+	const planResult = await planMigration({
 		aggregate,
 		currentDBState: {
 			markersBySpaceId: markerRows,
@@ -289,7 +283,7 @@ async function executeAggregateApply(options) {
 			summary
 		});
 	}
-	const applied = await applyAggregate({
+	const applied = await applyMigration({
 		aggregate,
 		perSpacePlans: planResult.value.perSpace,
 		applyOrder: planResult.value.applyOrder,
@@ -432,7 +426,7 @@ function buildRunnerFailure(args) {
 * changes belong to `db update`.
 */
 async function executeDbInit(options) {
-	return await executeAggregateApply({
+	return await executeApply({
 		driver: options.driver,
 		familyInstance: options.familyInstance,
 		contract: options.contract,
@@ -481,7 +475,7 @@ async function executeDbUpdate(options) {
 		const gate = await guardDestructiveChanges(sharedInputs);
 		if (gate !== null) return gate;
 	}
-	return await executeAggregateApply({
+	return await executeApply({
 		...sharedInputs,
 		mode: options.mode
 	});
@@ -494,7 +488,7 @@ async function executeDbUpdate(options) {
 * run.
 */
 async function guardDestructiveChanges(sharedInputs) {
-	const planResult = await executeAggregateApply({
+	const planResult = await executeApply({
 		...sharedInputs,
 		mode: "plan"
 	});
@@ -533,7 +527,7 @@ const SPAN_IDS = {
 *    structured CLI error.
 * 2. **Read DB state**: marker rows + (when `skipSchema` is `false`)
 *    schema introspection.
-* 3. **Verify**: {@link verifyAggregate} returns per-space
+* 3. **Verify**: {@link verifyMigration} returns per-space
 *    `markerCheck` + per-space pre-projected `schemaCheck` (closes F23).
 *    Marker mismatches map to `CliStructuredError` (code `5002`) so
 *    callers (CLI command) can render and exit. Schema results are
@@ -552,7 +546,7 @@ async function executeDbVerify(options) {
 	});
 	emitVerifySpan(onProgress, "spanStart");
 	return finaliseVerifyResult({
-		verifyResult: verifyAggregate({
+		verifyResult: verifyMigration({
 			aggregate,
 			markersBySpaceId,
 			schemaIntrospection,
@@ -611,7 +605,7 @@ function createPerMemberVerifier(options) {
 	return (projectedSchema, member, verifyMode) => {
 		if (skipSchema) return buildSkippedSchemaResult(member);
 		return familyInstance.verifySchema({
-			contract: member.contract,
+			contract: member.contract(),
 			schema: projectedSchema,
 			strict: verifyMode === "strict",
 			frameworkComponents
@@ -636,7 +630,7 @@ function emitVerifySpan(onProgress, kind) {
 	});
 }
 /**
-* Map an {@link AggregateVerifierOutput} to the operation's
+* Map an {@link VerifierOutput} to the operation's
 * {@link ExecuteDbVerifyResult}, applying the `skipMarker` policy used
 * by the CLI's `--schema-only` mode.
 */
@@ -664,15 +658,17 @@ function finaliseVerifyResult(args) {
 	});
 }
 function buildSkippedSchemaResult(member) {
-	const profileHash = member.contract.profileHash;
+	const contract = member.contract();
+	const headRef = requireHeadRef(member);
+	const profileHash = castAs(contract).profileHash;
 	return {
 		ok: true,
 		summary: "Schema verification skipped",
 		contract: {
-			storageHash: member.headRef.hash,
+			storageHash: headRef.hash,
 			...profileHash ? { profileHash } : {}
 		},
-		target: { expected: member.contract.target },
+		target: { expected: contract.target },
 		schema: {
 			issues: [],
 			root: {
@@ -750,7 +746,7 @@ function mapMarkerCheckFailures(appSpaceId, section) {
 *    marker to `member.headRef.hash` (or `refHash` for the app
 *    member when provided). Empty-graph members fail loudly — a
 *    "never planned" space is a user-error condition for replay.
-* 4. Hand off to {@link applyAggregate} (the runner-driving tail
+* 4. Hand off to {@link applyMigration} (the runner-driving tail
 *    shared with `db init` / `db update`). Marker advancement is
 *    inside the per-space transaction.
 *
@@ -758,14 +754,13 @@ function mapMarkerCheckFailures(appSpaceId, section) {
 * authored migration graph on disk before this operation can advance it.
 */
 async function executeMigrationApply(options) {
-	const { driver, familyInstance, contract, migrations, frameworkComponents, migrationsDir, extensionPacks, targetId, appMigrationPackages, refHash, refInvariants, refName, onProgress } = options;
+	const { driver, familyInstance, contract, migrations, frameworkComponents, migrationsDir, extensionPacks, targetId, refHash, refInvariants, refName, onProgress } = options;
 	const loaded = await buildContractSpaceAggregate({
 		targetId,
 		migrationsDir,
 		appContract: contract,
 		extensionPacks,
-		deserializeContract: (json) => familyInstance.deserializeContract(json),
-		appMigrationPackages
+		deserializeContract: (json) => familyInstance.deserializeContract(json)
 	});
 	if (!loaded.ok) throw loaded.failure;
 	const aggregate = loaded.value;
@@ -775,9 +770,10 @@ async function executeMigrationApply(options) {
 	const atHeadResolutions = /* @__PURE__ */ new Map();
 	for (const member of allMembers) {
 		const isAppMember = member.spaceId === aggregate.app.spaceId;
-		const targetHash = isAppMember && refHash !== void 0 ? refHash : member.headRef.hash;
+		const headRef = requireHeadRef(member);
+		const targetHash = isAppMember && refHash !== void 0 ? refHash : headRef.hash;
 		const liveMarker = markerRows.get(member.spaceId) ?? null;
-		if (member.migrations.graph.nodes.size === 0) {
+		if (member.graph().nodes.size === 0) {
 			const liveHash = liveMarker?.storageHash;
 			if (targetHash === liveHash || liveHash === void 0 && targetHash === EMPTY_CONTRACT_HASH) {
 				atHeadResolutions.set(member.spaceId, buildAtHeadResolution({
@@ -790,8 +786,8 @@ async function executeMigrationApply(options) {
 			}
 			return notOk(buildNeverPlannedFailure(member.spaceId, targetHash));
 		}
-		const targetInvariants = isAppMember && refHash !== void 0 && refInvariants !== void 0 ? refInvariants : member.headRef.invariants;
-		const targetMember = targetHash === member.headRef.hash && targetInvariants === member.headRef.invariants ? member : {
+		const targetInvariants = isAppMember && refHash !== void 0 && refInvariants !== void 0 ? refInvariants : headRef.invariants;
+		const targetMember = targetHash === headRef.hash && targetInvariants === headRef.invariants ? member : {
 			...member,
 			headRef: {
 				hash: targetHash,
@@ -807,7 +803,7 @@ async function executeMigrationApply(options) {
 		if (walked.kind === "unreachable") return notOk(buildPathNotFoundFailure(member.spaceId, liveMarker, targetHash));
 		if (walked.kind === "unsatisfiable") {
 			const fromHash = liveMarker?.storageHash ?? EMPTY_CONTRACT_HASH;
-			const structural = findPathWithDecision(targetMember.migrations.graph, fromHash, targetHash, { required: /* @__PURE__ */ new Set() });
+			const structural = findPathWithDecision(targetMember.graph(), fromHash, targetHash, { required: /* @__PURE__ */ new Set() });
 			const structuralPath = structural.kind === "ok" ? structural.decision.selectedPath.map((edge) => ({
 				dirName: edge.dirName,
 				migrationHash: edge.migrationHash,
@@ -845,7 +841,7 @@ async function executeMigrationApply(options) {
 			summary: totalSpaces === 0 ? "Already up to date — no contract spaces are loaded" : totalSpaces === 1 ? "Already up to date" : `Already up to date across ${totalSpaces} space(s)`
 		}));
 	}
-	const applied = await applyAggregate({
+	const applied = await applyMigration({
 		aggregate,
 		perSpacePlans,
 		applyOrder,
@@ -881,7 +877,7 @@ async function executeMigrationApply(options) {
 		};
 	});
 	const perSpaceAll = buildPerSpaceBreakdown(orderedAll, aggregate.app.spaceId, { includeMarkers: true });
-	const summary = `Applied ${applied.value.orderedResolutions.reduce((sum, r) => sum + (r.entry.migrationEdges?.length ?? 0), 0)} migration(s) (${applied.value.totalOpsExecuted} operation(s)) across ${orderedAll.length} contract space(s)`;
+	const summary = `Applied ${applied.value.orderedResolutions.reduce((sum, r) => sum + r.entry.migrationEdges.length, 0)} migration(s) (${applied.value.totalOpsExecuted} operation(s)) across ${orderedAll.length} contract space(s)`;
 	return ok(buildSuccess({
 		aggregate,
 		orderedResolutions: orderedAll,
@@ -891,7 +887,7 @@ async function executeMigrationApply(options) {
 	}));
 }
 /**
-* Build a zero-op {@link AggregatePerSpacePlan} for an empty-graph
+* Build a zero-op {@link PerSpacePlan} for an empty-graph
 * member whose live marker already matches the target. Lets the apply
 * pipeline thread the member through `perSpacePlans` -> `applyOrder`
 * -> the success envelope's `perSpace[]` block so the result reflects
@@ -909,9 +905,13 @@ function buildAtHeadResolution(args) {
 			providedInvariants: []
 		},
 		displayOps: [],
-		destinationContract: member.contract,
+		destinationContract: member.contract(),
 		strategy: "graph-walk",
-		migrationEdges: []
+		migrationEdges: [buildSynthMigrationEdge({
+			currentMarkerStorageHash: liveMarker?.storageHash,
+			destinationStorageHash: targetHash,
+			operationCount: 0
+		})]
 	};
 }
 function sumPlannedOps(applyOrder, perSpacePlans) {
@@ -925,9 +925,9 @@ function sumPlannedOps(applyOrder, perSpacePlans) {
 }
 function buildSuccess(args) {
 	const appResolution = args.orderedResolutions.find((r) => r.spaceId === args.aggregate.app.spaceId);
-	const appMarkerHash = appResolution?.entry.plan.destination.storageHash ?? args.aggregate.app.headRef.hash;
+	const appMarkerHash = appResolution?.entry.plan.destination.storageHash ?? requireHeadRef(args.aggregate.app).hash;
 	const applied = args.orderedResolutions.flatMap((r) => {
-		return (r.entry.migrationEdges ?? []).map((edge) => ({
+		return r.entry.migrationEdges.map((edge) => ({
 			spaceId: r.spaceId,
 			dirName: edge.dirName,
 			migrationHash: edge.migrationHash,
@@ -962,11 +962,19 @@ function buildSuccess(args) {
 		...pathDecision !== void 0 ? { pathDecision } : {}
 	};
 }
+/**
+* Build the `neverPlanned` failure raised when a contract space has no on-disk
+* migration graph but migrate was asked to reach a target hash. The `why`
+* states only the condition; the recovery sequence is composed by
+* `errorPathUnreachable`'s `fix`.
+*
+* @internal Exported for testing only.
+*/
 function buildNeverPlannedFailure(spaceId, targetHash) {
 	return {
 		code: "MIGRATION_PATH_NOT_FOUND",
 		summary: `No on-disk migrations for contract space "${spaceId}"`,
-		why: `migrate is replay-only: every contract space must have an authored migration graph on disk. Space "${spaceId}" has no migrations under \`migrations/${spaceId}/\` but its head ref targets "${targetHash}". Run \`prisma-next migration plan\` first to materialise the path.`,
+		why: `migrate is replay-only: every contract space must have an authored migration graph on disk. Space "${spaceId}" has no migrations under \`migrations/${spaceId}/\` but its head ref targets "${targetHash}".`,
 		meta: {
 			spaceId,
 			target: targetHash,
@@ -974,12 +982,22 @@ function buildNeverPlannedFailure(spaceId, targetHash) {
 		}
 	};
 }
+/**
+* Build the `pathUnreachable` failure raised when an emitted contract has no
+* on-disk migration edge from the current marker to the target. The `why`
+* states only the condition (no edge between the two named states, and migrate
+* replays edges rather than inventing them); the recovery sequence — plan the
+* edge, then re-apply — is composed by `errorPathUnreachable`'s `fix`, so the
+* two read as one non-redundant plan-then-apply story.
+*
+* @internal Exported for testing only.
+*/
 function buildPathNotFoundFailure(spaceId, marker, targetHash) {
 	const fromHash = marker?.storageHash ?? "<empty>";
 	return {
 		code: "MIGRATION_PATH_NOT_FOUND",
 		summary: spaceId === "app" ? "Current contract has no planned migration path" : `Current contract has no planned migration path for contract space "${spaceId}"`,
-		why: `Cannot reach target "${targetHash}" from current marker "${fromHash}" in space "${spaceId}". The on-disk migration graph for this space does not connect the two states. Run \`prisma-next migration plan\` to materialise the path.`,
+		why: `No migration edge connects the current state "${fromHash}" to the target "${targetHash}" in contract space "${spaceId}". The on-disk migration graph does not join the two, and migrate replays existing edges — it never invents one.`,
 		meta: {
 			spaceId,
 			fromHash,
@@ -1289,6 +1307,14 @@ var ControlClientImpl = class {
 		const { driver, familyInstance } = await this.ensureConnected();
 		return familyInstance.readAllMarkers({ driver });
 	}
+	/** Reads the per-migration journal for `space` (defaults to the app contract space). */
+	async readLedger(space = APP_SPACE_ID) {
+		const { driver, familyInstance } = await this.ensureConnected();
+		return familyInstance.readLedger({
+			driver,
+			space
+		});
+	}
 	async migrationApply(options) {
 		const { onProgress } = options;
 		await this.connectWithProgress(options.connection, "migrationApply", onProgress);
@@ -1309,7 +1335,6 @@ var ControlClientImpl = class {
 			migrationsDir: options.migrationsDir,
 			extensionPacks: this.options.extensionPacks ?? [],
 			targetId: this.options.target.targetId,
-			appMigrationPackages: options.appMigrationPackages,
 			...ifDefined("refHash", options.refHash),
 			...ifDefined("refInvariants", options.refInvariants),
 			...ifDefined("refName", options.refName),
@@ -1481,4 +1506,4 @@ var ControlClientImpl = class {
 //#endregion
 export { ContractValidationError as a, executeDbInit as i, executeDbVerify as n, executeDbUpdate as r, createControlClient as t };
 
-//# sourceMappingURL=client-oXO2WCPD.mjs.map
+//# sourceMappingURL=client-CDr4o07S.mjs.map