@prisma-next/cli 0.11.0-dev.70 → 0.11.0-dev.72

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

@@ -1,268 +0,0 @@
-import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
-import {
-  classifyMigrationListGraphTopology,
-  type MigrationEdgeKind,
-  type MigrationListGraphTopology,
-} from './migration-list-graph-topology';
-import type { MigrationListEntry } from './migration-list-types';
-
-export type ConnectorKind = 'fanBelow' | 'joinAbove';
-
-export interface MigrationLayoutRow {
-  readonly kind: 'migration';
-  readonly entry: MigrationListEntry;
-  readonly edgeKind: MigrationEdgeKind;
-  readonly laneIndex: number;
-  readonly passThroughLanes: readonly number[];
-  readonly woven: boolean;
-}
-
-export interface NodeLineLayoutRow {
-  readonly kind: 'nodeLine';
-  readonly contractHash: string;
-  readonly laneIndex: number;
-}
-
-export interface ConnectorLayoutRow {
-  readonly kind: 'connector';
-  readonly connectorKind: ConnectorKind;
-  readonly contractHash: string;
-  readonly startLane: number;
-  readonly endLane: number;
-  readonly branchCount: number;
-}
-
-export type LayoutRow = MigrationLayoutRow | NodeLineLayoutRow | ConnectorLayoutRow;
-
-export interface MigrationListGraphLayout {
-  readonly rows: readonly LayoutRow[];
-}
-
-interface LaneState {
-  want: string;
-  active: boolean;
-}
-
-function canonicalFrom(from: string | null): string {
-  return from ?? EMPTY_CONTRACT_HASH;
-}
-
-function forwardInDegree(topology: MigrationListGraphTopology, hash: string): number {
-  return topology.forwardInDegree.get(hash) ?? 0;
-}
-
-function forwardOutDegree(topology: MigrationListGraphTopology, hash: string): number {
-  return topology.forwardOutDegree.get(hash) ?? 0;
-}
-
-function buildForwardProducersByTo(
-  entries: readonly MigrationListEntry[],
-  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
-): Map<string, MigrationListEntry[]> {
-  const byTo = new Map<string, MigrationListEntry[]>();
-  for (const entry of entries) {
-    if (kindByMigrationHash.get(entry.migrationHash) !== 'forward') continue;
-    const bucket = byTo.get(entry.to);
-    if (bucket) bucket.push(entry);
-    else byTo.set(entry.to, [entry]);
-  }
-  return byTo;
-}
-
-function countForwardProducersTo(
-  forwardProducersByTo: Map<string, MigrationListEntry[]>,
-  contract: string,
-): number {
-  return forwardProducersByTo.get(contract)?.length ?? 0;
-}
-
-function hasLaterForwardDepartingFrom(
-  entries: readonly MigrationListEntry[],
-  startIndex: number,
-  contract: string,
-  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
-): boolean {
-  for (let index = startIndex + 1; index < entries.length; index++) {
-    const later = entries[index];
-    if (later === undefined) continue;
-    if (kindByMigrationHash.get(later.migrationHash) !== 'forward') continue;
-    if (canonicalFrom(later.from) === contract) return true;
-  }
-  return false;
-}
-
-export function computeMigrationListGraphLayout(
-  entries: readonly MigrationListEntry[],
-  topology: MigrationListGraphTopology = classifyMigrationListGraphTopology(entries),
-): MigrationListGraphLayout {
-  const { kindByMigrationHash } = topology;
-  const forwardProducersByTo = buildForwardProducersByTo(entries, kindByMigrationHash);
-  const convergencesEmitted = new Set<string>();
-  const producerLaneByHash = new Map<string, number>();
-  const lanes: LaneState[] = [];
-  const rows: LayoutRow[] = [];
-
-  function emitNodeLine(contractHash: string): void {
-    rows.push({ kind: 'nodeLine', contractHash, laneIndex: 0 });
-  }
-
-  function emitConnector(
-    connectorKind: ConnectorKind,
-    contractHash: string,
-    startLane: number,
-    endLane: number,
-    branchCount: number,
-  ): void {
-    rows.push({
-      kind: 'connector',
-      connectorKind,
-      contractHash,
-      startLane,
-      endLane,
-      branchCount,
-    });
-  }
-
-  function activeLaneIndices(): number[] {
-    const indices: number[] = [];
-    for (let index = 0; index < lanes.length; index++) {
-      if (lanes[index]?.active) indices.push(index);
-    }
-    return indices;
-  }
-
-  function lanesWanting(contract: string): number[] {
-    const indices: number[] = [];
-    for (let index = 0; index < lanes.length; index++) {
-      const lane = lanes[index];
-      if (lane?.active && lane.want === contract) indices.push(index);
-    }
-    return indices;
-  }
-
-  function ensureLane(index: number): void {
-    while (lanes.length <= index) {
-      lanes.push({ want: '', active: false });
-    }
-  }
-
-  function openLaneAtRight(want: string): number {
-    const index = lanes.length;
-    lanes.push({ want, active: true });
-    return index;
-  }
-
-  function closeLane(index: number): void {
-    ensureLane(index);
-    const lane = lanes[index];
-    if (lane) lane.active = false;
-  }
-
-  function emitJoinAbove(contractHash: string, laneIndices: readonly number[]): void {
-    if (laneIndices.length < 2) return;
-    const startLane = Math.min(...laneIndices);
-    const endLane = Math.max(...laneIndices);
-    emitConnector('joinAbove', contractHash, startLane, endLane, laneIndices.length);
-    for (const index of laneIndices) {
-      if (index !== startLane) closeLane(index);
-    }
-  }
-
-  function emitConvergencePreamble(contract: string): void {
-    if (convergencesEmitted.has(contract)) return;
-    if (forwardInDegree(topology, contract) < 2) return;
-
-    const consumersWanting = lanesWanting(contract);
-    if (forwardOutDegree(topology, contract) >= 2 && consumersWanting.length >= 2) {
-      emitJoinAbove(contract, consumersWanting);
-    }
-
-    emitNodeLine(contract);
-    const producers = forwardProducersByTo.get(contract) ?? [];
-    if (producers.length >= 2) {
-      emitConnector('fanBelow', contract, 0, producers.length - 1, producers.length);
-    }
-
-    for (const [producerIndex, producer] of producers.entries()) {
-      ensureLane(producerIndex);
-      lanes[producerIndex] = { want: canonicalFrom(producer.from), active: true };
-      producerLaneByHash.set(producer.migrationHash, producerIndex);
-    }
-
-    convergencesEmitted.add(contract);
-  }
-
-  function placeWoven(
-    entry: MigrationListEntry,
-    edgeKind: MigrationEdgeKind,
-    laneIndex: number,
-  ): void {
-    const passThroughLanes = activeLaneIndices().filter((index) => index !== laneIndex);
-    rows.push({
-      kind: 'migration',
-      entry,
-      edgeKind,
-      laneIndex,
-      passThroughLanes,
-      woven: true,
-    });
-    ensureLane(laneIndex);
-    lanes[laneIndex] = { want: canonicalFrom(entry.from), active: true };
-  }
-
-  function placeUnwoven(entry: MigrationListEntry, edgeKind: MigrationEdgeKind): void {
-    const passThroughLanes = activeLaneIndices();
-    const laneIndex = passThroughLanes.length === 0 ? 0 : Math.max(...passThroughLanes) + 1;
-    rows.push({
-      kind: 'migration',
-      entry,
-      edgeKind,
-      laneIndex,
-      passThroughLanes,
-      woven: false,
-    });
-  }
-
-  for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) {
-    const entry = entries[entryIndex]!;
-    const edgeKind = kindByMigrationHash.get(entry.migrationHash) ?? 'forward';
-    const to = entry.to;
-
-    if (edgeKind !== 'forward') {
-      placeUnwoven(entry, edgeKind);
-      continue;
-    }
-
-    if (forwardInDegree(topology, to) >= 2 && !convergencesEmitted.has(to)) {
-      emitConvergencePreamble(to);
-    }
-
-    const presetLane = producerLaneByHash.get(entry.migrationHash);
-    const wantingTo = lanesWanting(to);
-
-    if (wantingTo.length >= 2 && countForwardProducersTo(forwardProducersByTo, to) === 1) {
-      emitJoinAbove(to, wantingTo);
-    }
-
-    if (presetLane !== undefined) {
-      placeWoven(entry, edgeKind, presetLane);
-      continue;
-    }
-
-    const firstWanting = wantingTo[0];
-    if (firstWanting !== undefined) {
-      placeWoven(entry, edgeKind, firstWanting);
-      continue;
-    }
-
-    if (hasLaterForwardDepartingFrom(entries, entryIndex, to, kindByMigrationHash)) {
-      placeUnwoven(entry, edgeKind);
-      continue;
-    }
-
-    const tipLaneIndex = openLaneAtRight(canonicalFrom(entry.from));
-    placeWoven(entry, edgeKind, tipLaneIndex);
-  }
-
-  return { rows };
-}

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

