@prisma-next/cli 0.15.0 → 0.16.0-dev.10

package/README.md

@@ -952,15 +952,14 @@ prisma-next migration plan [--config <path>] [--name <slug>] [--from <contract>]
 2. Reads existing migrations from `config.migrations.dir` (default: `migrations/`)
 3. Determines the starting point: `--from <contract>` if provided, otherwise the `db` ref (greenfield when absent)
 4. Diffs the starting contract against the destination using the target's migration planner
-5. Scaffolds a new migration package: `migration.ts` (containing `placeholder(...)` lambdas for any data transforms), `migration.json` (with a content-addressed `migrationHash` over the planned ops, or over `[]` when the planner could not lower any calls because of placeholders), `ops.json` (the planned ops, or `[]` in the placeholder-blocked case), and contract bookends. The package is **always** fully attested — there is no draft state on disk.
+5. Scaffolds a new migration package: `migration.ts` (containing `placeholder(...)` lambdas for any data transforms), `migration.json` (with a content-addressed `migrationHash` over the planned ops, or over `[]` when the planner could not lower any calls because of placeholders), and `ops.json` (the planned ops, or `[]` in the placeholder-blocked case). The bookend contracts are written write-if-absent into the shared snapshot store at `migrations/snapshots/<hex>/contract.{json,d.ts}`. The package is **always** fully attested — there is no draft state on disk.
 6. If the plan has unfilled `placeholder(...)` slots, the command returns a successful `pendingPlaceholders` envelope (a warning, not a failure) asking the developer to fill in the slots before re-emitting. The on-disk `ops.json` is `[]` and `migrationHash` is the hash of `(metadata, [])`, so applying the migration as-written will not advance the storage hash to the intended destination — the runner's destination-hash post-check surfaces this as a state mismatch. After filling in the placeholders, run `node migrations/<dir>/migration.ts` to re-emit `ops.json` and the corresponding `migrationHash`. `PN-MIG-2001` is raised only at self-emit time when a slot is still unfilled.
 
 **Outputs:**
 - `migrations/<dir>/migration.ts` — editable migration source (with `placeholder(...)` slots when the planner inserted them)
 - `migrations/<dir>/migration.json` — fully attested metadata (`migrationHash: string`, never null)
 - `migrations/<dir>/ops.json` — planned operations (empty list `[]` if placeholders blocked the planner)
-- `migrations/<dir>/start-contract.{json,d.ts}` — bookend from the "from" side (when applicable)
-- `migrations/<dir>/end-contract.{json,d.ts}` — bookend from the "to" side
+- `migrations/snapshots/<hex>/contract.{json,d.ts}` — bookend contracts, written write-if-absent, keyed by each contract's storage hash (one entry for `from` when applicable, one for `to`)
 
 **Branching with `--from` and `--to`:** Use `--from` to create a migration edge from a specific contract hash instead of the default starting point. Use `--to` to plan toward any resolved contract — including a rollback via `<migration-dir>^` — instead of the emitted contract. This enables branched migration graphs and arbitrary-target (including reverse) edges without editing contract source.
 
