@prisma-next/cli 0.14.0-dev.49 → 0.14.0-dev.50

package/src/control-api/operations/run-migration.ts

@@ -45,10 +45,11 @@ export interface RunMigrationInputs<TFamilyId extends string, TTargetId extends
   readonly aggregate: ContractSpaceAggregate;
   /**
    * Per-space plans, keyed by `spaceId`. Produced by either the full
-   * {@link planMigration} pipeline (`db init` / `db update` — synth
-   * for the app, graph-walk for extensions) or by direct
-   * {@link graphWalkStrategy} calls (`migrate` — graph-walk
-   * for every contract space). Either way, the runner consumes the same shape.
+   * {@link planMigration} pipeline (`db init` / `db update` —
+   * `planFromDiff` for the app, `resolveRecordedPath` for extensions) or
+   * by direct {@link resolveRecordedPath} calls (`migrate` — resolves
+   * the recorded path for every contract space). Either way, the runner
+   * consumes the same shape.
    */
   readonly perSpacePlans: ReadonlyMap<string, PerSpacePlan>;
   /**

package/src/control-api/types.ts

@@ -545,7 +545,7 @@ export type EmitResult = Result<EmitSuccess, EmitFailure>;
  *
  * The control-api operation is responsible for: loading the
  * contract-space aggregate, reading per-space marker rows from the
- * live database, plotting per-space paths via `graphWalkStrategy`
+ * live database, plotting per-space paths via `resolveRecordedPath`
  * (replay-only — no synth, no introspection), and dispatching
  * through the shared `runMigration` primitive. The CLI command
  * just resolves the descriptor surface (config, refs, contract

package/src/utils/combine-verify-results.ts

@@ -12,11 +12,11 @@ export interface CombinedVerifyResult {
 
 /**
  * Collapse the aggregate verifier's per-space contract-satisfaction results
- * into a single {@link VerifyDatabaseSchemaResult} for the existing CLI
- * display surface, and carry the deduplicated unclaimed-elements list
- * alongside it. Concatenates issues across spaces; sums counts; uses the app
- * space's result as the structural envelope (storage hash, target). Extras are
- * already stripped from each per-space result, so nothing here duplicates an
+ * into a single {@link VerifyDatabaseSchemaResult} for the CLI display
+ * surface, and carry the deduplicated unclaimed-elements list alongside it.
+ * Concatenates the issue lists across spaces; uses the app space's result as
+ * the structural envelope (storage hash, target). Extras are already
+ * stripped from each per-space result, so nothing here duplicates an
  * unclaimed element per space.
  *
  * **Unclaimed disposition.** In strict mode a non-empty `unclaimed` list fails
@@ -50,21 +50,14 @@ export function combineVerifyResults(
   let okAll = true;
   let firstFailure: VerifyDatabaseSchemaResult | undefined;
   let issues: VerifyDatabaseSchemaResult['schema']['issues'] = [];
-  let schemaDiffIssues: VerifyDatabaseSchemaResult['schema']['schemaDiffIssues'] = [];
-  const counts = { pass: 0, warn: 0, fail: 0, totalNodes: 0 };
-  const childRoots: Array<VerifyDatabaseSchemaResult['schema']['root']> = [];
+  let warningIssues: VerifyDatabaseSchemaResult['schema']['issues'] = [];
   for (const [, result] of perSpace) {
     if (!result.ok) {
       okAll = false;
       if (firstFailure === undefined) firstFailure = result;
     }
     issues = [...issues, ...result.schema.issues];
-    schemaDiffIssues = [...schemaDiffIssues, ...result.schema.schemaDiffIssues];
-    counts.pass += result.schema.counts.pass;
-    counts.warn += result.schema.counts.warn;
-    counts.fail += result.schema.counts.fail;
-    counts.totalNodes += result.schema.counts.totalNodes;
-    childRoots.push(result.schema.root);
+    warningIssues = [...warningIssues, ...(result.schema.warnings?.issues ?? [])];
   }
 
   const unclaimedFails = strict && unclaimed.length > 0;
@@ -91,19 +84,7 @@ export function combineVerifyResults(
       target: appResult.target,
       schema: {
         issues,
-        schemaDiffIssues,
-        root: {
-          status: ok ? 'pass' : 'fail',
-          kind: 'aggregate',
-          name: 'aggregate',
-          contractPath: '',
-          code: 'AGGREGATE',
-          message: ok ? 'Aggregate schema matches' : 'Aggregate schema mismatch',
-          expected: undefined,
-          actual: undefined,
-          children: childRoots,
-        },
-        counts,
+        warnings: { issues: warningIssues },
       },
       meta: { strict },
       timings: { total: 0 },

package/src/utils/formatters/errors.ts

@@ -48,9 +48,17 @@ export function formatErrorOutput(error: CliErrorEnvelope, flags: GlobalFlags):
       }
     }
   }
-  // Show issues list if present (always show a short list; show full list when verbose)
+  // Show issues list if present (always show a short list; show full list when verbose).
+  // `issues` is a shared error-envelope field: PSL interpretation diagnostics stamp
+  // `kind` with their diagnostic code (e.g. `PSL_ORPHANED_BACKRELATION_LIST`); schema-diff
+  // issues carry no `kind` and stamp `reason` instead (e.g. `not-found`). Prefer whichever
+  // the producer supplied.
   if (error.meta?.['issues']) {
-    const issues = error.meta['issues'] as readonly { kind?: string; message?: string }[];
+    const issues = error.meta['issues'] as readonly {
+      kind?: string;
+      reason?: string;
+      message?: string;
+    }[];
     if (issues.length > 0) {
       const maxToShow = isVerbose(flags, 1) ? issues.length : Math.min(3, issues.length);
       const header = isVerbose(flags, 1)
@@ -58,9 +66,9 @@ export function formatErrorOutput(error: CliErrorEnvelope, flags: GlobalFlags):
         : `  Issues (showing ${maxToShow} of ${issues.length}):`;
       lines.push(`${formatDimText(header)}`);
       for (const issue of issues.slice(0, maxToShow)) {
-        const kind = issue.kind ?? 'issue';
+        const label = issue.kind ?? issue.reason ?? 'issue';
         const message = issue.message ?? '';
-        lines.push(`${formatDimText(`    - [${kind}] ${message}`)}`);
+        lines.push(`${formatDimText(`    - [${label}] ${message}`)}`);
       }
       if (!isVerbose(flags, 1) && issues.length > maxToShow) {
         lines.push(`${formatDimText('  Re-run with -v/--verbose to see all issues')}`);

package/src/utils/formatters/verify.ts

@@ -1,8 +1,9 @@
 import type {
   CoreSchemaView,
+  ExpectationFailureReason,
   IntrospectSchemaResult,
+  SchemaDiffIssue,
   SchemaTreeNode,
-  SchemaVerificationNode,
   SignDatabaseResult,
   VerifyDatabaseResult,
   VerifyDatabaseSchemaResult,
@@ -12,6 +13,23 @@ import { bold, cyan, dim, green, magenta, red, yellow } from 'colorette';
 import type { GlobalFlags } from '../global-flags';
 import { createColorFormatter, formatDim, isVerbose } from './helpers';
 
+/** Human-readable label for each failure reason, prefixed onto an issue's message for display. */
+const REASON_LABEL: Record<ExpectationFailureReason, string> = {
+  'not-found': 'missing',
+  'not-expected': 'extra',
+  'not-equal': 'mismatch',
+};
+
+/**
+ * The issue's display text: its own message (the differ's `path`), prefixed
+ * with a human label for why it's flagged. Turning `reason` into a label is
+ * this formatter's job, not the differ's — the differ's issue is data
+ * (`path` + `reason` + nodes), not prose.
+ */
+function formatIssueMessage(issue: SchemaDiffIssue): string {
+  return `${REASON_LABEL[issue.reason]}: ${issue.message}`;
+}
+
 // ============================================================================
 // Verify Output Formatters
 // ============================================================================
