@prisma-next/cli 0.12.0-dev.22 → 0.12.0-dev.24

package/src/commands/migration-list.ts

@@ -26,10 +26,7 @@ import {
   setCommandSeeAlso,
 } from '../utils/command-helpers';
 import { buildReadAggregate } from '../utils/contract-space-aggregate-loader';
-import {
-  buildMigrationListTopologyBySpace,
-  renderMigrationListWithStyle,
-} from '../utils/formatters/migration-list-render';
+import { renderMigrationListWithStyle } from '../utils/formatters/migration-list-render';
 import { createAnsiMigrationListStyler } from '../utils/formatters/migration-list-styler';
 import type {
   MigrationListEntry,
@@ -143,8 +140,9 @@ export function renderMigrationListHumanOutput(
   options: MigrationListHumanRenderOptions,
 ): string {
   const styler = createAnsiMigrationListStyler({ useColor: options.useColor });
-  const topologyBySpaceId = buildMigrationListTopologyBySpace(result);
-  return renderMigrationListWithStyle(result, styler, options.glyphMode, topologyBySpaceId);
+  return renderMigrationListWithStyle(result, styler, options.glyphMode, {
+    colorize: options.useColor,
+  });
 }
 
 /**
@@ -222,7 +220,7 @@ export async function executeMigrationListCommand(
   if (!flags.json && !flags.quiet) {
     const header = formatStyledHeader({
       command: 'migration list',
-      description: 'List on-disk migrations, latest first, per contract space',
+      description: 'List on-disk migrations per contract space',
       details: [
         { label: 'config', value: configPath },
         { label: 'migrations', value: migrationsRelative },
@@ -253,15 +251,13 @@ export function createMigrationListCommand(): Command {
   const command = new Command('list');
   setCommandDescriptions(
     command,
-    'List on-disk migrations, latest first, per contract space',
+    'List on-disk migrations per contract space',
     'Enumerates every on-disk migration under migrations/<space>/ for every\n' +
-      'contract space found on disk, latest first. Offline — does not consult\n' +
-      'the database. Each row leads with a kind glyph (* forward, ↩ rollback,\n' +
-      '⟲ self), then dirName, then source → destination contract hashes\n' +
-      '(7-char git-style). Self-edges show a single hash. Invariants render as\n' +
-      '{...}; refs on the destination as (production, db). Pass --space <id>\n' +
-      'to narrow to one contract space. --ascii forces ASCII kind glyphs\n' +
-      '(orthogonal to --no-color).',
+      'contract space found on disk. Offline — does not consult the database.\n' +
+      'Human output draws the shared migration graph tree with operation counts,\n' +
+      'invariants on each migration row, and refs on destination contract nodes.\n' +
+      'Pass --space <id> to narrow to one contract space. --ascii forces ASCII\n' +
+      'tree glyphs (orthogonal to --no-color).',
   );
   setCommandExamples(command, [
     'prisma-next migration list',

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

@@ -27,8 +27,15 @@ const LABEL_GAP = 2;
  */
 const DB_MARKER_NAME = 'db';
 
+export interface MigrationEdgeAnnotation {
+  readonly status?: 'applied' | 'pending';
+  readonly operationCount?: number;
+  readonly invariants?: readonly string[];
+}
+
 export interface RenderMigrationGraphTreeOptions {
   readonly refsByHash?: ReadonlyMap<string, readonly string[]>;
+  readonly edgeAnnotationsByHash?: ReadonlyMap<string, MigrationEdgeAnnotation>;
   readonly dbHash?: string;
   readonly contractHash?: string;
   readonly activeRefName?: string;
@@ -571,6 +578,28 @@ function createTreeStyler(opts: RenderMigrationGraphTreeOptions): MigrationListS
   };
 }
 
