@prisma-next/cli 0.11.0-dev.5 → 0.11.0-dev.51

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

@@ -0,0 +1,194 @@
+import {
+  classifyMigrationListGraphTopology,
+  type MigrationEdgeKind,
+  type MigrationListGraphTopology,
+} from '@prisma-next/migration-tools/migration-list-graph-topology';
+import type {
+  MigrationListEntry,
+  MigrationListResult,
+} from '@prisma-next/migration-tools/migration-list-types';
+import type { GlyphMode } from '../glyph-mode';
+import {
+  computeMigrationDirNameWidth,
+  formatMigrationDataColumn,
+  migrationListEmptySource,
+  migrationListForwardArrow,
+  migrationListKindGlyph,
+} from './migration-list-data-column';
+
+export type { MigrationEdgeKind } from '@prisma-next/migration-tools/migration-list-graph-topology';
+export type {
+  MigrationListEntry,
+  MigrationListResult,
+  MigrationSpaceListEntry,
+} from '@prisma-next/migration-tools/migration-list-types';
+export type { GlyphMode } from '../glyph-mode';
+
+/**
+ * Semantic styler for `migration list` output tokens. Token-typed so
+ * the renderer composes presentation-neutral fragments and the styler
+ * decides how each token kind is decorated (ANSI codes, plain text,
+ * etc.). The renderer pads with raw spaces *outside* styled tokens so
+ * visible column widths stay stable regardless of what the styler
+ * emits — adding ANSI escape sequences never disturbs alignment.
+ *
+ * `invariants` and `refs` receive the underlying string arrays rather
+ * than a pre-joined string so per-element styling (e.g. distinguishing
+ * the live-DB `db` marker from user-named refs) is possible without
+ * 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;
+  summary(text: string): string;
+  emptyState(text: string): string;
+}
+
+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,
+  summary: (text) => text,
+  emptyState: (text) => text,
+};
+
+function resolveEdgeKind(
+  migrationHash: string,
+  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
+): MigrationEdgeKind {
+  return kindByMigrationHash.get(migrationHash) ?? 'forward';
+}
+
+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}`;
+}
+
+function formatEmptyStateLine(spaceId: string, style: MigrationListStyler): string {
+  return style.emptyState(`There are no migrations in migrations/${spaceId}/ yet`);
+}
+
+function renderSpaceBlock(
+  spaceId: string,
+  migrations: readonly MigrationListEntry[],
+  multiSpace: boolean,
+  glyphMode: GlyphMode,
+  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
+  style: MigrationListStyler,
+): readonly string[] {
+  if (migrations.length === 0) {
+    const emptyLine = formatEmptyStateLine(spaceId, style);
+    if (!multiSpace) {
+      return [emptyLine];
+    }
+    return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
+  }
+
+  const dirNameWidth = computeMigrationDirNameWidth(migrations);
+  const rows = migrations.map((entry) =>
+    formatMigrationRow(
+      entry,
+      dirNameWidth,
+      resolveEdgeKind(entry.migrationHash, kindByMigrationHash),
+      glyphMode,
+      style,
+    ),
+  );
+  if (!multiSpace) {
+    return rows;
+  }
+  return [style.spaceHeading(`${spaceId}:`), ...rows.map((row) => `  ${row}`)];
+}
+
+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;
+}
+
+/**
+ * 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).
+ */
+export function renderMigrationListWithStyle(
+  result: MigrationListResult,
+  style: MigrationListStyler,
+  glyphMode: GlyphMode = 'unicode',
+  topologyBySpaceId: ReadonlyMap<
+    string,
+    MigrationListGraphTopology
+  > = buildMigrationListTopologyBySpace(result),
+): 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);
+    const kindByMigrationHash =
+      topology?.kindByMigrationHash ??
+      classifyMigrationListGraphTopology(space.migrations).kindByMigrationHash;
+    lines.push(
+      ...renderSpaceBlock(
+        space.spaceId,
+        space.migrations,
+        multiSpace,
+        glyphMode,
+        kindByMigrationHash,
+        style,
+      ),
+    );
+  }
+
+  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');
+}
+
+export function renderMigrationList(result: MigrationListResult): string {
+  return renderMigrationListWithStyle(result, IDENTITY_MIGRATION_LIST_STYLER);
+}

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

