@prisma-next/cli 0.11.0-dev.43 → 0.11.0-dev.45

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

@@ -0,0 +1,319 @@
+import type {
+  ConnectorLayoutRow,
+  LayoutRow,
+  MigrationLayoutRow,
+  MigrationListGraphLayout,
+  NodeLineLayoutRow,
+} from '@prisma-next/migration-tools/migration-list-graph-layout';
+import { computeMigrationListGraphLayout } from '@prisma-next/migration-tools/migration-list-graph-layout';
+import type { EdgeKind } from '@prisma-next/migration-tools/migration-list-graph-topology';
+import type {
+  MigrationListEntry,
+  MigrationListResult,
+} from '@prisma-next/migration-tools/migration-list-types';
+import {
+  abbreviateContractHash,
+  computeMigrationDirNameWidth,
+  formatMigrationDataColumn,
+  formatNodeLineDataColumn,
+  MIGRATION_LIST_EMPTY_SOURCE,
+  MIGRATION_LIST_FORWARD_EDGE_GLYPH,
+} from './migration-list-data-column';
+import type { MigrationListStyler } from './migration-list-render';
+
+export type GlyphMode = 'unicode' | 'ascii';
+
+export interface GlyphModeInput {
+  readonly isTTY: boolean;
+  readonly env: Readonly<Record<string, string | undefined>>;
+}
+
+interface GlyphPalette {
+  readonly lane: string;
+  readonly node: string;
+  readonly forwardArrow: string;
+  readonly emptySource: string;
+  readonly kind: Record<EdgeKind, string>;
+  readonly fanBelow: (branchCount: number) => string;
+  readonly joinBelow: (branchCount: number) => string;
+}
+
+const UNICODE_PALETTE: GlyphPalette = {
+  lane: '│',
+  node: 'o',
+  forwardArrow: MIGRATION_LIST_FORWARD_EDGE_GLYPH,
+  emptySource: MIGRATION_LIST_EMPTY_SOURCE,
+  kind: { forward: '*', rollback: '↩', self: '⟲' },
+  fanBelow: (branchCount) => (branchCount === 2 ? '├─┐' : '├─┬─┐'),
+  joinBelow: (branchCount) => (branchCount === 2 ? '├─┘' : '└─┴─┘'),
+};
+
+const ASCII_PALETTE: GlyphPalette = {
+  lane: '|',
+  node: 'o',
+  forwardArrow: '->',
+  emptySource: '-',
+  kind: { forward: '*', rollback: '<', self: '~' },
+  fanBelow: (branchCount) => (branchCount === 2 ? '+-\\' : '+-|-\\'),
+  joinBelow: (branchCount) => (branchCount === 2 ? '+-/' : '/-+-/'),
+};
+
+function paletteFor(mode: GlyphMode): GlyphPalette {
+  return mode === 'ascii' ? ASCII_PALETTE : UNICODE_PALETTE;
+}
+
+function localeString(env: Readonly<Record<string, string | undefined>>): string {
+  return env['LC_ALL'] ?? env['LC_CTYPE'] ?? env['LANG'] ?? '';
+}
+
+function isUtf8Locale(env: Readonly<Record<string, string | undefined>>): boolean {
+  const locale = localeString(env);
+  if (locale.length === 0) return false;
+  return /UTF-8|utf8/i.test(locale);
+}
+
+export function detectGlyphMode(input: GlyphModeInput): GlyphMode {
+  if (!input.isTTY) return 'ascii';
+  if (!isUtf8Locale(input.env)) return 'ascii';
+  return 'unicode';
+}
+
+function migrationEntries(layout: MigrationListGraphLayout) {
+  const entries = [];
+  for (const row of layout.rows) {
+    if (row.kind === 'migration') entries.push(row.entry);
+  }
+  return entries;
+}
+
+function layoutMaxLaneIndex(layout: MigrationListGraphLayout): number {
+  let max = 0;
+  for (const row of layout.rows) {
+    if (row.kind === 'migration') {
+      max = Math.max(max, row.laneIndex, ...row.passThroughLanes);
+    } else if (row.kind === 'connector') {
+      max = Math.max(max, row.endLane);
+    } else {
+      max = Math.max(max, row.laneIndex);
+    }
+  }
+  return max;
+}
+
+function laneCell(glyph: string): string {
+  return `${glyph} `;
+}
+
+function emptyLaneCell(): string {
+  return '  ';
+}
+
+function renderMigrationGutter(
+  row: MigrationLayoutRow,
+  maxLane: number,
+  palette: GlyphPalette,
+  style: MigrationListStyler,
+): string {
+  const cells: string[] = [];
+  for (let lane = 0; lane <= maxLane; lane++) {
+    if (lane === row.laneIndex) {
+      cells.push(laneCell(palette.kind[row.edgeKind]));
+    } else if (row.passThroughLanes.includes(lane)) {
+      cells.push(laneCell(style.lane(palette.lane)));
+    } else {
+      cells.push(emptyLaneCell());
+    }
+  }
+  return cells.join('');
+}
+
+function renderNodeLineGutter(
+  row: NodeLineLayoutRow,
+  openLanes: ReadonlySet<number>,
+  maxLane: number,
+  palette: GlyphPalette,
+  style: MigrationListStyler,
+): string {
+  const cells: string[] = [];
+  for (let lane = 0; lane <= maxLane; lane++) {
+    if (lane === row.laneIndex) {
+      cells.push(laneCell(palette.node));
+    } else if (openLanes.has(lane)) {
+      cells.push(laneCell(style.lane(palette.lane)));
+    } else {
+      cells.push(emptyLaneCell());
+    }
+  }
+  return cells.join('');
+}
+
+function renderConnectorGutter(
+  row: ConnectorLayoutRow,
+  openLanes: ReadonlySet<number>,
+  maxLane: number,
+  palette: GlyphPalette,
+  style: MigrationListStyler,
+): string {
+  const spanLaneCount = row.endLane - row.startLane + 1;
+  const spanWidth = spanLaneCount * 2;
+  let spanGlyph = (
+    row.connectorKind === 'fanBelow'
+      ? palette.fanBelow(row.branchCount)
+      : palette.joinBelow(row.branchCount)
+  )
+    .padEnd(spanWidth, ' ')
+    .slice(0, spanWidth);
+
+  const hasOutsideOpen = [...openLanes].some((lane) => lane < row.startLane || lane > row.endLane);
+  if (!hasOutsideOpen && spanGlyph.endsWith(' ')) {
+    spanGlyph = spanGlyph.slice(0, -1);
+  }
+
+  let gutter = '';
+  for (let lane = 0; lane < row.startLane; lane++) {
+    gutter += openLanes.has(lane) ? laneCell(style.lane(palette.lane)) : emptyLaneCell();
+  }
+  gutter += style.lane(spanGlyph);
+  for (let lane = row.endLane + 1; lane <= maxLane; lane++) {
+    gutter += openLanes.has(lane) ? laneCell(style.lane(palette.lane)) : emptyLaneCell();
+  }
+  return gutter;
+}
+
+function advanceOpenLanes(row: LayoutRow, openLanes: ReadonlySet<number>): ReadonlySet<number> {
+  if (row.kind === 'migration') {
+    return new Set([row.laneIndex, ...row.passThroughLanes]);
+  }
+  if (row.kind === 'connector') {
+    if (row.connectorKind === 'fanBelow') {
+      const next = new Set(openLanes);
+      for (let lane = row.startLane; lane <= row.endLane; lane++) {
+        next.add(lane);
+      }
+      return next;
+    }
+    const next = new Set(openLanes);
+    for (let lane = row.startLane + 1; lane <= row.endLane; lane++) {
+      next.delete(lane);
+    }
+    return next;
+  }
+  return openLanes;
+}
+
+export function renderMigrationListGraphWithStyle(
+  layout: MigrationListGraphLayout,
+  style: MigrationListStyler,
+  glyphMode: GlyphMode,
+): string {
+  const palette = paletteFor(glyphMode);
+  const migrations = migrationEntries(layout);
+  const layoutMaxLane = layoutMaxLaneIndex(layout);
+  const dirNameWidth = computeMigrationDirNameWidth(migrations);
+  const gutterMaxLane = layoutMaxLane;
+  const blockDataStart = (layoutMaxLane + 1) * 2;
+  // Migration and node-line gutters always occupy a fixed, ANSI-free visible
+  // width of two columns per lane. Padding is computed from this width rather
+  // than the rendered string length so dimmed lanes (which carry zero-width
+  // SGR bytes) stay column-aligned with the data that follows.
+  const gutterVisibleWidth = (gutterMaxLane + 1) * 2;
+  const lines: string[] = [];
+  let openLanes: ReadonlySet<number> = new Set();
+
+  function padToDataColumn(gutter: string, dataStart: number): string {
+    return gutter + ' '.repeat(Math.max(0, dataStart - gutterVisibleWidth));
+  }
+
+  for (const row of layout.rows) {
+    if (row.kind === 'migration') {
+      const gutter = renderMigrationGutter(row, gutterMaxLane, palette, style);
+      const data = formatMigrationDataColumn(row.entry, {
+        dirNameWidth,
+        edgeKind: row.edgeKind,
+        style,
+        forwardArrow: palette.forwardArrow,
+        emptySource: palette.emptySource,
+      });
+      lines.push(`${padToDataColumn(gutter, blockDataStart)}${data}`);
+    } else if (row.kind === 'nodeLine') {
+      const gutter = renderNodeLineGutter(row, openLanes, gutterMaxLane, palette, style);
+      const data = formatNodeLineDataColumn(row.contractHash, style);
+      lines.push(`${padToDataColumn(gutter, blockDataStart)}${data}`);
+    } else {
+      lines.push(renderConnectorGutter(row, openLanes, gutterMaxLane, palette, style));
+    }
+    openLanes = advanceOpenLanes(row, openLanes);
+  }
+
+  return lines.join('\n');
+}
+
+export function renderMigrationListGraph(
+  layout: MigrationListGraphLayout,
+  style: MigrationListStyler,
+  glyphMode: GlyphMode,
+): string {
+  return renderMigrationListGraphWithStyle(layout, style, glyphMode);
+}
+
+export function formatGraphNodeLineHash(contractHash: string, style: MigrationListStyler): string {
+  return style.sourceHash(abbreviateContractHash(contractHash));
+}
+
+function formatGraphEmptyStateLine(spaceId: string, style: MigrationListStyler): string {
+  return style.emptyState(`There are no migrations in migrations/${spaceId}/ yet`);
+}
+
+function renderGraphSpaceBlock(
+  spaceId: string,
+  migrations: readonly MigrationListEntry[],
+  multiSpace: boolean,
+  style: MigrationListStyler,
+  glyphMode: GlyphMode,
+): readonly string[] {
+  if (migrations.length === 0) {
+    const emptyLine = formatGraphEmptyStateLine(spaceId, style);
+    if (!multiSpace) {
+      return [emptyLine];
+    }
+    return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
+  }
+
+  const layout = computeMigrationListGraphLayout(migrations);
+  const graphBody = renderMigrationListGraphWithStyle(layout, style, glyphMode);
+  const rows = graphBody.split('\n');
+  if (!multiSpace) {
+    return rows;
+  }
+  return [style.spaceHeading(`${spaceId}:`), ...rows.map((row) => `  ${row}`)];
+}
+
+export function renderMigrationListGraphResult(
+  result: MigrationListResult,
+  style: MigrationListStyler,
+  glyphMode: GlyphMode,
+): string {
+  const multiSpace = result.spaces.length > 1;
+  const lines: string[] = [];
+
+  for (let index = 0; index < result.spaces.length; index++) {
+    const space = result.spaces[index]!;
+    if (index > 0) {
+      lines.push('');
+    }
+    lines.push(
+      ...renderGraphSpaceBlock(space.spaceId, space.migrations, multiSpace, style, glyphMode),
+    );
+  }
+
+  const totalMigrations = result.spaces.reduce(
+    (count, space) => count + space.migrations.length,
+    0,
+  );
+  if (totalMigrations > 0) {
+    lines.push('');
+    lines.push(style.summary(result.summary));
+  }
+
+  return lines.join('\n');
+}

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