+function formatEdgeAnnotationSuffix(
+  migrationHash: string,
+  opts: RenderMigrationGraphTreeOptions,
+  style: MigrationListStyler,
+): string {
+  const annotation = opts.edgeAnnotationsByHash?.get(migrationHash);
+  if (annotation === undefined) {
+    return '';
+  }
+  const segments: string[] = [];
+  if (annotation.operationCount !== undefined) {
+    segments.push(`${annotation.operationCount} ops`);
+  }
+  if (annotation.invariants !== undefined && annotation.invariants.length > 0) {
+    segments.push(style.invariants(annotation.invariants));
+  }
+  if (segments.length === 0) {
+    return '';
+  }
+  return `  ${segments.join('  ')}`;
+}
+
 function formatEdgeHashColumn(
   edge: ClassifiedEdge,
   style: MigrationListStyler,
@@ -784,7 +813,8 @@ export function renderMigrationGraphTree(
         : style.dirName;
     const dirName = `${dirNameStyler(edge.dirName)}${dirNamePadding}`;
     const hashColumn = formatEdgeHashColumn(edge, style, hashLength, palette);
-    lines.push(trimTrailingWhitespace(`${gutterPad}${dirName}${hashColumn}`));
+    const annotationSuffix = formatEdgeAnnotationSuffix(edge.migrationHash, opts, style);
+    lines.push(trimTrailingWhitespace(`${gutterPad}${dirName}${hashColumn}${annotationSuffix}`));
   }
 
   return lines.join('\n');

package/src/utils/formatters/migration-list-data-column.ts

@@ -1,32 +1,10 @@
 import type { GlyphMode } from '../glyph-mode';
-import type { MigrationEdgeKind } from './migration-list-graph-topology';
-import type { MigrationListStyler } from './migration-list-render';
-import type { MigrationListEntry } from './migration-list-types';
 
 export const MIGRATION_LIST_HASH_WIDTH = 7;
 export const MIGRATION_LIST_EMPTY_SOURCE = '∅';
 export const MIGRATION_LIST_ASCII_EMPTY_SOURCE = '-';
 export const MIGRATION_LIST_FORWARD_EDGE_GLYPH = '→';
 export const MIGRATION_LIST_ASCII_FORWARD_EDGE_GLYPH = '->';
-export const MIGRATION_LIST_DECORATION_PREFIX = '  ';
-
-export const MIGRATION_LIST_UNICODE_KIND_GLYPH: Record<MigrationEdgeKind, string> = {
-  forward: '*',
-  rollback: '↩',
-  self: '⟲',
-};
-
-export const MIGRATION_LIST_ASCII_KIND_GLYPH: Record<MigrationEdgeKind, string> = {
-  forward: '*',
-  rollback: '<',
-  self: '~',
-};
-
-export function migrationListKindGlyph(glyphMode: GlyphMode, edgeKind: MigrationEdgeKind): string {
-  return glyphMode === 'ascii'
-    ? MIGRATION_LIST_ASCII_KIND_GLYPH[edgeKind]
-    : MIGRATION_LIST_UNICODE_KIND_GLYPH[edgeKind];
-}
 
 export function migrationListForwardArrow(glyphMode: GlyphMode): string {
   return glyphMode === 'ascii'
@@ -42,74 +20,3 @@ export function abbreviateContractHash(hash: string): string {
   const stripped = hash.startsWith('sha256:') ? hash.slice(7) : hash;
   return stripped.slice(0, MIGRATION_LIST_HASH_WIDTH);
 }
-
-export function computeMigrationDirNameWidth(migrations: readonly MigrationListEntry[]): number {
-  if (migrations.length === 0) return 0;
-  return Math.max(...migrations.map((entry) => entry.dirName.length)) + 2;
-}
-
-function formatSourceColumn(
-  from: string | null,
-  style: MigrationListStyler,
-  emptySource: string,
-): string {
-  if (from === null) {
-    return style.glyph(emptySource) + ' '.repeat(MIGRATION_LIST_HASH_WIDTH - emptySource.length);
-  }
-  return style.sourceHash(abbreviateContractHash(from));
-}
-
-export function formatDecorations(
-  providedInvariants: readonly string[],
-  refs: readonly string[],
-  style: MigrationListStyler,
-): string {
-  const blocks: string[] = [];
-  if (providedInvariants.length > 0) {
-    blocks.push(style.invariants(providedInvariants));
-  }
-  if (refs.length > 0) {
-    blocks.push(style.refs(refs));
-  }
-  if (blocks.length === 0) return '';
-  return `${MIGRATION_LIST_DECORATION_PREFIX}${blocks.join(' ')}`;
-}
-
-export interface MigrationDataColumnOptions {
-  readonly dirNameWidth: number;
-  readonly edgeKind: MigrationEdgeKind;
-  readonly style: MigrationListStyler;
-  readonly forwardArrow?: string;
-  readonly emptySource?: string;
-}
-
-export function formatMigrationDataColumn(
-  migration: MigrationListEntry,
-  options: MigrationDataColumnOptions,
-): string {
-  const {
-    dirNameWidth,
-    edgeKind,
-    style,
-    forwardArrow = MIGRATION_LIST_FORWARD_EDGE_GLYPH,
-    emptySource = MIGRATION_LIST_EMPTY_SOURCE,
-  } = options;
-  const dirNamePadding = ' '.repeat(Math.max(0, dirNameWidth - migration.dirName.length));
-  const dirName = `${style.dirName(migration.dirName)}${dirNamePadding}`;
-  const decorations = formatDecorations(migration.providedInvariants, migration.refs, style);
-
-  if (edgeKind === 'self') {
-    const contractHash = migration.from ?? migration.to;
-    const hash = style.sourceHash(abbreviateContractHash(contractHash));
-    return `${dirName}${hash}${decorations}`;
-  }
-
-  const source = formatSourceColumn(migration.from, style, emptySource);
-  const arrow = style.glyph(forwardArrow);
-  const dest = style.destHash(abbreviateContractHash(migration.to));
-  return `${dirName}${source} ${arrow} ${dest}${decorations}`;
-}
-
-export function formatNodeLineDataColumn(contractHash: string, style: MigrationListStyler): string {
-  return style.sourceHash(abbreviateContractHash(contractHash));
-}

package/src/utils/formatters/migration-list-graph-topology.ts

@@ -11,8 +11,7 @@ export interface MigrationListGraphTopology {
 }
 
 // ---------------------------------------------------------------------------
-// Shared classifier — operates on a normalized edge shape common to both
-// MigrationListEntry (Tier-2) and MigrationEdge / MigrationGraph (Tier-3).
+// Shared classifier — operates on a normalized edge shape for MigrationGraph.
 // ---------------------------------------------------------------------------
 
 interface NormalizedEdge {
@@ -315,9 +314,6 @@ function canonicalFrom(from: string | null): string {
 
 /**
  * Classify forward/rollback/self for a Tier-2 `MigrationListEntry[]` edge set.
- * Returns the kind of each migration plus the forward in/out degree of each
- * contract node. This is the established Tier-2 surface; its behaviour is
- * unchanged — only its implementation now delegates to the shared classifier.
  */
 export function classifyMigrationListGraphTopology(
   entries: readonly MigrationListEntry[],
@@ -333,8 +329,6 @@ export function classifyMigrationListGraphTopology(
 
 /**
  * Classify forward/rollback/self for a `MigrationGraph` edge set (Tier-3).
- * Delegates to the same shared classifier as `classifyMigrationListGraphTopology`
- * so both tiers agree on forward/rollback/self without duplicating logic.
  */
 export function classifyMigrationGraphTopology(graph: MigrationGraph): MigrationListGraphTopology {
   const normalized: NormalizedEdge[] = [];

package/src/utils/formatters/migration-list-render.ts

@@ -1,16 +1,12 @@
+import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
+import type { MigrationEdge, 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 {
-  computeMigrationDirNameWidth,
-  formatMigrationDataColumn,
-  migrationListEmptySource,
-  migrationListForwardArrow,
-  migrationListKindGlyph,
-} from './migration-list-data-column';
-import {
-  classifyMigrationListGraphTopology,
-  type MigrationEdgeKind,
-  type MigrationListGraphTopology,
-} from './migration-list-graph-topology';
+  type MigrationEdgeAnnotation,
+  renderMigrationGraphTree,
+} from './migration-graph-tree-render';
 import type { MigrationListEntry, MigrationListResult } from './migration-list-types';
 
 export type { GlyphMode } from '../glyph-mode';
@@ -62,42 +58,88 @@ export const IDENTITY_MIGRATION_LIST_STYLER: MigrationListStyler = {
   emptyState: (text) => text,
 };
 
-function resolveEdgeKind(
-  migrationHash: string,
-  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
-): MigrationEdgeKind {
-  return kindByMigrationHash.get(migrationHash) ?? 'forward';
+function canonicalFrom(from: string | null): string {
+  return from ?? EMPTY_CONTRACT_HASH;
 }
 
-function formatMigrationRow(
-  migration: MigrationListEntry,
-  dirNameWidth: number,
-  edgeKind: MigrationEdgeKind,
-  glyphMode: GlyphMode,
-  style: MigrationListStyler,
-): string {
-  const kindColumn = `${style.kind(migrationListKindGlyph(glyphMode, edgeKind))} `;
-  const data = formatMigrationDataColumn(migration, {
-    dirNameWidth,
-    edgeKind,
-    style,
-    forwardArrow: migrationListForwardArrow(glyphMode),
-    emptySource: migrationListEmptySource(glyphMode),
-  });
-  return `${kindColumn}${data}`;
+export function migrationGraphFromListEntries(
+  entries: readonly MigrationListEntry[],
+): MigrationGraph {
+  const nodes = new Set<string>();
+  const forwardChain = new Map<string, MigrationEdge[]>();
+  const reverseChain = new Map<string, MigrationEdge[]>();
+  const migrationByHash = new Map<string, MigrationEdge>();
+
+  for (const entry of entries) {
+    const from = canonicalFrom(entry.from);
+    const edge: MigrationEdge = {
+      from,
+      to: entry.to,
+      migrationHash: entry.migrationHash,
+      dirName: entry.dirName,
+      createdAt: entry.createdAt,
+      invariants: entry.providedInvariants,
+    };
+    nodes.add(from);
+    nodes.add(entry.to);
+    const forward = forwardChain.get(from);
+    if (forward) forward.push(edge);
+    else forwardChain.set(from, [edge]);
+    const reverse = reverseChain.get(entry.to);
+    if (reverse) reverse.push(edge);
+    else reverseChain.set(entry.to, [edge]);
+    migrationByHash.set(entry.migrationHash, edge);
+  }
+
+  return { nodes, forwardChain, reverseChain, migrationByHash };
+}
+
+export function buildEdgeAnnotationsByHashFromListEntries(
+  entries: readonly MigrationListEntry[],
+): ReadonlyMap<string, MigrationEdgeAnnotation> {
+  const annotations = new Map<string, MigrationEdgeAnnotation>();
+  for (const entry of entries) {
+    annotations.set(entry.migrationHash, {
+      operationCount: entry.operationCount,
+      invariants: entry.providedInvariants,
+    });
+  }
+  return annotations;
+}
+
+export function buildRefsByHashFromListEntries(
+  entries: readonly MigrationListEntry[],
+): ReadonlyMap<string, readonly string[]> {
+  const refsByHash = new Map<string, readonly string[]>();
+  for (const entry of entries) {
+    if (entry.refs.length > 0) {
+      refsByHash.set(entry.to, entry.refs);
+    }
+  }
+  return refsByHash;
 }
 
 function formatEmptyStateLine(spaceId: string, style: MigrationListStyler): string {
   return style.emptyState(`There are no migrations in migrations/${spaceId}/ yet`);
 }
 
-function renderSpaceBlock(
+function indentTreeBlock(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');
+}
+
+function renderSpaceTreeBlock(
   spaceId: string,
   migrations: readonly MigrationListEntry[],
   multiSpace: boolean,
   glyphMode: GlyphMode,
-  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
   style: MigrationListStyler,
+  colorize: boolean,
 ): readonly string[] {
   if (migrations.length === 0) {
     const emptyLine = formatEmptyStateLine(spaceId, style);
@@ -107,50 +149,44 @@ function renderSpaceBlock(
     return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
   }
 
-  const dirNameWidth = computeMigrationDirNameWidth(migrations);
-  const rows = migrations.map((entry) =>
-    formatMigrationRow(
-      entry,
-      dirNameWidth,
-      resolveEdgeKind(entry.migrationHash, kindByMigrationHash),
-      glyphMode,
-      style,
-    ),
-  );
+  const graph = migrationGraphFromListEntries(migrations);
+  const rowModel = buildMigrationGraphRows(graph);
+  const layout = buildMigrationGraphLayout(rowModel);
+  const treeOutput = renderMigrationGraphTree(layout, {
+    refsByHash: buildRefsByHashFromListEntries(migrations),
+    edgeAnnotationsByHash: buildEdgeAnnotationsByHashFromListEntries(migrations),
+    colorize,
+    glyphMode,
+  });
+
   if (!multiSpace) {
-    return rows;
+    return treeOutput.length === 0 ? [] : [treeOutput];
   }
-  return [style.spaceHeading(`${spaceId}:`), ...rows.map((row) => `  ${row}`)];
+
+  const indented = indentTreeBlock(treeOutput, '  ');
+  return [style.spaceHeading(`${spaceId}:`), indented];
 }
 
-export function buildMigrationListTopologyBySpace(
-  result: MigrationListResult,
-): ReadonlyMap<string, MigrationListGraphTopology> {
-  const topologyBySpaceId = new Map<string, MigrationListGraphTopology>();
-  for (const space of result.spaces) {
-    topologyBySpaceId.set(space.spaceId, classifyMigrationListGraphTopology(space.migrations));
-  }
-  return topologyBySpaceId;
+export interface RenderMigrationListWithStyleOptions {
+  readonly colorize?: boolean;
 }
 
 /**
- * Compose the styled `migration list` output. The renderer is
- * presentation-neutral — every token passes through `style` before
- * landing in the output, so the same composition serves the pure-text
- * path ({@link renderMigrationList} via
- * {@link IDENTITY_MIGRATION_LIST_STYLER}) and the ANSI-styled CLI path
- * (via the ANSI styler the CLI shell wires up).
+ * Compose the styled `migration list` human output via the shared tree
+ * renderer. Each on-disk migration is one edge row with package-fact
+ * annotations; refs decorate destination contract nodes.
+ *
+ * `options.colorize` must match whether `style` emits ANSI (e.g. both true for
+ * `createAnsiMigrationListStyler({ useColor: true })`).
  */
 export function renderMigrationListWithStyle(
   result: MigrationListResult,
   style: MigrationListStyler,
   glyphMode: GlyphMode = 'unicode',
-  topologyBySpaceId: ReadonlyMap<
-    string,
-    MigrationListGraphTopology
-  > = buildMigrationListTopologyBySpace(result),
+  options: RenderMigrationListWithStyleOptions = {},
 ): string {
   const multiSpace = result.spaces.length > 1;
+  const colorize = options.colorize ?? false;
   const lines: string[] = [];
 
   for (let index = 0; index < result.spaces.length; index++) {
@@ -158,18 +194,14 @@ export function renderMigrationListWithStyle(
     if (index > 0) {
       lines.push('');
     }
-    const topology = topologyBySpaceId.get(space.spaceId);
-    const kindByMigrationHash =
-      topology?.kindByMigrationHash ??
-      classifyMigrationListGraphTopology(space.migrations).kindByMigrationHash;
     lines.push(
-      ...renderSpaceBlock(
+      ...renderSpaceTreeBlock(
         space.spaceId,
         space.migrations,
         multiSpace,
         glyphMode,
-        kindByMigrationHash,
         style,
+        colorize,
       ),
     );
   }