@@ -0,0 +1,61 @@
+import { bold, cyan, cyanBright, dim, green, greenBright, yellow } from 'colorette';
+import { IDENTITY_MIGRATION_LIST_STYLER, type MigrationListStyler } from './migration-list-render';
+
+/**
+ * The reserved ref name for the live-database marker. Treated as a
+ * structurally distinct token from user-named refs so the styler can
+ * make it visually pop in `(refs)` decorations.
+ */
+const DB_REF_NAME = 'db';
+
+function styleRefName(name: string): string {
+  return name === DB_REF_NAME ? bold(greenBright(name)) : green(name);
+}
+
+/**
+ * Build a {@link MigrationListStyler} that decorates `migration list`
+ * tokens with ANSI SGR codes. When `useColor` is `false` (non-TTY,
+ * `--no-color`, `NO_COLOR=1`, piped output) the function returns the
+ * shared identity styler so callers get plain text with zero ANSI
+ * bytes — pipe-friendly by construction.
+ *
+ * Palette:
+ *
+ * - `dirName`: bold
+ * - `sourceHash`: dim cyan
+ * - `destHash`: bright cyan
+ * - `kind` (`*` / `↩` / `⟲`): bright — the signal; lanes and arrows dim
+ * - `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
+ * - `summary`: dim
+ * - `emptyState`: dim
+ */
+export function createAnsiMigrationListStyler(opts: {
+  readonly useColor: boolean;
+}): MigrationListStyler {
+  if (!opts.useColor) {
+    return IDENTITY_MIGRATION_LIST_STYLER;
+  }
+  return {
+    // Kind glyphs stay bright in both flat and graph views; lanes carry the dim gutter.
+    kind: (text) => 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('(');
+      const close = green(')');
+      const separator = green(', ');
+      return open + names.map(styleRefName).join(separator) + close;
+    },
+    spaceHeading: (text) => bold(text),
+    summary: (text) => dim(text),
+    emptyState: (text) => dim(text),
+  };
+}

package/src/utils/formatters/migrations.ts

