@prisma-next/cli 0.14.0 → 0.15.0-dev.1

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 path, prefixed with a human label for
+ * why it's flagged. Turning `reason` (and the path) into prose 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.path.join('/')}`;
+}
+
 // ============================================================================
 // Verify Output Formatters
 // ============================================================================
@@ -27,9 +45,20 @@ 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
+   * only ever non-empty in lenient mode — strict mode fails on it — and is
+   * rendered informationally.
+   */
+  readonly unclaimed?: readonly string[];
   readonly warning?: string;
   readonly meta?:
     | (NonNullable<VerifyDatabaseResult['meta']> & {
@@ -71,11 +100,22 @@ 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):'));
+    for (const name of result.unclaimed) {
+      lines.push(`  ${formatYellow('⚠')} ${name}`);
+    }
+  }
+
   if (result.warning) {
     lines.push('');
     lines.push(`${formatYellow('⚠')} ${result.warning}`);
@@ -107,6 +147,7 @@ export function formatVerifyJson(result: DbVerifyCommandSuccessResult): string {
     ...ifDefined('missingCodecs', result.missingCodecs),
     ...ifDefined('codecCoverageSkipped', result.codecCoverageSkipped),
     ...ifDefined('schema', result.schema),
+    unclaimed: result.unclaimed ?? [],
     ...ifDefined('warning', result.warning),
     ...ifDefined('meta', result.meta),
     timings: result.timings,
@@ -124,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,
@@ -310,213 +351,13 @@ 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.
  */
 export function formatSchemaVerifyOutput(
   result: VerifyDatabaseSchemaResult,
   flags: GlobalFlags,
+  unclaimed: readonly string[] = [],
 ): string {
   if (flags.quiet) {
     return '';
@@ -527,30 +368,45 @@ export function formatSchemaVerifyOutput(
   const useColor = flags.color !== false;
   const formatGreen = createColorFormatter(useColor, green);
   const formatRed = createColorFormatter(useColor, red);
+  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);
-
-  // Add counts and timings in verbose mode
-  if (isVerbose(flags, 1)) {
-    lines.push(`${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+  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;
+    if (lines.length > 0) lines.push('');
     lines.push(
-      `${formatDimText(`  pass=${result.schema.counts.pass} warn=${result.schema.counts.warn} fail=${result.schema.counts.fail}`)}`,
+      (strict ? formatRed : formatYellow)('Unclaimed elements (declared by no contract):'),
     );
+    for (const name of unclaimed) {
+      lines.push(`  ${(strict ? formatRed : formatYellow)(strict ? '✖' : '⚠')} ${name}`);
+    }
+  }
+
+  if (isVerbose(flags, 1)) {
+    lines.push(`${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
   }
 
   // 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 {
@@ -562,10 +418,15 @@ export function formatSchemaVerifyOutput(
 }
 
 /**
- * Formats JSON output for database schema verification.
+ * Formats JSON output for database schema verification. The unclaimed-elements
+ * list is a top-level field alongside the combined result, reported once for
+ * the whole database.
  */
-export function formatSchemaVerifyJson(result: VerifyDatabaseSchemaResult): string {
-  return JSON.stringify(result, null, 2);
+export function formatSchemaVerifyJson(
+  result: VerifyDatabaseSchemaResult,
+  unclaimed: readonly string[] = [],
+): string {
+  return JSON.stringify({ ...result, unclaimed }, null, 2);
 }
 
 // ============================================================================

package/src/utils/migration-command-scaffold.ts

@@ -1,9 +1,9 @@
 import { readFile } from 'node:fs/promises';
 import { relative, resolve } from 'node:path';
+import { loadConfig } from '@prisma-next/config-loader';
 import { hasMigrations } from '@prisma-next/framework-components/control';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import type { Command } from 'commander';
-import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
 import type { ControlClient } from '../control-api/types';
 import {

package/src/utils/plan-resolution.ts

@@ -1,5 +1,5 @@
 import type { Contract } from '@prisma-next/contract/types';
-import type { ContractSpaceMember } from '@prisma-next/migration-tools/aggregate';
+import type { AggregateContractSpace } from '@prisma-next/migration-tools/aggregate';
 import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
 import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
 import {
@@ -45,11 +45,11 @@ export type FromResolution =
 
 export interface ResolveFromForPlanInput {
   readonly optionsFrom?: string | undefined;
-  readonly member: ContractSpaceMember;
+  readonly space: AggregateContractSpace;
 }
 
-function graphIsEmpty(member: ContractSpaceMember): boolean {
-  return member.packages.length === 0;
+function graphIsEmpty(space: AggregateContractSpace): boolean {
+  return space.packages.length === 0;
 }
 
 function getReachableRefs(
@@ -98,14 +98,14 @@ type RefContractResolution =
 
 async function resolveContractRef(
   parsed: ContractRef,
-  member: ContractSpaceMember,
+  space: AggregateContractSpace,
   options?: { readonly explicitLabel?: string; readonly artifactRole?: 'from' | 'to' },
 ): Promise<Result<RefContractResolution, CliStructuredError>> {
   const { hash, provenance } = parsed;
   const refName = provenance.kind === 'ref' ? provenance.refName : undefined;
 
   try {
-    const at = await member.contractAt(hash, refName !== undefined ? { refName } : undefined);
+    const at = await space.contractAt(hash, refName !== undefined ? { refName } : undefined);
 
     if (at.provenance === 'snapshot') {
       return ok({
@@ -139,7 +139,7 @@ async function resolveFromPolicy(
   refs: Refs,
   explicitFromLabel?: string,
 ): Promise<Result<FromResolution, CliStructuredError>> {
-  const resolution = await resolveContractRef(parsed, input.member, {
+  const resolution = await resolveContractRef(parsed, input.space, {
     ...(explicitFromLabel !== undefined ? { explicitLabel: explicitFromLabel } : {}),
     artifactRole: 'from',
   });
@@ -157,7 +157,7 @@ async function resolveFromPolicy(
   }
 
   const { hash, contract, contractJson, contractDts } = resolution.value;
-  if (graphIsEmpty(input.member)) {
+  if (graphIsEmpty(input.space)) {
     return ok({
       kind: 'auto-baseline',
       fromHash: hash,
@@ -167,7 +167,7 @@ async function resolveFromPolicy(
     });
   }
 
-  const graph = input.member.graph();
+  const graph = input.space.graph();
   const graphTip = findLatestMigration(graph)?.to ?? null;
   try {
     assertFromIsGraphNode(hash, graph, refs, graphTip);
@@ -189,9 +189,9 @@ async function resolveFromPolicy(
 export async function resolveFromForPlan(
   input: ResolveFromForPlanInput,
 ): Promise<Result<FromResolution, CliStructuredError>> {
-  const { optionsFrom, member } = input;
-  const graph = member.graph();
-  const refs = member.refs;
+  const { optionsFrom, space } = input;
+  const graph = space.graph();
+  const refs = space.refs;
 
   if (optionsFrom === undefined) {
     const dbRef = refs['db'];
@@ -208,7 +208,7 @@ export async function resolveFromForPlan(
   const refResult = parseContractRef(optionsFrom, { graph, refs });
   if (!refResult.ok) {
     if (looksLikeFullHash(optionsFrom)) {
-      const empty = graphIsEmpty(member);
+      const empty = graphIsEmpty(space);
       const graphTip = findLatestMigration(graph)?.to ?? null;
       if (empty) {
         return notOk(errorSnapshotMissing(optionsFrom, { viaRef: false }));
@@ -222,7 +222,7 @@ export async function resolveFromForPlan(
 }
 
 export interface ResolveToForPlanInput {
-  readonly member: ContractSpaceMember;
+  readonly space: AggregateContractSpace;
 }
 
 export interface ResolvedContractRef {
@@ -236,16 +236,16 @@ export async function resolveToForPlan(
   optionsTo: string,
   input: ResolveToForPlanInput,
 ): Promise<Result<ResolvedContractRef, CliStructuredError>> {
-  const { member } = input;
-  const graph = member.graph();
-  const refs = member.refs;
+  const { space } = input;
+  const graph = space.graph();
+  const refs = space.refs;
 
   const refResult = parseContractRef(optionsTo, { graph, refs });
   if (!refResult.ok) {
     return notOk(mapRefResolutionError(refResult.failure));
   }
 
-  const resolution = await resolveContractRef(refResult.value, member, {
+  const resolution = await resolveContractRef(refResult.value, space, {
     explicitLabel: optionsTo,
     artifactRole: 'to',
   });