@prisma-next/cli 0.12.0-dev.27 → 0.12.0-dev.29

package/src/utils/formatters/migration-graph-lane-colors.ts

@@ -1,4 +1,5 @@
 import { createColors } from 'colorette';
+import type { StructuralCell } from './migration-graph-layout';
 
 export type LaneColorizer = (text: string) => string;
 
@@ -13,6 +14,12 @@ export const LANE_COLOR_CYCLE: readonly LaneColorizer[] = [
   red,
 ];
 
+/**
+ * The leftmost lane (column 0) renders neutral — no palette hue. Columns ≥ 1
+ * rotate through {@link LANE_COLOR_CYCLE}.
+ */
+export const NEUTRAL_LANE_COLUMN = 0;
+
 /**
  * The hue for a gutter column. The leftmost lane (column 0) is **neutral** — it
  * has nothing to be told apart from in the common single-lane linear case, so
@@ -23,9 +30,165 @@ export const LANE_COLOR_CYCLE: readonly LaneColorizer[] = [
  * branch identity, exactly like `git log --graph`.
  */
 export function laneColorForColumn(column: number): LaneColorizer {
-  if (column <= 0) {
+  if (column <= NEUTRAL_LANE_COLUMN) {
     return (text) => text;
   }
   const colorizer = LANE_COLOR_CYCLE[(column - 1) % LANE_COLOR_CYCLE.length];
   return colorizer ?? ((text) => text);
 }
+
+/**
+ * Style a structural glyph by its resolved colour column. Column 0 and the
+ * neutral sentinel render dim (`dimLane`); columns ≥ 1 take a palette hue.
+ */
+export function stylerForLaneColumn(
+  colorColumn: number,
+  colorize: boolean,
+  dimLane: (text: string) => string,
+): LaneColorizer {
+  if (!colorize || colorColumn <= NEUTRAL_LANE_COLUMN) {
+    return dimLane;
+  }
+  return laneColorForColumn(colorColumn);
+}
+
+/**
+ * The colour-source column for each cell of a row, resolved together because a
+ * routed back-arc spans columns and must read as **one hue** rather than a
+ * per-column "rainbow".
+ */
+export interface RowArcLaneColors {
+  /** Colour column for a cell's structural glyph (lane / spine / arc body). */
+  readonly lane: readonly number[];
+  /** Colour column for a node arc-pair's connector half (`◂` / `─`). */
+  readonly connector: readonly number[];
+  /**
+   * Colour column for the trailing `─` of a landing tee (`┴─`). The junction
+   * (`lane`) keeps its own column; the dash leads into the next converging arc.
+   */
+  readonly dash: readonly number[];
+}
+
+/**
+ * Resolve per-cell colour columns for a node/arc row. Scanning right-to-left
+ * lets each arc segment inherit the hue of the arc it leads into.
+ */
+export function resolveRowArcLaneColors(cells: readonly StructuralCell[]): RowArcLaneColors {
+  const lane = new Array<number>(cells.length);
+  const connector = new Array<number>(cells.length);
+  const dash = new Array<number>(cells.length);
+  let arcCorner = NEUTRAL_LANE_COLUMN;
+  let landingAnchor = NEUTRAL_LANE_COLUMN;
+  for (let column = cells.length - 1; column >= 0; column--) {
+    const cell = cells[column];
+    connector[column] = landingAnchor !== NEUTRAL_LANE_COLUMN ? landingAnchor : arcCorner;
+    switch (cell?.kind) {
+      case 'arc-branch-corner':
+        arcCorner = column;
+        lane[column] = column;
+        dash[column] = column;
+        break;
+      case 'arc-land-corner':
+        arcCorner = column;
+        landingAnchor = column;
+        lane[column] = column;
+        dash[column] = column;
+        break;
+      case 'arc-branch-tee':
+        lane[column] = column;
+        dash[column] = column;
+        break;
+      case 'arc-land-tee':
+        lane[column] = column;
+        dash[column] = landingAnchor === NEUTRAL_LANE_COLUMN ? column : landingAnchor;
+        landingAnchor = column;
+        break;
+      case 'arc-crossing':
+      case 'arc-land-bridge': {
+        const served = landingAnchor !== NEUTRAL_LANE_COLUMN ? landingAnchor : arcCorner;
+        lane[column] = served;
+        dash[column] = served;
+        break;
+      }
+      case 'horizontal-pass':
+        lane[column] = arcCorner === NEUTRAL_LANE_COLUMN ? column : arcCorner;
+        dash[column] = lane[column] ?? column;
+        break;
+      case 'node':
+        lane[column] = column;
+        dash[column] = column;
+        arcCorner = NEUTRAL_LANE_COLUMN;
+        landingAnchor = NEUTRAL_LANE_COLUMN;
+        break;
+      default:
+        lane[column] = column;
+        dash[column] = column;
+        arcCorner = NEUTRAL_LANE_COLUMN;
+        landingAnchor = NEUTRAL_LANE_COLUMN;
+    }
+  }
+  return { lane, connector, dash };
+}
+
+/**
+ * Per-cell colour for a forward branch/merge connector row, split into the
+ * cell's junction `glyph` and its trailing `dash`.
+ */
+export interface ConnectorLaneColors {
+  /** Colour column for a cell's junction glyph (`├` / `┬` / `┴` / `╮` / `╯`). */
+  readonly glyph: readonly number[];
+  /** Colour column for a tee's trailing `─` — the branch it leads into. */
+  readonly dash: readonly number[];
+}
+
+/**
+ * Resolve per-cell connector colours. Scanning right-to-left, a corner or an
+ * intermediate tee anchors its own lane, but a tee's trailing dash leads into
+ * the branch on its right.
+ */
+export function resolveConnectorLaneColors(
+  cells: readonly StructuralCell[],
+  startLane: number,
+): ConnectorLaneColors {
+  const glyph = new Array<number>(cells.length);
+  const dash = new Array<number>(cells.length);
+  let owner = NEUTRAL_LANE_COLUMN;
+  for (let column = cells.length - 1; column >= 0; column--) {
+    const cell = cells[column];
+    switch (cell?.kind) {
+      case 'branch-corner':
+      case 'merge-corner':
+        owner = column;
+        glyph[column] = column;
+        dash[column] = column;
+        break;
+      case 'branch-tee':
+      case 'merge-tee':
+        if (column === startLane) {
+          const served = owner === NEUTRAL_LANE_COLUMN ? column : owner;
+          glyph[column] = column;
+          dash[column] = served;
+        } else {
+          dash[column] = owner === NEUTRAL_LANE_COLUMN ? column : owner;
+          glyph[column] = column;
+          owner = column;
+        }
+        break;
+      case 'arc-crossing':
+        glyph[column] = column;
+        dash[column] = owner === NEUTRAL_LANE_COLUMN ? column : owner;
+        owner = column;
+        break;
+      case 'horizontal-pass': {
+        const served = owner === NEUTRAL_LANE_COLUMN ? column : owner;
+        glyph[column] = served;
+        dash[column] = served;
+        break;
+      }
+      default:
+        glyph[column] = column;
+        dash[column] = column;
+    }
+  }
+  return { glyph, dash };
+}

package/src/utils/formatters/migration-graph-rows.ts

@@ -173,10 +173,19 @@ function compareNodesTipsFirst(a: string, b: string, rank: ReadonlyMap<string, n
  * at the same rank — stable across edge-insertion order and correct under
  * diamonds, cross-links, and rollbacks.
  */
+function maxRank(rank: ReadonlyMap<string, number>): number {
+  let max = 0;
+  for (const value of rank.values()) {
+    if (value > max) max = value;
+  }
+  return max;
+}
+
 function layerNodesByLongestForwardPath(
   componentNodes: ReadonlySet<string>,
   topology: MigrationListGraphTopology,
   graph: MigrationGraph,
+  contractHash: string | undefined,
 ): readonly string[] {
   const forwardOut = new Map<string, string[]>();
 
@@ -224,6 +233,15 @@ function layerNodesByLongestForwardPath(
     }
   }
 
+  if (
+    contractHash !== undefined &&
+    contractHash !== EMPTY_CONTRACT_HASH &&
+    componentNodes.has(contractHash) &&
+    (forwardOut.get(contractHash) ?? []).length === 0
+  ) {
+    rank.set(contractHash, maxRank(rank) + 1);
+  }
+
   return [...componentNodes].sort((a, b) => compareNodesTipsFirst(a, b, rank));
 }
 
@@ -262,6 +280,99 @@ function detachedContractHash(
     : undefined;
 }
 
+function isForwardLeaf(node: string, edges: readonly ClassifiedEdge[]): boolean {
+  return !edges.some((e) => e.kind === 'forward' && e.from === node && e.from !== e.to);
+}
+
+function forwardReachableFrom(
+  start: string,
+  forwardTo: ReadonlyMap<string, readonly string[]>,
+): ReadonlySet<string> {
+  const reachable = new Set<string>([start]);
+  const queue = [start];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    if (node === undefined) continue;
+    for (const next of forwardTo.get(node) ?? []) {
+      if (!reachable.has(next)) {
+        reachable.add(next);
+        queue.push(next);
+      }
+    }
+  }
+  return reachable;
+}
+
+function buildForwardToMap(edges: readonly ClassifiedEdge[]): Map<string, string[]> {
+  const forwardTo = new Map<string, string[]>();
+  for (const edge of edges) {
+    if (edge.kind !== 'forward' || edge.from === edge.to) continue;
+    const bucket = forwardTo.get(edge.from);
+    if (bucket) bucket.push(edge.to);
+    else forwardTo.set(edge.from, [edge.to]);
+  }
+  return forwardTo;
+}
+
+function sortEdgesForContractHashTrunk(
+  edges: ClassifiedEdge[],
+  contractHash: string | undefined,
+): ClassifiedEdge[] {
+  if (
+    contractHash === undefined ||
+    contractHash === EMPTY_CONTRACT_HASH ||
+    !isForwardLeaf(contractHash, edges)
+  ) {
+    return edges;
+  }
+
+  const preferredLeaf = contractHash;
+  const forwardTo = buildForwardToMap(edges);
+  const reachability = new Map<string, ReadonlySet<string>>();
+  function canReachContractHash(from: string): boolean {
+    let cached = reachability.get(from);
+    if (cached === undefined) {
+      cached = forwardReachableFrom(from, forwardTo);
+      reachability.set(from, cached);
+    }
+    return cached.has(preferredLeaf);
+  }
+
+  function trunkBias(edge: ClassifiedEdge): number {
+    if (edge.kind !== 'forward' || edge.from === edge.to) return 0;
+    if (edge.to === preferredLeaf) return 2;
+    if (canReachContractHash(edge.to)) return 1;
+    return 0;
+  }
+
+  return edges
+    .map((edge, index) => ({ edge, index, bias: trunkBias(edge) }))
+    .sort((a, b) => {
+      if (a.edge.from !== b.edge.from) return a.index - b.index;
+      if (a.bias !== b.bias) return b.bias - a.bias;
+      return a.index - b.index;
+    })
+    .map(({ edge }) => edge);
+}
+
+function rebuildEdgeLookupMaps(edges: readonly ClassifiedEdge[]): {
+  edgesByFrom: Map<string, ClassifiedEdge[]>;
+  edgesByTo: Map<string, ClassifiedEdge[]>;
+} {
+  const edgesByFrom = new Map<string, ClassifiedEdge[]>();
+  const edgesByTo = new Map<string, ClassifiedEdge[]>();
+  for (const classified of edges) {
+    const fromBucket = edgesByFrom.get(classified.from);
+    if (fromBucket) fromBucket.push(classified);
+    else edgesByFrom.set(classified.from, [classified]);
+
+    const toBucket = edgesByTo.get(classified.to);
+    if (toBucket) toBucket.push(classified);
+    else edgesByTo.set(classified.to, [classified]);
+  }
+  return { edgesByFrom, edgesByTo };
+}
+
 export function buildMigrationGraphRows(
   graph: MigrationGraph,
   options: BuildMigrationGraphRowsOptions = {},
@@ -284,31 +395,23 @@ export function buildMigrationGraphRows(
 
   // 2. Build classified edge list
   const edges: ClassifiedEdge[] = [];
-  const edgesByFrom = new Map<string, ClassifiedEdge[]>();
-  const edgesByTo = new Map<string, ClassifiedEdge[]>();
 
   for (const edgeList of graph.forwardChain.values()) {
     for (const edge of edgeList) {
       const kind = topology.kindByMigrationHash.get(edge.migrationHash) ?? 'forward';
-      const classified: ClassifiedEdge = {
+      edges.push({
         migrationHash: edge.migrationHash,
         from: edge.from,
         to: edge.to,
         dirName: edge.dirName,
         kind,
-      };
-      edges.push(classified);
-
-      const fromBucket = edgesByFrom.get(edge.from);
-      if (fromBucket) fromBucket.push(classified);
-      else edgesByFrom.set(edge.from, [classified]);
-
-      const toBucket = edgesByTo.get(edge.to);
-      if (toBucket) toBucket.push(classified);
-      else edgesByTo.set(edge.to, [classified]);
+      });
     }
   }
 
+  const sortedEdges = sortEdgesForContractHashTrunk(edges, options.contractHash);
+  const { edgesByFrom, edgesByTo } = rebuildEdgeLookupMaps(sortedEdges);
+
   // 3. Find weakly-connected components (ordered: EMPTY first, then lex)
   const components = weaklyConnectedComponents(graph);
 
@@ -318,7 +421,12 @@ export function buildMigrationGraphRows(
     if (i > 0) nodes.push(null);
     const component = components[i];
     if (component === undefined) continue;
-    const ordered = layerNodesByLongestForwardPath(component, topology, graph);
+    const ordered = layerNodesByLongestForwardPath(
+      component,
+      topology,
+      graph,
+      options.contractHash,
+    );
     for (const node of ordered) {
       nodes.push(node);
     }
@@ -332,5 +440,10 @@ export function buildMigrationGraphRows(
     nodes.unshift(detached);
   }
 
-  return { nodes, edges, edgesByFrom, edgesByTo };
+  return {
+    nodes,
+    edges: sortedEdges,
+    edgesByFrom,
+    edgesByTo,
+  };
 }

package/src/utils/formatters/migration-graph-space-render.ts

@@ -0,0 +1,138 @@
+import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
+import type { GlyphMode } from '../glyph-mode';
+import { buildMigrationGraphLayout } from './migration-graph-layout';
+import { buildMigrationGraphRows } from './migration-graph-rows';
+import {
+  computeMaxDirNameLengthForLayout,
+  computeMaxEdgeTreePrefixWidthForLayout,
+  type MigrationEdgeAnnotation,
+  renderMigrationGraphTree,
+} from './migration-graph-tree-render';
+import {
+  buildEdgeAnnotationsByHashFromListEntries,
+  buildRefsByHashFromListEntries,
+  type MigrationListStyler,
+} from './migration-list-render';
+import type { MigrationListEntry } from './migration-list-types';
+
+export { buildEdgeAnnotationsByHashFromListEntries } from './migration-list-render';
+
+export function mergeMigrationEdgeAnnotations(
+  listOverlay: ReadonlyMap<string, MigrationEdgeAnnotation>,
+  statusOverlay: ReadonlyMap<string, MigrationEdgeAnnotation>,
+): ReadonlyMap<string, MigrationEdgeAnnotation> {
+  const merged = new Map<string, MigrationEdgeAnnotation>();
+  for (const [migrationHash, listAnnotation] of listOverlay) {
+    const statusAnnotation = statusOverlay.get(migrationHash);
+    merged.set(migrationHash, {
+      ...listAnnotation,
+      ...(statusAnnotation?.status !== undefined ? { status: statusAnnotation.status } : {}),
+    });
+  }
+  return merged;
+}
+
+export interface RenderMigrationGraphSpaceTreeInput {
+  readonly graph: MigrationGraph;
+  readonly migrations: readonly MigrationListEntry[];
+  readonly liveContractHash: string;
+  readonly glyphMode: GlyphMode;
+  readonly colorize: boolean;
+  readonly refsByHash?: ReadonlyMap<string, readonly string[]>;
+  readonly statusOverlayByHash?: ReadonlyMap<string, MigrationEdgeAnnotation>;
+  readonly dbHash?: string;
+  readonly styler?: MigrationListStyler;
+  readonly globalMaxEdgeTreePrefixWidth?: number;
+  readonly globalMaxDirNameWidth?: number;
+}
+
+export interface ComputeGlobalMaxEdgeTreePrefixWidthInput {
+  readonly graph: MigrationGraph;
+  readonly liveContractHash: string;
+}
+
+export function computeGlobalMaxEdgeTreePrefixWidth(
+  inputs: readonly ComputeGlobalMaxEdgeTreePrefixWidthInput[],
+): number {
+  let globalMax = 0;
+  for (const input of inputs) {
+    const rowModel = buildMigrationGraphRows(input.graph, {
+      contractHash: input.liveContractHash,
+    });
+    const layout = buildMigrationGraphLayout(rowModel);
+    globalMax = Math.max(globalMax, computeMaxEdgeTreePrefixWidthForLayout(layout));
+  }
+  return globalMax;
+}
+
+export function computeGlobalMaxDirNameWidth(
+  inputs: readonly ComputeGlobalMaxEdgeTreePrefixWidthInput[],
+): number {
+  let globalMax = 0;
+  for (const input of inputs) {
+    const rowModel = buildMigrationGraphRows(input.graph, {
+      contractHash: input.liveContractHash,
+    });
+    const layout = buildMigrationGraphLayout(rowModel);
+    globalMax = Math.max(globalMax, computeMaxDirNameLengthForLayout(layout));
+  }
+  return globalMax;
+}
+
+function renderMigrationGraphSpaceTreeInternal(input: RenderMigrationGraphSpaceTreeInput): string {
+  const rowModel = buildMigrationGraphRows(input.graph, {
+    contractHash: input.liveContractHash,
+  });
+  const layout = buildMigrationGraphLayout(rowModel);
+  const listOverlay = buildEdgeAnnotationsByHashFromListEntries(input.migrations);
+  const edgeAnnotationsByHash =
+    input.statusOverlayByHash === undefined
+      ? listOverlay
+      : mergeMigrationEdgeAnnotations(listOverlay, input.statusOverlayByHash);
+  return renderMigrationGraphTree(layout, {
+    refsByHash: input.refsByHash ?? buildRefsByHashFromListEntries(input.migrations),
+    contractHash: input.liveContractHash,
+    edgeAnnotationsByHash,
+    colorize: input.colorize,
+    glyphMode: input.glyphMode,
+    ...(input.dbHash !== undefined ? { dbHash: input.dbHash } : {}),
+    ...(input.styler !== undefined ? { styler: input.styler } : {}),
+    ...(input.globalMaxEdgeTreePrefixWidth !== undefined
+      ? { globalMaxEdgeTreePrefixWidth: input.globalMaxEdgeTreePrefixWidth }
+      : {}),
+    ...(input.globalMaxDirNameWidth !== undefined
+      ? { globalMaxDirNameWidth: input.globalMaxDirNameWidth }
+      : {}),
+  });
+}
+
+export function renderMigrationGraphSpaceTree(input: RenderMigrationGraphSpaceTreeInput): string {
+  return renderMigrationGraphSpaceTreeInternal(input);
+}
+
+export function renderMigrationGraphSpaceTrees(
+  inputs: readonly RenderMigrationGraphSpaceTreeInput[],
+): readonly string[] {
+  const globalMaxTreePrefix =
+    inputs.length > 1 ? computeGlobalMaxEdgeTreePrefixWidth(inputs) : undefined;
+  const globalMaxDirName = inputs.length > 1 ? computeGlobalMaxDirNameWidth(inputs) : undefined;
+  return inputs.map((input) =>
+    renderMigrationGraphSpaceTreeInternal({
+      ...input,
+      ...(globalMaxTreePrefix !== undefined
+        ? { globalMaxEdgeTreePrefixWidth: globalMaxTreePrefix }
+        : {}),
+      ...(globalMaxDirName !== undefined ? { globalMaxDirNameWidth: globalMaxDirName } : {}),
+    }),
+  );
+}
+
+export function indentMigrationGraphTreeBlock(treeOutput: string, indent: string): string {
+  if (treeOutput.length === 0) {
+    return treeOutput;
+  }
+  return treeOutput
+    .split('\n')
+    .map((line) => (line.length === 0 ? line : `${indent}${line}`))
+    .join('\n');
+}