@@ -27,8 +45,13 @@ export interface DbVerifyCommandSuccessResult {
   readonly codecCoverageSkipped?: VerifyDatabaseResult['codecCoverageSkipped'];
   readonly schema?: {
     readonly summary: string;
-    readonly counts: VerifyDatabaseSchemaResult['schema']['counts'];
     readonly strict: boolean;
+    /**
+     * Warn-graded finding messages (observed-policy drift). Informational —
+     * present on a passing verify; the full-mode result summarizes them as a
+     * flat message list.
+     */
+    readonly warnings?: readonly string[];
   };
   /**
    * Live element names no contract space declares. In full success this is
@@ -77,11 +100,14 @@ export function formatVerifyOutput(
   if (result.contract.profileHash) {
     lines.push(`${formatDimText(`  profileHash: ${result.contract.profileHash}`)}`);
   }
-  if (result.mode === 'full' && result.schema && isVerbose(flags, 1)) {
-    lines.push(
-      `${formatDimText(`  schema: pass=${result.schema.counts.pass} warn=${result.schema.counts.warn} fail=${result.schema.counts.fail}`)}`,
-    );
+  if (result.schema?.warnings && result.schema.warnings.length > 0) {
+    lines.push('');
+    lines.push(formatYellow('Schema warnings:'));
+    for (const message of result.schema.warnings) {
+      lines.push(`  ${formatYellow('⚠')} ${message}`);
+    }
   }
+
   if (result.unclaimed && result.unclaimed.length > 0) {
     lines.push('');
     lines.push(formatYellow('Unclaimed elements (declared by no contract):'));
@@ -139,7 +165,7 @@ export function formatIntrospectJson(result: IntrospectSchemaResult<unknown>): s
 
 /**
  * Renders a schema tree structure from CoreSchemaView.
- * Matches the style of renderSchemaVerificationTree for consistency.
+ * Status-glyph tree styling shared with the retired verification-tree renderer.
  */
 function renderSchemaTree(
   node: SchemaTreeNode,
@@ -325,207 +351,6 @@ export function formatIntrospectOutput(
   return lines.join('\n');
 }
 
-/**
- * Renders a schema verification tree structure from SchemaVerificationNode.
- * Similar to renderSchemaTree but for verification nodes with status-based colors and glyphs.
- */
-function renderSchemaVerificationTree(
-  node: SchemaVerificationNode,
-  flags: GlobalFlags,
-  options: {
-    readonly isLast: boolean;
-    readonly prefix: string;
-    readonly useColor: boolean;
-    readonly formatDimText: (text: string) => string;
-    readonly isRoot?: boolean;
-  },
-): string[] {
-  const { isLast, prefix, useColor, formatDimText, isRoot = false } = options;
-  const lines: string[] = [];
-
-  // Format status glyph and color based on status
-  let statusGlyph = '';
-  let statusColor: (text: string) => string = (text) => text;
-  if (useColor) {
-    switch (node.status) {
-      case 'pass':
-        statusGlyph = '✔';
-        statusColor = green;
-        break;
-      case 'warn':
-        statusGlyph = '⚠';
-        statusColor = (text) => (useColor ? yellow(text) : text);
-        break;
-      case 'fail':
-        statusGlyph = '✖';
-        statusColor = red;
-        break;
-    }
-  } else {
-    switch (node.status) {
-      case 'pass':
-        statusGlyph = '✔';
-        break;
-      case 'warn':
-        statusGlyph = '⚠';
-        break;
-      case 'fail':
-        statusGlyph = '✖';
-        break;
-    }
-  }
-
-  // Format node label with color based on kind
-  // For column nodes, we need to parse the name to color code different parts
-  let labelColor: (text: string) => string = (text) => text;
-  let formattedLabel: string = node.name;
-
-  if (useColor) {
-    switch (node.kind) {
-      case 'contract':
-      case 'schema':
-        labelColor = bold;
-        formattedLabel = labelColor(node.name);
-        break;
-      case 'table': {
-        // Parse "table tableName" format - color "table" dim, tableName cyan
-        const tableMatch = node.name.match(/^table\s+(.+)$/);
-        if (tableMatch?.[1]) {
-          const tableName = tableMatch[1];
-          formattedLabel = `${dim('table')} ${cyan(tableName)}`;
-        } else {
-          formattedLabel = dim(node.name);
-        }
-        break;
-      }
-      case 'columns':
-        labelColor = dim;
-        formattedLabel = labelColor(node.name);
-        break;
-      case 'column': {
-        // Parse column name format: "columnName: contractType -> nativeType (nullability)"
-        // Color code: column name (cyan), contract type (default), native type (dim), nullability (dim)
-        const columnMatch = node.name.match(/^([^:]+):\s*(.+)$/);
-        if (columnMatch?.[1] && columnMatch[2]) {
-          const columnName = columnMatch[1];
-          const rest = columnMatch[2];
-          // Parse rest: "contractType -> nativeType (nullability)"
-          // Match contract type (can contain /, @, etc.), arrow, native type, then nullability in parentheses
-          const typeMatch = rest.match(/^([^\s→]+)\s*→\s*([^\s(]+)\s*(\([^)]+\))$/);
-          if (typeMatch?.[1] && typeMatch[2] && typeMatch[3]) {
-            const contractType = typeMatch[1];
-            const nativeType = typeMatch[2];
-            const nullability = typeMatch[3];
-            formattedLabel = `${cyan(columnName)}: ${contractType} → ${dim(nativeType)} ${dim(nullability)}`;
-          } else {
-            // Fallback if format doesn't match (e.g., no native type or no nullability)
-            formattedLabel = `${cyan(columnName)}: ${rest}`;
-          }
-        } else {
-          formattedLabel = node.name;
-        }
-        break;
-      }
-      case 'type':
-      case 'nullability':
-        labelColor = (text) => text; // Default color
-        formattedLabel = labelColor(node.name);
-        break;
-      case 'primaryKey': {
-        // Parse "primary key: columnName" format - color "primary key" dim, columnName cyan
-        const pkMatch = node.name.match(/^primary key:\s*(.+)$/);
-        if (pkMatch?.[1]) {
-          const columnNames = pkMatch[1];
-          formattedLabel = `${dim('primary key')}: ${cyan(columnNames)}`;
-        } else {
-          formattedLabel = dim(node.name);
-        }
-        break;
-      }
-      case 'foreignKey':
-      case 'unique':
-      case 'index':
-        labelColor = dim;
-        formattedLabel = labelColor(node.name);
-        break;
-      case 'dependency': {
-        // Parse specific extension message formats
-        // "database is postgres" -> dim "database is", cyan "postgres"
-        const dbMatch = node.name.match(/^database is\s+(.+)$/);
-        if (dbMatch?.[1]) {
-          const dbName = dbMatch[1];
-          formattedLabel = `${dim('database is')} ${cyan(dbName)}`;
-        } else {
-          // "vector extension is enabled" -> dim everything except extension name
-          // Match pattern: "extensionName extension is enabled"
-          const extMatch = node.name.match(/^([^\s]+)\s+(extension is enabled)$/);
-          if (extMatch?.[1] && extMatch[2]) {
-            const extName = extMatch[1];
-            const rest = extMatch[2];
-            formattedLabel = `${cyan(extName)} ${dim(rest)}`;
-          } else {
-            // Fallback: color entire name with magenta
-            labelColor = magenta;
-            formattedLabel = labelColor(node.name);
-          }
-        }
-        break;
-      }
-      default:
-        formattedLabel = node.name;
-        break;
-    }
-  } else {
-    formattedLabel = node.name;
-  }
-
-  const statusGlyphColored = statusColor(statusGlyph);
-
-  // Build the label with optional message for failure/warn nodes
-  let nodeLabel = formattedLabel;
-  if (
-    (node.status === 'fail' || node.status === 'warn') &&
-    node.message &&
-    node.message.length > 0
-  ) {
-    // Always show message for failure/warn nodes - it provides crucial context
-    // For parent nodes, the message summarizes child failures
-    // For leaf nodes, the message explains the specific issue
-    const messageText = formatDimText(`(${node.message})`);
-    nodeLabel = `${formattedLabel} ${messageText}`;
-  }
-
-  // Root node renders without tree characters or | prefix
-  // Root node renders without tree characters or prefix
-  if (isRoot) {
-    lines.push(`${statusGlyphColored} ${nodeLabel}`);
-  } else {
-    const treeChar = isLast ? '└' : '├';
-    const treePrefix = `${formatDimText(treeChar)}─ `;
-    lines.push(`${prefix}${treePrefix}${statusGlyphColored} ${nodeLabel}`);
-  }
-
-  // Render children if present
-  if (node.children && node.children.length > 0) {
-    const childPrefix = isRoot ? '' : `${prefix}${isLast ? '   ' : `${formatDimText('│')}  `}`;
-    for (let i = 0; i < node.children.length; i++) {
-      const child = node.children[i];
-      if (!child) continue;
-      const isLastChild = i === node.children.length - 1;
-      const childLines = renderSchemaVerificationTree(child, flags, {
-        isLast: isLastChild,
-        prefix: childPrefix,
-        useColor,
-        formatDimText,
-        isRoot: false,
-      });
-      lines.push(...childLines);
-    }
-  }
-
-  return lines;
-}
-
 /**
  * Formats human-readable output for database schema verification.
  */
@@ -546,27 +371,26 @@ export function formatSchemaVerifyOutput(
   const formatYellow = createColorFormatter(useColor, yellow);
   const formatDimText = (text: string) => formatDim(useColor, text);
 
-  // Render verification tree first
-  const treeLines = renderSchemaVerificationTree(result.schema.root, flags, {
-    isLast: true,
-    prefix: '',
-    useColor,
-    formatDimText,
-    isRoot: true,
-  });
-  lines.push(...treeLines);
-
-  if (result.schema.schemaDiffIssues.length > 0) {
-    lines.push('');
-    lines.push(formatRed('Schema drift:'));
-    for (const issue of result.schema.schemaDiffIssues) {
-      lines.push(`  ${formatRed('✖')} ${issue.message}`);
+  const issueMessages = result.schema.issues.map(formatIssueMessage);
+  if (issueMessages.length > 0) {
+    lines.push(formatRed('Schema issues:'));
+    for (const message of issueMessages) {
+      lines.push(`  ${formatRed('✖')} ${message}`);
+    }
+  }
+
+  const warningMessages = (result.schema.warnings?.issues ?? []).map(formatIssueMessage);
+  if (warningMessages.length > 0) {
+    if (lines.length > 0) lines.push('');
+    lines.push(formatYellow('Schema warnings:'));
+    for (const message of warningMessages) {
+      lines.push(`  ${formatYellow('⚠')} ${message}`);
     }
   }
 
   if (unclaimed.length > 0) {
     const strict = result.meta?.strict ?? false;
-    lines.push('');
+    if (lines.length > 0) lines.push('');
     lines.push(
       (strict ? formatRed : formatYellow)('Unclaimed elements (declared by no contract):'),
     );
@@ -575,18 +399,14 @@ export function formatSchemaVerifyOutput(
     }
   }
 
-  // Add counts and timings in verbose mode
   if (isVerbose(flags, 1)) {
     lines.push(`${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
-    lines.push(
-      `${formatDimText(`  pass=${result.schema.counts.pass} warn=${result.schema.counts.warn} fail=${result.schema.counts.fail}`)}`,
-    );
   }
 
   // Blank line before summary
-  lines.push('');
+  if (lines.length > 0) lines.push('');
 
-  // Summary line at the end: summary with status glyph
+  // Summary line at the end: verdict with status glyph
   if (result.ok) {
     lines.push(`${formatGreen('✔')} ${result.summary}`);
   } else {