@@ -1028,7 +1027,7 @@ prisma-next migrate [--db <url>] [--to <contract>] [--config <path>] [--json] [-
 
 **Options:**
 - `--db <url>`: Database connection string (optional; defaults to `config.db.connection`)
-- `--to <contract>`: Target contract reference (hash, prefix, ref name, migration directory, `<dir>^`, or filesystem path). When omitted, applies toward the emitted `contract.json`. When `--to` resolves to an on-disk graph node, verification and apply use that bundle's `end-contract.json` — so a planned rollback or other arbitrary-target edge applies without editing contract source.
+- `--to <contract>`: Target contract reference (hash, prefix, ref name, migration directory, `<dir>^`, or filesystem path). When omitted, applies toward the emitted `contract.json`. When `--to` resolves to an on-disk graph node, verification and apply use the snapshot store entry for that node's hash — so a planned rollback or other arbitrary-target edge applies without editing contract source.
 - `--ref <name>`: Target a named ref from `migrations/refs.json` instead of the current contract hash
 - `--config <path>`: Path to `prisma-next.config.ts`
 - `--json`: Output as JSON object

package/dist/cli.d.mts

@@ -1 +1 @@
-export { };
+export {}

package/dist/cli.mjs

@@ -1,31 +1,31 @@
 #!/usr/bin/env node
-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-CUoKYTlG.mjs";
-import { t as createContractEmitCommand } from "./contract-emit-wgqrOXUI.mjs";
-import { t as createContractInferCommand } from "./contract-infer-6SQnnVj7.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-CVn3U9Uz.mjs";
+import { t as createContractEmitCommand } from "./contract-emit-DzOkTs11.mjs";
+import { t as createContractInferCommand } from "./contract-infer-BVqworBB.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-CEsG5Gek.mjs";
-import { t as createFormatCommand } from "./format-CjongNb1.mjs";
-import { t as createMigrationListCommand } from "./migration-list-DTYM8xvm.mjs";
+import { t as createDbVerifyCommand } from "./db-verify-BpwCMyWJ.mjs";
+import { t as createFormatCommand } from "./format-CFLZv_zU.mjs";
+import { t as createMigrationListCommand } from "./migration-list-cnSKilYH.mjs";
 import { createMigrateCommand } from "./commands/migrate.mjs";
-import { t as createMigrationCheckCommand } from "./migration-check-ByeQHOhK.mjs";
+import { t as createMigrationCheckCommand } from "./migration-check-DMxPzbHl.mjs";
 import { createMigrationGraphCommand } from "./commands/migration-graph.mjs";
-import { t as createMigrationLogCommand } from "./migration-log-qZ8LpQIl.mjs";
+import { t as createMigrationLogCommand } from "./migration-log-CEqFiez9.mjs";
 import { createMigrationNewCommand } from "./commands/migration-new.mjs";
-import { t as createMigrationPlanCommand } from "./migration-plan-CfPrB80t.mjs";
+import { t as createMigrationPlanCommand } from "./migration-plan-BJHulFZC.mjs";
 import { createMigrationShowCommand } from "./commands/migration-show.mjs";
-import { r as createMigrationStatusCommand } from "./migration-status-DRuS-rP5.mjs";
+import { r as createMigrationStatusCommand } from "./migration-status-ugWwGk1V.mjs";
 import { createRefCommand } from "./commands/ref.mjs";
-import { t as createTelemetryCommand } from "./telemetry-DHBBq5wT.mjs";
+import { t as createTelemetryCommand } from "./telemetry-BEyNMfco.mjs";
 import { Command } from "commander";
 import { DEFAULT_CONTRACT_SOURCE_DIR } from "@prisma-next/config/config-types";
 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.15.0";
+var version = "0.16.0-dev.10";
 //#endregion
 //#region src/commands/init/templates/code-templates.ts
 function targetPackageName(target) {
@@ -294,7 +294,7 @@ Exit codes (see CLI Style Guide § Exit Codes):
 		"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) => {
-		const { runInit } = await import("./init-D8YFfaD6.mjs");
+		const { runInit } = await import("./init-BSgPxVXA.mjs");
 		const flags = parseGlobalFlagsOrExit(options);
 		const canPrompt = deriveCanPrompt({
 			flagsInteractive: flags.interactive,

package/dist/{client-DigVI8zX.mjs → client-2kwLMBSf.mjs}

@@ -1,13 +1,13 @@
-import { F as CliStructuredError } from "./command-helpers-CUoKYTlG.mjs";
-import { t as assertFrameworkComponentsCompatible } from "./framework-components-BbnM1RYm.mjs";
+import { F as CliStructuredError } from "./command-helpers-CVn3U9Uz.mjs";
+import { t as assertFrameworkComponentsCompatible } from "./framework-components-VMQJbAwl.mjs";
 import { t as enrichContract } from "./contract-enrichment-gn9sWbPw.mjs";
-import { t as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-DpB4x97a.mjs";
+import { t as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-hPVymNLw.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, hasOperationPreview, hasPslContractInfer, hasSchemaSubjectClassifier, hasSchemaView } from "@prisma-next/framework-components/control";
 import { blindCast, castAs } from "@prisma-next/utils/casts";
-import { buildFabricatedMigrationEdge, collectAggregateNamespaces, planMigration, requireHeadRef, resolveRecordedPath, verifyMigration } from "@prisma-next/migration-tools/aggregate";
+import { allStorageElementsExternal, buildFabricatedMigrationEdge, collectAggregateNamespaces, planMigration, requireHeadRef, resolveRecordedPath, 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 { findPathWithDecision } from "@prisma-next/migration-tools/migration-graph";
@@ -330,8 +330,9 @@ function aggregatePlannerWarnings(orderedResolutions) {
 * an extension that was removed from `extensionPacks` without first
 * cleaning up its on-disk migrations / database tables.
 *
-* Returns a {@link CliStructuredError} envelope (code `5002`,
-* `kind: 'orphanMarker'`) for the first orphan it finds, or `null`
+* Returns a {@link CliStructuredError} envelope (code
+* `MIGRATION.CONTRACT_SPACE_VIOLATION`, `kind: 'orphanMarker'`) for the
+* first orphan it finds, or `null`
 * when every marker row maps to a declared contract space. Mirrors the M2
 * `runContractSpaceVerifierMarkerCheck` envelope so downstream
 * tooling (integration tests, JSON consumers) keeps asserting on the
@@ -343,8 +344,7 @@ function detectOrphanMarkers(aggregate, markerRows) {
 	for (const [spaceId, row] of markerRows) if (row !== null && row !== void 0 && !aggregateSpaceIds.has(spaceId)) orphans.push(spaceId);
 	if (orphans.length === 0) return null;
 	orphans.sort((a, b) => a.localeCompare(b));
-	return new CliStructuredError("5002", orphans.length === 1 ? `Orphan contract-space marker detected for "${orphans[0]}"` : `Orphan contract-space markers detected for ${orphans.length} spaces`, {
-		domain: "MIG",
+	return new CliStructuredError("MIGRATION.CONTRACT_SPACE_VIOLATION", orphans.length === 1 ? `Orphan contract-space marker detected for "${orphans[0]}"` : `Orphan contract-space markers detected for ${orphans.length} spaces`, {
 		why: `The database has \`_prisma_marker\` rows for spaces (${orphans.map((s) => `"${s}"`).join(", ")}) that are not declared in the project's \`extensionPacks\`. The aggregate pipeline refuses to advance markers it cannot account for.`,
 		fix: "Either re-declare the missing extension(s) in `extensionPacks` (so the aggregate owns them again), or remove the orphan marker row(s) from `_prisma_marker` once you have confirmed the corresponding tables can be safely retired.",
 		docsUrl: "https://pris.ly/contract-spaces",
@@ -663,8 +663,7 @@ function finaliseVerifyResult(args) {
 	const { verifyResult, aggregate, skipMarker, onProgress } = args;
 	if (!verifyResult.ok) {
 		emitVerifySpan(onProgress, "spanEndError");
-		return notOk(new CliStructuredError("5002", "Aggregate verifier introspection failed", {
-			domain: "MIG",
+		return notOk(new CliStructuredError("MIGRATION.CONTRACT_SPACE_VIOLATION", "Aggregate verifier introspection failed", {
 			why: verifyResult.failure.detail,
 			fix: "Check database connectivity and the introspection tooling.",
 			docsUrl: "https://pris.ly/contract-spaces"
@@ -702,7 +701,8 @@ function buildSkippedSchemaResult(space) {
 /**
 * Translate per-space marker check failures and orphan markers into a
 * single CLI structured error envelope. Preserves the legacy code
-* `5002` (was emitted by `runContractSpaceVerifierMarkerCheck`).
+* `MIGRATION.CONTRACT_SPACE_VIOLATION` (was emitted by
+* `runContractSpaceVerifierMarkerCheck`).
 */
 function mapMarkerCheckFailures(appSpaceId, section) {
 	const violations = [];
@@ -729,8 +729,7 @@ function mapMarkerCheckFailures(appSpaceId, section) {
 	});
 	if (violations.length === 0) return null;
 	const lines = violations.map((v) => `- [${v.kind}] ${v.spaceId}: ${v.remediation}`);
-	return new CliStructuredError("5002", violations.length === 1 ? "Contract-space verifier found a violation" : `Contract-space verifier found violations (${violations.length})`, {
-		domain: "MIG",
+	return new CliStructuredError("MIGRATION.CONTRACT_SPACE_VIOLATION", violations.length === 1 ? "Contract-space verifier found a violation" : `Contract-space verifier found violations (${violations.length})`, {
 		why: `The on-disk \`migrations/\` directory, the \`extensionPacks\` declaration, and the live database marker rows are not in agreement.\n${lines.join("\n")}`,
 		fix: violations[0]?.remediation ?? "Review and reconcile the violations listed above.",
 		docsUrl: "https://pris.ly/contract-spaces",
@@ -751,13 +750,17 @@ function mapMarkerCheckFailures(appSpaceId, section) {
 * 2. Read live marker rows per space (`familyInstance.readAllMarkers`).
 * 3. Per space: `resolveRecordedPath` plots the path from the live
 *    marker to `space.headRef.hash` (or `refHash` for the app
-*    space when provided). Empty-graph spaces fail loudly — a
-*    "never planned" space is a user-error condition for replay.
+*    space when provided). An empty-graph space whose elements are ALL
+*    externally managed resolves declaratively (marker to head, zero
+*    ops), mirroring the db-init aggregate planner: such a space ships
+*    no DDL and has nothing to author. Every other empty-graph space
+*    fails loudly — "never planned" is a user-error condition for
+*    replay.
 * 4. Hand off to {@link runMigration} (the runner-driving tail
 *    shared with `db init` / `db update`). Marker advancement is
 *    inside the per-space transaction.
 *
-* Encodes the replay-only contract: every contract space must have an
+* Encodes the replay-only contract: the app contract space must have an
 * authored migration graph on disk before this operation can advance it.
 */
 async function executeMigrate(options) {
@@ -813,7 +816,10 @@ async function executeMigrate(options) {
 	}
 	const canonicalOrder = [...aggregate.extensions.map((m) => m.spaceId), aggregate.app.spaceId];
 	const applyOrder = canonicalOrder.filter((spaceId) => perSpacePlans.has(spaceId));
-	if (sumPlannedOps(applyOrder, perSpacePlans) === 0) {
+	if (!applyOrder.some((spaceId) => {
+		const entry = perSpacePlans.get(spaceId);
+		return entry !== void 0 && planRequiresExecution(entry);
+	})) {
 		const ordered = canonicalOrder.filter((spaceId) => perSpacePlans.has(spaceId) || atHeadResolutions.has(spaceId)).map((spaceId) => {
 			const entry = perSpacePlans.get(spaceId) ?? atHeadResolutions.get(spaceId);
 			if (entry === void 0) throw new Error(`Unreachable: missing per-space plan for "${spaceId}"`);
@@ -906,6 +912,27 @@ function planSpacePath({ space, aggregate, targetHash, refInvariants, liveMarker
 				liveMarker
 			})
 		};
+		if (!isAppSpace && allStorageElementsExternal(space.contract())) {
+			if (headRef.invariants.length > 0) return {
+				kind: "unsatisfiable",
+				spaceId: space.spaceId,
+				isAppSpace,
+				missing: [...headRef.invariants].sort(),
+				targetInvariants: headRef.invariants,
+				targetSpace: space,
+				liveHash: liveHash ?? EMPTY_CONTRACT_HASH,
+				refName: void 0
+			};
+			return {
+				kind: "ok",
+				plan: buildAtHeadResolution({
+					aggregateTargetId: aggregate.targetId,
+					space,
+					targetHash,
+					liveMarker
+				})
+			};
+		}
 		return {
 			kind: "never-planned",
 			spaceId: space.spaceId,
@@ -951,11 +978,13 @@ function planSpacePath({ space, aggregate, targetHash, refInvariants, liveMarker
 	};
 }
 /**
-* Build a zero-op {@link PerSpacePlan} for an empty-graph
-* space whose live marker already matches the target. Lets the apply
-* pipeline thread the space through `perSpacePlans` -> `applyOrder`
-* -> the success envelope's `perSpace[]` block so the result reflects
-* every loaded space, even when there is nothing to execute.
+* Build a zero-op {@link PerSpacePlan} for an empty-graph space —
+* either one whose live marker already matches the target (at-head), or
+* an all-external extension space whose marker must advance to the head
+* ref with no DDL (declared-state). Lets the apply pipeline thread the
+* space through `perSpacePlans` -> `applyOrder` -> the success
+* envelope's `perSpace[]` block so the result reflects every loaded
+* space, even when there is nothing to execute.
 */
 function buildAtHeadResolution(args) {
 	const { aggregateTargetId, space, targetHash, liveMarker } = args;
@@ -978,14 +1007,14 @@ function buildAtHeadResolution(args) {
 		})]
 	};
 }
-function sumPlannedOps(applyOrder, perSpacePlans) {
-	let total = 0;
-	for (const spaceId of applyOrder) {
-		const entry = perSpacePlans.get(spaceId);
-		if (!entry) continue;
-		total += entry.plan.operations.length;
-	}
-	return total;
+/**
+* A plan needs the runner when it executes operations or advances the
+* space's marker (a declared-state resolution has zero operations but a
+* destination hash the live marker doesn't carry yet).
+*/
+function planRequiresExecution(entry) {
+	if (entry.plan.operations.length > 0) return true;
+	return entry.plan.origin?.storageHash !== entry.plan.destination.storageHash;
 }
 function buildSuccess(args) {
 	const appResolution = args.orderedResolutions.find((r) => r.spaceId === args.aggregate.app.spaceId);
@@ -1027,10 +1056,12 @@ function buildSuccess(args) {
 	};
 }
 /**
-* 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`.
+* Build the `neverPlanned` failure raised when a contract space that
+* declares managed storage elements has no on-disk migration graph but
+* migrate was asked to reach a target hash. All-external spaces never reach
+* this: they resolve declaratively (marker advances to the head ref with
+* zero operations). The `why` states only the condition; the recovery
+* sequence is composed by `errorPathUnreachable`'s `fix`.
 *
 * @internal Exported for testing only.
 */
@@ -1038,7 +1069,7 @@ 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}".`,
+		why: `migrate is replay-only: a contract space that declares managed storage elements 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,
@@ -1594,4 +1625,4 @@ var ControlClientImpl = class {
 //#endregion
 export { executeDbInit as a, executeDbUpdate as i, planSpacePath as n, ContractValidationError as o, executeDbVerify as r, createControlClient as t };
 
-//# sourceMappingURL=client-DigVI8zX.mjs.map
+//# sourceMappingURL=client-2kwLMBSf.mjs.map