@@ -1,7 +1,18 @@
+import {
+  classifyMigrationListGraphTopology,
+  type EdgeKind,
+} from '@prisma-next/migration-tools/migration-list-graph-topology';
 import type {
   MigrationListEntry,
   MigrationListResult,
 } from '@prisma-next/migration-tools/migration-list-types';
+import {
+  computeMigrationDirNameWidth,
+  formatMigrationDataColumn,
+  MIGRATION_LIST_FORWARD_EDGE_GLYPH,
+} from './migration-list-data-column';
+
+export type { EdgeKind } from '@prisma-next/migration-tools/migration-list-graph-topology';
 
 export type {
   MigrationListEntry,
@@ -9,11 +20,11 @@ export type {
   MigrationSpaceListEntry,
 } from '@prisma-next/migration-tools/migration-list-types';
 
-const HASH_WIDTH = 7;
-const EMPTY_SOURCE = '∅';
-const SELF_EDGE_GLYPH = '⟲';
-const FORWARD_EDGE_GLYPH = '→';
-const DECORATION_PREFIX = '  ';
+const KIND_GLYPH: Record<EdgeKind, string> = {
+  forward: '*',
+  rollback: '↩',
+  self: '⟲',
+};
 
 /**
  * Semantic styler for `migration list` output tokens. Token-typed so
@@ -29,10 +40,12 @@ const DECORATION_PREFIX = '  ';
  * having to re-parse a joined block.
  */
 export interface MigrationListStyler {
+  kind(text: string): string;
   dirName(text: string): string;
   sourceHash(text: string): string;
   destHash(text: string): string;
   glyph(text: string): string;
+  lane(text: string): string;
   invariants(ids: readonly string[]): string;
   refs(names: readonly string[]): string;
   spaceHeading(text: string): string;
@@ -41,10 +54,12 @@ export interface MigrationListStyler {
 }
 
 export const IDENTITY_MIGRATION_LIST_STYLER: MigrationListStyler = {
+  kind: (text) => text,
   dirName: (text) => text,
   sourceHash: (text) => text,
   destHash: (text) => text,
   glyph: (text) => text,
+  lane: (text) => text,
   invariants: (ids) => `{${ids.join(', ')}}`,
   refs: (names) => `(${names.join(', ')})`,
   spaceHeading: (text) => text,
@@ -52,57 +67,27 @@ export const IDENTITY_MIGRATION_LIST_STYLER: MigrationListStyler = {
   emptyState: (text) => text,
 };
 
-function abbreviateContractHash(hash: string): string {
-  const stripped = hash.startsWith('sha256:') ? hash.slice(7) : hash;
-  return stripped.slice(0, HASH_WIDTH);
-}
-
-function formatSourceColumn(from: string | null, style: MigrationListStyler): string {
-  if (from === null) {
-    return style.glyph(EMPTY_SOURCE) + ' '.repeat(HASH_WIDTH - EMPTY_SOURCE.length);
-  }
-  return style.sourceHash(abbreviateContractHash(from));
-}
-
-function formatDestColumn(from: string | null, to: string, style: MigrationListStyler): string {
-  if (from !== null && from === to) {
-    return ' '.repeat(HASH_WIDTH);
-  }
-  return style.destHash(abbreviateContractHash(to));
-}
-
-function formatArrowGlyph(from: string | null, to: string, style: MigrationListStyler): string {
-  return style.glyph(from !== null && from === to ? SELF_EDGE_GLYPH : FORWARD_EDGE_GLYPH);
-}
-
-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 `${DECORATION_PREFIX}${blocks.join(' ')}`;
+function resolveEdgeKind(
+  migrationHash: string,
+  kindByMigrationHash: ReadonlyMap<string, EdgeKind>,
+): EdgeKind {
+  return kindByMigrationHash.get(migrationHash) ?? 'forward';
 }
 
 function formatMigrationRow(
   migration: MigrationListEntry,
   dirNameWidth: number,
+  edgeKind: EdgeKind,
   style: MigrationListStyler,
 ): string {
-  const dirNamePadding = ' '.repeat(Math.max(0, dirNameWidth - migration.dirName.length));
-  const dirName = `${style.dirName(migration.dirName)}${dirNamePadding}`;
-  const source = formatSourceColumn(migration.from, style);
-  const arrow = formatArrowGlyph(migration.from, migration.to, style);
-  const dest = formatDestColumn(migration.from, migration.to, style);
-  const decorations = formatDecorations(migration.providedInvariants, migration.refs, style);
-  return `${dirName}${source} ${arrow} ${dest}${decorations}`;
+  const kindColumn = `${style.kind(KIND_GLYPH[edgeKind])} `;
+  const data = formatMigrationDataColumn(migration, {
+    dirNameWidth,
+    edgeKind,
+    style,
+    forwardArrow: MIGRATION_LIST_FORWARD_EDGE_GLYPH,
+  });
+  return `${kindColumn}${data}`;
 }
 
 function formatEmptyStateLine(spaceId: string, style: MigrationListStyler): string {
@@ -123,8 +108,16 @@ function renderSpaceBlock(
     return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
   }
 
-  const dirNameWidth = Math.max(...migrations.map((entry) => entry.dirName.length)) + 2;
-  const rows = migrations.map((entry) => formatMigrationRow(entry, dirNameWidth, style));
+  const kindByMigrationHash = classifyMigrationListGraphTopology(migrations).kindByMigrationHash;
+  const dirNameWidth = computeMigrationDirNameWidth(migrations);
+  const rows = migrations.map((entry) =>
+    formatMigrationRow(
+      entry,
+      dirNameWidth,
+      resolveEdgeKind(entry.migrationHash, kindByMigrationHash),
+      style,
+    ),
+  );
   if (!multiSpace) {
     return rows;
   }

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

@@ -25,6 +25,7 @@ function styleRefName(name: string): string {
  * - `sourceHash`: dim cyan
  * - `destHash`: bright cyan
  * - `glyph` (`→` / `⟲` / `∅`): dim
+ * - `lane` (graph gutter lines `│` and fan/join connectors `├─┐` / `├─┘`): dim
  * - `invariants` (`{...}`): yellow
  * - `refs` (`(...)`): green; the live-DB `db` marker inside is green-bold
  * - `spaceHeading` (`<spaceId>:`): bold
@@ -38,10 +39,12 @@ export function createAnsiMigrationListStyler(opts: {
     return IDENTITY_MIGRATION_LIST_STYLER;
   }
   return {
+    kind: (text) => dim(text),
     dirName: (text) => bold(text),
     sourceHash: (text) => dim(cyan(text)),
     destHash: (text) => cyanBright(text),
     glyph: (text) => dim(text),
+    lane: (text) => dim(text),
     invariants: (ids) => yellow(`{${ids.join(', ')}}`),
     refs: (names) => {
       const open = green('(');

package/src/utils/terminal-ui.ts

@@ -1,8 +1,15 @@
 import * as clack from '@clack/prompts';
 import { bold, cyan, dim, green, red, yellow } from 'colorette';
+import {
+  detectGlyphMode,
+  type GlyphMode,
+  type GlyphModeInput,
+} from './formatters/migration-list-graph-render';
 import type { GlobalFlags } from './global-flags';
 import { shutdownSignal } from './shutdown';
 
+export interface TerminalUIRuntime extends GlyphModeInput {}
+
 /**
  * Composable CLI output abstraction.
  *
@@ -36,17 +43,50 @@ export class TerminalUI {
    */
   readonly forcePretty: boolean;
 
+  /**
+   * Whether stdout is a TTY — used for migration-list graph glyph detection.
+   */
+  readonly stdoutIsTTY: boolean;
+
+  /**
+   * Process environment snapshot for locale-aware glyph detection.
+   */
+  readonly env: Readonly<Record<string, string | undefined>>;
+
   private static readonly stderrOpts = { output: process.stderr } as const;
 
   constructor(options?: {
     readonly color?: boolean | undefined;
     readonly interactive?: boolean | undefined;
     readonly forcePretty?: boolean | undefined;
+    readonly stdoutIsTTY?: boolean | undefined;
+    readonly env?: Readonly<Record<string, string | undefined>> | undefined;
   }) {
     // --interactive/--no-interactive override TTY detection
     this.isInteractive = options?.interactive ?? !!process.stdout.isTTY;
     this.forcePretty = options?.forcePretty ?? false;
     this.useColor = options?.color ?? (this.isInteractive || this.forcePretty);
+    this.stdoutIsTTY = options?.stdoutIsTTY ?? !!process.stdout.isTTY;
+    this.env = options?.env ?? process.env;
+  }
+
+  get isTTY(): boolean {
+    return this.stdoutIsTTY;
+  }
+
+  /**
+   * Resolve graph glyph mode for `migration list --graph`. `--ascii` forces
+   * ASCII; otherwise delegates to the pure {@link detectGlyphMode} helper.
+   */
+  resolveGlyphMode(forceAscii: boolean): GlyphMode {
+    if (forceAscii) {
+      return 'ascii';
+    }
+    return detectGlyphMode(this.glyphModeInput());
+  }
+
+  glyphModeInput(): GlyphModeInput {
+    return { isTTY: this.stdoutIsTTY, env: this.env };
   }
 
   private get shouldDecorate(): boolean {
@@ -288,10 +328,15 @@ export class TerminalUI {
   }
 }
 
-export function createTerminalUI(flags: GlobalFlags): TerminalUI {
+export function createTerminalUI(
+  flags: GlobalFlags,
+  runtime?: Partial<TerminalUIRuntime>,
+): TerminalUI {
   return new TerminalUI({
     color: flags.color,
     interactive: flags.interactive,
     forcePretty: flags.format === 'pretty' && flags.explicitFormat,
+    stdoutIsTTY: runtime?.isTTY,
+    env: runtime?.env,
   });
 }