@@ -82,6 +82,8 @@ export interface MigrationCommandResult {
    * into a single ambiguous list. See {@link AggregatePerSpaceExecutionEntry}.
    */
   readonly perSpace?: ReadonlyArray<AggregatePerSpaceExecutionEntry>;
+  readonly advancedRef?: { readonly name: string; readonly hash: string } | null;
+  readonly plannedAdvanceRef?: { readonly name: string; readonly hash: string } | null;
   readonly summary: string;
   readonly timings: {
     readonly total: number;
@@ -208,6 +210,15 @@ export function formatMigrationPlanOutput(
     lines.push(`${formatDimText(`Destination hash: ${result.plan.destination.storageHash}`)}`);
   }
 
+  if (result.plannedAdvanceRef) {
+    lines.push('');
+    lines.push(
+      formatDimText(
+        `Would advance ref "${result.plannedAdvanceRef.name}" → ${result.plannedAdvanceRef.hash}`,
+      ),
+    );
+  }
+
   // Statement preview (any family that implements OperationPreviewCapable)
   const preview = result.plan?.preview;
   if (preview) {
@@ -260,6 +271,7 @@ export interface MigrationApplyCommandOutputResult {
   readonly timings?: {
     readonly total: number;
   };
+  readonly advancedRef?: { readonly name: string; readonly hash: string } | null;
 }
 
 export function formatMigrationApplyCommandOutput(
@@ -284,6 +296,13 @@ export function formatMigrationApplyCommandOutput(
     }
   }
 
+  if (result.advancedRef) {
+    lines.push('');
+    lines.push(
+      formatDimText(`Advanced ref "${result.advancedRef.name}" → ${result.advancedRef.hash}`),
+    );
+  }
+
   lines.push('');
   lines.push(formatDimText('Next: prisma-next migration status'));
 
@@ -295,9 +314,7 @@ export function formatMigrationApplyCommandOutput(
   return lines.join('\n');
 }
 
-interface MigrationShowSpacePresent {
-  readonly kind: 'present';
-  readonly spaceId: string;
+interface MigrationShowPresent {
   readonly dirName: string;
   readonly dirPath: string;
   readonly from: string | null;
@@ -313,22 +330,11 @@ interface MigrationShowSpacePresent {
   readonly summary: string;
 }
 
-interface MigrationShowSpaceMissing {
-  readonly kind: 'missing';
-  readonly spaceId: string;
-  readonly summary: string;
-}
-
-type MigrationShowSpaceResult = MigrationShowSpacePresent | MigrationShowSpaceMissing;
-
 interface MigrationShowResult {
-  readonly spaces: readonly MigrationShowSpaceResult[];
+  readonly migration: MigrationShowPresent;
 }
 
-function formatSpaceShowBlock(
-  space: MigrationShowSpacePresent,
-  useColor: boolean,
-): readonly string[] {
+function formatSpaceShowBlock(space: MigrationShowPresent, useColor: boolean): readonly string[] {
   const formatGreen = createColorFormatter(useColor, green);
   const formatYellow = createColorFormatter(useColor, yellow);
   const formatDimText = (text: string) => formatDim(useColor, text);
@@ -384,28 +390,7 @@ export function formatMigrationShowOutput(result: MigrationShowResult, flags: Gl
   }
 
   const useColor = flags.color !== false;
-  const formatDimText = (text: string) => formatDim(useColor, text);
-  const multipleSpaces = result.spaces.length > 1;
-  const lines: string[] = [];
-
-  for (let i = 0; i < result.spaces.length; i++) {
-    const space = result.spaces[i]!;
-    if (multipleSpaces) {
-      lines.push(formatDimText(`── ${space.spaceId} ──`));
-    }
-    if (space.kind === 'missing') {
-      lines.push(formatDimText(`  ${space.summary}`));
-    } else {
-      for (const line of formatSpaceShowBlock(space, useColor)) {
-        lines.push(line);
-      }
-    }
-    if (i < result.spaces.length - 1) {
-      lines.push('');
-    }
-  }
-
-  return lines.join('\n');
+  return formatSpaceShowBlock(result.migration, useColor).join('\n');
 }
 
 /**
@@ -470,6 +455,12 @@ export function formatMigrationApplyOutput(
     if (isVerbose(flags, 1)) {
       lines.push(`${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
     }
+
+    if (result.advancedRef) {
+      lines.push(
+        formatDimText(`Advanced ref "${result.advancedRef.name}" → ${result.advancedRef.hash}`),
+      );
+    }
   }
 
   return lines.join('\n');

package/src/utils/glyph-mode.ts

@@ -0,0 +1,22 @@
+export type GlyphMode = 'unicode' | 'ascii';
+
+export interface GlyphModeInput {
+  readonly isTTY: boolean;
+  readonly env: Readonly<Record<string, string | undefined>>;
+}
+
+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';
+}

package/src/utils/integrity-violation-to-check-failure.ts

@@ -0,0 +1,130 @@
+import type { IntegrityViolation } from '@prisma-next/migration-tools/aggregate';
+import { join, relative } from 'pathe';
+
+export interface CheckFailure {
+  readonly pnCode: string;
+  readonly where: string;
+  readonly why: string;
+  readonly fix: string;
+}
+
+function migrationPathRelative(dirPath: string): string {
+  return relative(process.cwd(), dirPath);
+}
+
+function migrationFileRelative(dirPath: string, fileName: string): string {
+  return join(migrationPathRelative(dirPath), fileName);
+}
+
+/**
+ * Map one {@link IntegrityViolation} onto a `migration check` failure row.
+ * Sole catalogue mapping from integrity violations to `PN-MIG-CHECK-*`.
+ */
+export function integrityViolationToCheckFailure(
+  violation: IntegrityViolation,
+  migrationsDir: string,
+): CheckFailure {
+  const spaceRelative = (spaceId: string): string =>
+    migrationPathRelative(join(migrationsDir, spaceId));
+  const packageRelative = (spaceId: string, dirName: string): string =>
+    migrationPathRelative(join(migrationsDir, spaceId, dirName));
+  const refRelative = (spaceId: string, refName: string): string =>
+    migrationPathRelative(join(migrationsDir, spaceId, 'refs', `${refName}.json`));
+
+  switch (violation.kind) {
+    case 'hashMismatch':
+      return {
+        pnCode: 'PN-MIG-CHECK-001',
+        where: migrationFileRelative(
+          join(migrationsDir, violation.spaceId, violation.dirName),
+          'migration.json',
+        ),
+        why: `Stored hash ${violation.stored} does not match recomputed hash ${violation.computed}`,
+        fix: 'Re-emit the migration package or restore from version control.',
+      };
+    case 'providedInvariantsMismatch':
+      return {
+        pnCode: 'PN-MIG-CHECK-002',
+        where: packageRelative(violation.spaceId, violation.dirName),
+        why: `Migration "${violation.dirName}" providedInvariants in migration.json disagrees with ops.json.`,
+        fix: 'Re-emit the migration package so migration.json and ops.json agree.',
+      };
+    case 'packageUnloadable':
+      return {
+        pnCode: 'PN-MIG-CHECK-002',
+        where: packageRelative(violation.spaceId, violation.dirName),
+        why: `Migration "${violation.dirName}" could not be loaded: ${violation.detail}`,
+        fix: 'Re-emit the migration package or restore from version control.',
+      };
+    case 'sameSourceAndTarget':
+      return {
+        pnCode: 'PN-MIG-CHECK-007',
+        where: packageRelative(violation.spaceId, violation.dirName),
+        why: `Migration "${violation.dirName}" in space "${violation.spaceId}" has source equal to target (${violation.hash}) with no data invariant — a true no-op self-edge.`,
+        fix: 'Add a data operation if this self-edge was meant to carry a data invariant, or delete the migration if it is a true no-op.',
+      };
+    case 'orphanSpaceDir':
+      return {
+        pnCode: 'PN-MIG-CHECK-008',
+        where: spaceRelative(violation.spaceId),
+        why: `Contract-space directory "${violation.spaceId}" exists on disk but no extension declares it.`,
+        fix: 'Remove the orphan directory, or declare the extension in `extensionPacks`.',
+      };
+    case 'declaredButUnmigrated':
+      return {
+        pnCode: 'PN-MIG-CHECK-009',
+        where: spaceRelative(violation.spaceId),
+        why: `Extension "${violation.spaceId}" is declared in \`extensionPacks\` but has no on-disk migrations directory.`,
+        fix: 'Re-emit the extension contract-space artefacts with `prisma-next contract emit` and migration planning, or remove the extension from `extensionPacks` if it is unused.',
+      };
+    case 'headRefMissing':
+      return {
+        pnCode: 'PN-MIG-CHECK-010',
+        where: refRelative(violation.spaceId, 'head'),
+        why: `Head ref \`refs/head.json\` is missing for contract space "${violation.spaceId}".`,
+        fix: 'Re-emit the contract-space migrations and head ref artefacts, or restore `refs/head.json` from version control.',
+      };
+    case 'headRefNotInGraph':
+      return {
+        pnCode: 'PN-MIG-CHECK-011',
+        where: refRelative(violation.spaceId, 'head'),
+        why: `Head ref ${violation.hash} for contract space "${violation.spaceId}" is not present in its migration graph.`,
+        fix: 'Re-emit the contract space migrations, or restore the missing migration package.',
+      };
+    case 'refUnreadable':
+      return {
+        pnCode: 'PN-MIG-CHECK-012',
+        where: refRelative(violation.spaceId, violation.refName),
+        why: `Ref "${violation.refName}" for contract space "${violation.spaceId}" is unreadable: ${violation.detail}`,
+        fix: 'Repair or remove the corrupt ref file.',
+      };
+    case 'targetMismatch':
+      return {
+        pnCode: 'PN-MIG-CHECK-013',
+        where: spaceRelative(violation.spaceId),
+        why: `Contract space "${violation.spaceId}" targets "${violation.actual}" but the project targets "${violation.expected}".`,
+        fix: 'Update the extension to target the configured database, or change the project target.',
+      };
+    case 'disjointness':
+      return {
+        pnCode: 'PN-MIG-CHECK-014',
+        where: migrationPathRelative(migrationsDir),
+        why: `Storage element "${violation.element}" is claimed by multiple contract spaces: ${violation.claimedBy.join(', ')}.`,
+        fix: 'Update the contracts so each storage element is owned by exactly one contract space.',
+      };
+    case 'contractUnreadable':
+      return {
+        pnCode: 'PN-MIG-CHECK-015',
+        where: migrationFileRelative(join(migrationsDir, violation.spaceId), 'contract.json'),
+        why: `Contract for space "${violation.spaceId}" is unreadable: ${violation.detail}`,
+        fix: 'Re-emit the extension contract artefacts, or fix the descriptor producing the invalid contract.',
+      };
+    case 'duplicateMigrationHash':
+      return {
+        pnCode: 'PN-MIG-CHECK-016',
+        where: spaceRelative(violation.spaceId),
+        why: `Multiple migrations in space "${violation.spaceId}" share migrationHash "${violation.migrationHash}" (${violation.dirNames.join(', ')}).`,
+        fix: 'Re-emit one of the conflicting packages so each migrationHash is unique.',
+      };
+  }
+}