@@ -1,311 +0,0 @@
-import type { GlyphMode } from '../glyph-mode';
-import {
-  abbreviateContractHash,
-  computeMigrationDirNameWidth,
-  formatMigrationDataColumn,
-  formatNodeLineDataColumn,
-  MIGRATION_LIST_ASCII_KIND_GLYPH,
-  MIGRATION_LIST_UNICODE_KIND_GLYPH,
-  migrationListEmptySource,
-  migrationListForwardArrow,
-} from './migration-list-data-column';
-import type {
-  ConnectorLayoutRow,
-  LayoutRow,
-  MigrationLayoutRow,
-  MigrationListGraphLayout,
-  NodeLineLayoutRow,
-} from './migration-list-graph-layout';
-import { computeMigrationListGraphLayout } from './migration-list-graph-layout';
-import type { MigrationListGraphTopology } from './migration-list-graph-topology';
-import type { MigrationListStyler } from './migration-list-render';
-import type { MigrationListEntry, MigrationListResult } from './migration-list-types';
-
-export type { GlyphMode } from '../glyph-mode';
-
-interface GlyphPalette {
-  readonly lane: string;
-  readonly node: string;
-  readonly forwardArrow: string;
-  readonly emptySource: string;
-  readonly kind: typeof MIGRATION_LIST_UNICODE_KIND_GLYPH;
-  readonly fanBelow: (branchCount: number) => string;
-  readonly joinAbove: (branchCount: number) => string;
-}
-
-const UNICODE_PALETTE: GlyphPalette = {
-  lane: '│',
-  node: 'o',
-  forwardArrow: migrationListForwardArrow('unicode'),
-  emptySource: migrationListEmptySource('unicode'),
-  kind: MIGRATION_LIST_UNICODE_KIND_GLYPH,
-  fanBelow: (branchCount) => (branchCount === 2 ? '├─┐' : '├─┬─┐'),
-  joinAbove: (branchCount) => (branchCount === 2 ? '├─┘' : '└─┴─┘'),
-};
-
-const ASCII_PALETTE: GlyphPalette = {
-  lane: '|',
-  node: 'o',
-  forwardArrow: migrationListForwardArrow('ascii'),
-  emptySource: migrationListEmptySource('ascii'),
-  kind: MIGRATION_LIST_ASCII_KIND_GLYPH,
-  fanBelow: (branchCount) => (branchCount === 2 ? '+-\\' : '+-|-\\'),
-  joinAbove: (branchCount) => (branchCount === 2 ? '+-/' : '/-+-/'),
-};
-
-function paletteFor(mode: GlyphMode): GlyphPalette {
-  return mode === 'ascii' ? ASCII_PALETTE : UNICODE_PALETTE;
-}
-
-function migrationEntries(layout: MigrationListGraphLayout): MigrationListEntry[] {
-  const entries: MigrationListEntry[] = [];
-  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(style.kind(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.joinAbove(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.map((line) => line.trimEnd()).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,
-  topology: MigrationListGraphTopology,
-): readonly string[] {
-  if (migrations.length === 0) {
-    const emptyLine = formatGraphEmptyStateLine(spaceId, style);
-    if (!multiSpace) {
-      return [emptyLine];
-    }
-    return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
-  }
-
-  const layout = computeMigrationListGraphLayout(migrations, topology);
-  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,
-  topologyBySpaceId: ReadonlyMap<string, MigrationListGraphTopology>,
-): 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('');
-    }
-    const topology = topologyBySpaceId.get(space.spaceId);
-    if (topology === undefined) {
-      throw new Error(`missing topology for space ${space.spaceId}`);
-    }
-    lines.push(
-      ...renderGraphSpaceBlock(
-        space.spaceId,
-        space.migrations,
-        multiSpace,
-        style,
-        glyphMode,
-        topology,
-      ),
-    );
-  }
-
-  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');
-}