@prisma-next/migration-tools 0.5.0-dev.67 → 0.5.0-dev.68

package/dist/migration-graph-DGNnKDY5.mjs

@@ -0,0 +1,523 @@
+import { S as errorNoTarget, b as errorNoInitialMigration, n as errorAmbiguousTarget, o as errorDuplicateMigrationHash, w as errorSameSourceAndTarget } from "./errors-EPL_9p9f.mjs";
+import { t as EMPTY_CONTRACT_HASH } from "./constants-DWV9_o2Z.mjs";
+import { ifDefined } from "@prisma-next/utils/defined";
+//#region src/queue.ts
+/**
+* FIFO queue with amortised O(1) push and shift.
+*
+* Uses a head-index cursor over a backing array rather than
+* `Array.prototype.shift()`, which is O(n) on V8. Intended for BFS-shaped
+* traversals where the queue is drained in a single pass — it does not
+* reclaim memory for already-shifted items, so it is not suitable for
+* long-lived queues with many push/shift cycles.
+*/
+var Queue = class {
+	items;
+	head = 0;
+	constructor(initial = []) {
+		this.items = [...initial];
+	}
+	push(item) {
+		this.items.push(item);
+	}
+	/**
+	* Remove and return the next item. Caller must check `isEmpty` first —
+	* shifting an empty queue throws.
+	*/
+	shift() {
+		if (this.head >= this.items.length) throw new Error("Queue.shift called on empty queue");
+		return this.items[this.head++];
+	}
+	get isEmpty() {
+		return this.head >= this.items.length;
+	}
+};
+//#endregion
+//#region src/graph-ops.ts
+function* bfs(starts, neighbours, key = (state) => state) {
+	const visited = /* @__PURE__ */ new Set();
+	const parentMap = /* @__PURE__ */ new Map();
+	const queue = new Queue();
+	for (const start of starts) {
+		const k = key(start);
+		if (!visited.has(k)) {
+			visited.add(k);
+			queue.push({
+				state: start,
+				key: k
+			});
+		}
+	}
+	while (!queue.isEmpty) {
+		const { state: current, key: curKey } = queue.shift();
+		const parentInfo = parentMap.get(curKey);
+		yield {
+			state: current,
+			parent: parentInfo?.parent ?? null,
+			incomingEdge: parentInfo?.edge ?? null
+		};
+		for (const { next, edge } of neighbours(current)) {
+			const k = key(next);
+			if (!visited.has(k)) {
+				visited.add(k);
+				parentMap.set(k, {
+					parent: current,
+					edge
+				});
+				queue.push({
+					state: next,
+					key: k
+				});
+			}
+		}
+	}
+}
+//#endregion
+//#region src/migration-graph.ts
+/** Forward-edge neighbours: edge `e` from `n` visits `e.to` next. */
+function forwardNeighbours(graph, node) {
+	return (graph.forwardChain.get(node) ?? []).map((edge) => ({
+		next: edge.to,
+		edge
+	}));
+}
+/**
+* Forward-edge neighbours, sorted by the deterministic tie-break.
+* Used by path-finding so the resulting shortest path is stable across runs.
+*/
+function sortedForwardNeighbours(graph, node) {
+	return [...graph.forwardChain.get(node) ?? []].sort(compareTieBreak).map((edge) => ({
+		next: edge.to,
+		edge
+	}));
+}
+/** Reverse-edge neighbours: edge `e` from `n` visits `e.from` next. */
+function reverseNeighbours(graph, node) {
+	return (graph.reverseChain.get(node) ?? []).map((edge) => ({
+		next: edge.from,
+		edge
+	}));
+}
+function appendEdge(map, key, entry) {
+	const bucket = map.get(key);
+	if (bucket) bucket.push(entry);
+	else map.set(key, [entry]);
+}
+function reconstructGraph(packages) {
+	const nodes = /* @__PURE__ */ new Set();
+	const forwardChain = /* @__PURE__ */ new Map();
+	const reverseChain = /* @__PURE__ */ new Map();
+	const migrationByHash = /* @__PURE__ */ new Map();
+	for (const pkg of packages) {
+		const from = pkg.metadata.from ?? "sha256:empty";
+		const { to } = pkg.metadata;
+		if (from === to) {
+			if (!pkg.ops.some((op) => op.operationClass === "data")) throw errorSameSourceAndTarget(pkg.dirPath, from);
+		}
+		nodes.add(from);
+		nodes.add(to);
+		const migration = {
+			from,
+			to,
+			migrationHash: pkg.metadata.migrationHash,
+			dirName: pkg.dirName,
+			createdAt: pkg.metadata.createdAt,
+			labels: pkg.metadata.labels,
+			invariants: pkg.metadata.providedInvariants
+		};
+		if (migrationByHash.has(migration.migrationHash)) throw errorDuplicateMigrationHash(migration.migrationHash);
+		migrationByHash.set(migration.migrationHash, migration);
+		appendEdge(forwardChain, from, migration);
+		appendEdge(reverseChain, to, migration);
+	}
+	return {
+		nodes,
+		forwardChain,
+		reverseChain,
+		migrationByHash
+	};
+}
+const LABEL_PRIORITY = {
+	main: 0,
+	default: 1,
+	feature: 2
+};
+function labelPriority(labels) {
+	let best = 3;
+	for (const l of labels) {
+		const p = LABEL_PRIORITY[l];
+		if (p !== void 0 && p < best) best = p;
+	}
+	return best;
+}
+function compareTieBreak(a, b) {
+	const lp = labelPriority(a.labels) - labelPriority(b.labels);
+	if (lp !== 0) return lp;
+	const ca = a.createdAt.localeCompare(b.createdAt);
+	if (ca !== 0) return ca;
+	const tc = a.to.localeCompare(b.to);
+	if (tc !== 0) return tc;
+	return a.migrationHash.localeCompare(b.migrationHash);
+}
+function sortedNeighbors(edges) {
+	return [...edges].sort(compareTieBreak);
+}
+/**
+* Find the shortest path from `fromHash` to `toHash` using BFS over the
+* contract-hash graph. Returns the ordered list of edges, or null if no path
+* exists. Returns an empty array when `fromHash === toHash` (no-op).
+*
+* Neighbor ordering is deterministic via the tie-break sort key:
+* label priority → createdAt → to → migrationHash.
+*/
+function findPath(graph, fromHash, toHash) {
+	if (fromHash === toHash) return [];
+	const parents = /* @__PURE__ */ new Map();
+	for (const step of bfs([fromHash], (n) => sortedForwardNeighbours(graph, n))) {
+		if (step.parent !== null && step.incomingEdge !== null) parents.set(step.state, {
+			parent: step.parent,
+			edge: step.incomingEdge
+		});
+		if (step.state === toHash) {
+			const path = [];
+			let cur = toHash;
+			let p = parents.get(cur);
+			while (p) {
+				path.push(p.edge);
+				cur = p.parent;
+				p = parents.get(cur);
+			}
+			path.reverse();
+			return path;
+		}
+	}
+	return null;
+}
+/**
+* Find the shortest path from `fromHash` to `toHash` whose edges collectively
+* cover every invariant in `required`. Returns `null` when no such path exists
+* (either `fromHash`→`toHash` is structurally unreachable, or every reachable
+* path leaves at least one required invariant uncovered). When `required` is
+* empty, delegates to `findPath` so the result is byte-identical for that case.
+*
+* Algorithm: BFS over `(node, coveredSubset)` states with state-level dedup.
+* The covered subset is a `Set<string>` of invariant ids; the state's dedup
+* key is `${node}\0${[...covered].sort().join('\0')}`. State keys distinguish
+* distinct `(node, covered)` tuples regardless of node-name length because
+* `\0` cannot appear in any invariant id (validation rejects whitespace and
+* control chars at authoring time).
+*
+* Neighbour ordering when `required ≠ ∅`: edges covering ≥1 still-needed
+* invariant come first, with `labelPriority → createdAt → to → migrationHash`
+* as the secondary key. The heuristic steers BFS toward the satisfying path;
+* correctness (shortest, deterministic) does not depend on it.
+*/
+function findPathWithInvariants(graph, fromHash, toHash, required) {
+	if (required.size === 0) return findPath(graph, fromHash, toHash);
+	const stateKey = (s) => {
+		if (s.covered.size === 0) return `${s.node}\0`;
+		return `${s.node}\0${[...s.covered].sort().join("\0")}`;
+	};
+	const neighbours = (s) => {
+		const outgoing = graph.forwardChain.get(s.node) ?? [];
+		if (outgoing.length === 0) return [];
+		return [...outgoing].map((edge) => {
+			let useful = false;
+			let next = null;
+			for (const inv of edge.invariants) if (required.has(inv) && !s.covered.has(inv)) {
+				if (next === null) next = new Set(s.covered);
+				next.add(inv);
+				useful = true;
+			}
+			return {
+				edge,
+				useful,
+				nextCovered: next ?? s.covered
+			};
+		}).sort((a, b) => {
+			if (a.useful !== b.useful) return a.useful ? -1 : 1;
+			return compareTieBreak(a.edge, b.edge);
+		}).map(({ edge, nextCovered }) => ({
+			next: {
+				node: edge.to,
+				covered: nextCovered
+			},
+			edge
+		}));
+	};
+	const parents = /* @__PURE__ */ new Map();
+	for (const step of bfs([{
+		node: fromHash,
+		covered: /* @__PURE__ */ new Set()
+	}], neighbours, stateKey)) {
+		const curKey = stateKey(step.state);
+		if (step.parent !== null && step.incomingEdge !== null) parents.set(curKey, {
+			parentKey: stateKey(step.parent),
+			edge: step.incomingEdge
+		});
+		if (step.state.node === toHash && step.state.covered.size === required.size) {
+			const path = [];
+			let cur = curKey;
+			while (cur !== void 0) {
+				const p = parents.get(cur);
+				if (!p) break;
+				path.push(p.edge);
+				cur = p.parentKey;
+			}
+			path.reverse();
+			return path;
+		}
+	}
+	return null;
+}
+/**
+* Reverse-BFS from `toHash` over `reverseChain` to collect every node from
+* which `toHash` is reachable (inclusive of `toHash` itself).
+*/
+function collectNodesReachingTarget(graph, toHash) {
+	const reached = /* @__PURE__ */ new Set();
+	for (const step of bfs([toHash], (n) => reverseNeighbours(graph, n))) reached.add(step.state);
+	return reached;
+}
+/**
+* Find the shortest path from `fromHash` to `toHash` and return structured
+* path-decision metadata for machine-readable output. When `required` is
+* non-empty, the returned path is the shortest one whose edges collectively
+* cover every required invariant.
+*
+* The discriminated return type tells the caller *why* a path could not be
+* found, so the CLI can pick the right structured error without re-running
+* a structural BFS.
+*/
+function findPathWithDecision(graph, fromHash, toHash, options = {}) {
+	const { refName, required = /* @__PURE__ */ new Set() } = options;
+	const requiredInvariants = [...required].sort();
+	if (fromHash === toHash && required.size === 0) return {
+		kind: "ok",
+		decision: {
+			selectedPath: [],
+			fromHash,
+			toHash,
+			alternativeCount: 0,
+			tieBreakReasons: [],
+			requiredInvariants,
+			satisfiedInvariants: [],
+			...ifDefined("refName", refName)
+		}
+	};
+	const path = findPathWithInvariants(graph, fromHash, toHash, required);
+	if (!path) {
+		if (required.size === 0) return { kind: "unreachable" };
+		const structural = findPath(graph, fromHash, toHash);
+		if (structural === null) return { kind: "unreachable" };
+		const coveredByStructural = /* @__PURE__ */ new Set();
+		for (const edge of structural) for (const inv of edge.invariants) if (required.has(inv)) coveredByStructural.add(inv);
+		return {
+			kind: "unsatisfiable",
+			structuralPath: structural,
+			missing: requiredInvariants.filter((id) => !coveredByStructural.has(id))
+		};
+	}
+	const satisfiedInvariants = computeSatisfiedInvariants(required, path);
+	const reachesTarget = collectNodesReachingTarget(graph, toHash);
+	const coveragePrefixes = requiredCoveragePrefixes(required, path);
+	const tieBreakReasons = [];
+	let alternativeCount = 0;
+	for (const [i, edge] of path.entries()) {
+		const outgoing = graph.forwardChain.get(edge.from);
+		if (!outgoing || outgoing.length <= 1) continue;
+		const reachable = outgoing.filter((e) => reachesTarget.has(e.to));
+		if (reachable.length <= 1) continue;
+		let comparisonPool = reachable;
+		if (required.size > 0) {
+			const prefixSet = coveragePrefixes[i];
+			if (prefixSet === void 0) continue;
+			comparisonPool = invariantViableAlternativesAtStep(required, prefixSet, reachable);
+		}
+		alternativeCount += reachable.length - 1;
+		if (sortedNeighbors(reachable)[0]?.migrationHash !== edge.migrationHash) continue;
+		if (!reachable.some((e) => e.migrationHash !== edge.migrationHash)) continue;
+		const sortedViable = sortedNeighbors(comparisonPool);
+		if (sortedViable.length > 1 && sortedViable[0]?.migrationHash === edge.migrationHash && sortedViable.some((e) => e.migrationHash !== edge.migrationHash)) tieBreakReasons.push(`at ${edge.from}: ${comparisonPool.length} candidates, selected by tie-break`);
+	}
+	return {
+		kind: "ok",
+		decision: {
+			selectedPath: path,
+			fromHash,
+			toHash,
+			alternativeCount,
+			tieBreakReasons,
+			requiredInvariants,
+			satisfiedInvariants,
+			...ifDefined("refName", refName)
+		}
+	};
+}
+function computeSatisfiedInvariants(required, path) {
+	if (required.size === 0) return [];
+	const covered = /* @__PURE__ */ new Set();
+	for (const edge of path) for (const inv of edge.invariants) if (required.has(inv)) covered.add(inv);
+	return [...covered].sort();
+}
+/**
+* For each edge on path, invariant coverage accumulated from earlier edges only —
+* `(required ∩ ∪_{j<i} path[j].invariants)` represented as cumulative set along `required`,
+* keyed as "full set of required ids satisfied before taking path[i]".
+*/
+function requiredCoveragePrefixes(required, path) {
+	const prefixes = [];
+	const acc = /* @__PURE__ */ new Set();
+	for (const edge of path) {
+		prefixes.push(new Set(acc));
+		for (const inv of edge.invariants) if (required.has(inv)) acc.add(inv);
+	}
+	return prefixes;
+}
+function invariantViableAlternativesAtStep(required, coverageBeforeTakingEdge, outgoing) {
+	if (required.size === 0) return [...outgoing];
+	return outgoing.filter((e) => [...required].every((id) => coverageBeforeTakingEdge.has(id) || e.invariants.includes(id)));
+}
+/**
+* Walk ancestors of each branch tip back to find the last node
+* that appears on all paths. Returns `fromHash` if no shared ancestor is found.
+*/
+function findDivergencePoint(graph, fromHash, leaves) {
+	const ancestorSets = leaves.map((leaf) => {
+		const ancestors = /* @__PURE__ */ new Set();
+		for (const step of bfs([leaf], (n) => reverseNeighbours(graph, n))) ancestors.add(step.state);
+		return ancestors;
+	});
+	const commonAncestors = [...ancestorSets[0] ?? []].filter((node) => ancestorSets.every((s) => s.has(node)));
+	let deepest = fromHash;
+	let deepestDepth = -1;
+	for (const ancestor of commonAncestors) {
+		const path = findPath(graph, fromHash, ancestor);
+		const depth = path ? path.length : 0;
+		if (depth > deepestDepth) {
+			deepestDepth = depth;
+			deepest = ancestor;
+		}
+	}
+	return deepest;
+}
+/**
+* Find all branch tips (nodes with no outgoing edges) reachable from
+* `fromHash` via forward edges.
+*/
+function findReachableLeaves(graph, fromHash) {
+	const leaves = [];
+	for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n))) if (!graph.forwardChain.get(step.state)?.length) leaves.push(step.state);
+	return leaves;
+}
+/**
+* Find the target contract hash of the migration graph reachable from
+* EMPTY_CONTRACT_HASH. Returns `null` for a graph that has no target
+* state (either empty, or containing only the root with no outgoing
+* edges). Throws NO_INITIAL_MIGRATION if the graph has nodes but none
+* originate from the empty hash, and AMBIGUOUS_TARGET if multiple
+* branch tips exist.
+*/
+function findLeaf(graph) {
+	if (graph.nodes.size === 0) return null;
+	if (!graph.nodes.has("sha256:empty")) throw errorNoInitialMigration([...graph.nodes]);
+	const leaves = findReachableLeaves(graph, EMPTY_CONTRACT_HASH);
+	if (leaves.length === 0) {
+		const reachable = [...graph.nodes].filter((n) => n !== EMPTY_CONTRACT_HASH);
+		if (reachable.length > 0) throw errorNoTarget(reachable);
+		return null;
+	}
+	if (leaves.length > 1) {
+		const divergencePoint = findDivergencePoint(graph, EMPTY_CONTRACT_HASH, leaves);
+		throw errorAmbiguousTarget(leaves, {
+			divergencePoint,
+			branches: leaves.map((tip) => {
+				return {
+					tip,
+					edges: (findPath(graph, divergencePoint, tip) ?? []).map((e) => ({
+						dirName: e.dirName,
+						from: e.from,
+						to: e.to
+					}))
+				};
+			})
+		});
+	}
+	return leaves[0];
+}
+/**
+* Find the latest migration entry by traversing from EMPTY_CONTRACT_HASH
+* to the single target. Returns null for an empty graph.
+* Throws AMBIGUOUS_TARGET if the graph has multiple branch tips.
+*/
+function findLatestMigration(graph) {
+	const leafHash = findLeaf(graph);
+	if (leafHash === null) return null;
+	return findPath(graph, "sha256:empty", leafHash)?.at(-1) ?? null;
+}
+function detectCycles(graph) {
+	const WHITE = 0;
+	const GRAY = 1;
+	const BLACK = 2;
+	const color = /* @__PURE__ */ new Map();
+	const parentMap = /* @__PURE__ */ new Map();
+	const cycles = [];
+	for (const node of graph.nodes) color.set(node, WHITE);
+	const stack = [];
+	function pushFrame(u) {
+		color.set(u, GRAY);
+		stack.push({
+			node: u,
+			outgoing: graph.forwardChain.get(u) ?? [],
+			index: 0
+		});
+	}
+	for (const root of graph.nodes) {
+		if (color.get(root) !== WHITE) continue;
+		parentMap.set(root, null);
+		pushFrame(root);
+		while (stack.length > 0) {
+			const frame = stack[stack.length - 1];
+			if (frame.index >= frame.outgoing.length) {
+				color.set(frame.node, BLACK);
+				stack.pop();
+				continue;
+			}
+			const v = frame.outgoing[frame.index++].to;
+			const vColor = color.get(v);
+			if (vColor === GRAY) {
+				const cycle = [v];
+				let cur = frame.node;
+				while (cur !== v) {
+					cycle.push(cur);
+					cur = parentMap.get(cur) ?? v;
+				}
+				cycle.reverse();
+				cycles.push(cycle);
+			} else if (vColor === WHITE) {
+				parentMap.set(v, frame.node);
+				pushFrame(v);
+			}
+		}
+	}
+	return cycles;
+}
+function detectOrphans(graph) {
+	if (graph.nodes.size === 0) return [];
+	const reachable = /* @__PURE__ */ new Set();
+	const startNodes = [];
+	if (graph.forwardChain.has("sha256:empty")) startNodes.push(EMPTY_CONTRACT_HASH);
+	else {
+		const allTargets = /* @__PURE__ */ new Set();
+		for (const edges of graph.forwardChain.values()) for (const edge of edges) allTargets.add(edge.to);
+		for (const node of graph.nodes) if (!allTargets.has(node)) startNodes.push(node);
+	}
+	for (const step of bfs(startNodes, (n) => forwardNeighbours(graph, n))) reachable.add(step.state);
+	const orphans = [];
+	for (const [from, migrations] of graph.forwardChain) if (!reachable.has(from)) orphans.push(...migrations);
+	return orphans;
+}
+//#endregion
+export { findPath as a, findReachableLeaves as c, findLeaf as i, reconstructGraph as l, detectOrphans as n, findPathWithDecision as o, findLatestMigration as r, findPathWithInvariants as s, detectCycles as t };
+
+//# sourceMappingURL=migration-graph-DGNnKDY5.mjs.map