@prisma-next/cli 0.3.0-dev.6 → 0.3.0-dev.63

package/src/utils/output.ts

@@ -1,12 +1,14 @@
-import { relative } from 'node:path';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { bgGreen, blue, bold, cyan, dim, green, magenta, red, yellow } from 'colorette';
 import type { Command } from 'commander';
+import { relative } from 'pathe';
 import stringWidth from 'string-width';
 import stripAnsi from 'strip-ansi';
 import wrapAnsi from 'wrap-ansi';
 // EmitContractResult type for CLI output formatting (includes file paths)
 export interface EmitContractResult {
-  readonly coreHash: string;
+  readonly storageHash: string;
+  readonly executionHash?: string;
   readonly profileHash: string;
   readonly outDir: string;
   readonly files: {
@@ -94,7 +96,10 @@ export function formatEmitOutput(result: EmitContractResult, flags: GlobalFlags)
 
   lines.push(`${prefix}✔ Emitted contract.json → ${jsonPath}`);
   lines.push(`${prefix}✔ Emitted contract.d.ts → ${dtsPath}`);
-  lines.push(`${prefix}  coreHash: ${result.coreHash}`);
+  lines.push(`${prefix}  storageHash: ${result.storageHash}`);
+  if (result.executionHash) {
+    lines.push(`${prefix}  executionHash: ${result.executionHash}`);
+  }
   if (result.profileHash) {
     lines.push(`${prefix}  profileHash: ${result.profileHash}`);
   }
@@ -111,7 +116,8 @@ export function formatEmitOutput(result: EmitContractResult, flags: GlobalFlags)
 export function formatEmitJson(result: EmitContractResult): string {
   const output = {
     ok: true,
-    coreHash: result.coreHash,
+    storageHash: result.storageHash,
+    ...ifDefined('executionHash', result.executionHash),
     ...(result.profileHash ? { profileHash: result.profileHash } : {}),
     outDir: result.outDir,
     files: result.files,
@@ -223,7 +229,7 @@ export function formatVerifyOutput(result: VerifyDatabaseResult, flags: GlobalFl
 
   if (result.ok) {
     lines.push(`${prefix}${formatGreen('✔')} ${result.summary}`);
-    lines.push(`${prefix}${formatDimText(`  coreHash: ${result.contract.coreHash}`)}`);
+    lines.push(`${prefix}${formatDimText(`  storageHash: ${result.contract.storageHash}`)}`);
     if (result.contract.profileHash) {
       lines.push(`${prefix}${formatDimText(`  profileHash: ${result.contract.profileHash}`)}`);
     }
@@ -772,8 +778,8 @@ export function formatSignOutput(result: SignDatabaseResult, flags: GlobalFlags)
     lines.push(`${prefix}${formatGreen('✔')} Database signed`);
 
     // Show from -> to hashes with clear labels
-    const previousHash = result.marker.previous?.coreHash ?? 'none';
-    const currentHash = result.contract.coreHash;
+    const previousHash = result.marker.previous?.storageHash ?? 'none';
+    const currentHash = result.contract.storageHash;
 
     lines.push(`${prefix}${formatDimText(`  from: ${previousHash}`)}`);
     lines.push(`${prefix}${formatDimText(`  to:   ${currentHash}`)}`);
@@ -802,19 +808,19 @@ export function formatSignJson(result: SignDatabaseResult): string {
 }
 
 // ============================================================================
-// DB Init Output Formatters
+// Migration Command Output Formatters (shared by db init and db update)
 // ============================================================================
 
 /**
- * Result type for db init command.
+ * Shared CLI output type for migration commands (db init, db update).
  */
-export interface DbInitResult {
-  readonly ok: boolean;
+export interface MigrationCommandResult {
+  readonly ok: true;
   readonly mode: 'plan' | 'apply';
-  readonly plan?: {
+  readonly plan: {
     readonly targetId: string;
     readonly destination: {
-      readonly coreHash: string;
+      readonly storageHash: string;
       readonly profileHash?: string;
     };
     readonly operations: readonly {
@@ -822,13 +828,14 @@ export interface DbInitResult {
       readonly label: string;
       readonly operationClass: string;
     }[];
+    readonly sql?: readonly string[];
   };
   readonly execution?: {
     readonly operationsPlanned: number;
     readonly operationsExecuted: number;
   };
   readonly marker?: {
-    readonly coreHash: string;
+    readonly storageHash: string;
     readonly profileHash?: string;
   };
   readonly summary: string;
@@ -838,9 +845,12 @@ export interface DbInitResult {
 }
 
 /**
- * Formats human-readable output for db init plan mode.
+ * Formats human-readable output for migration commands (db init, db update) in plan mode.
  */
-export function formatDbInitPlanOutput(result: DbInitResult, flags: GlobalFlags): string {
+export function formatMigrationPlanOutput(
+  result: MigrationCommandResult,
+  flags: GlobalFlags,
+): string {
   if (flags.quiet) {
     return '';
   }
@@ -857,14 +867,26 @@ export function formatDbInitPlanOutput(result: DbInitResult, flags: GlobalFlags)
 
   // Show operations tree
   if (result.plan?.operations && result.plan.operations.length > 0) {
+    const formatYellow = createColorFormatter(useColor, yellow);
     lines.push(`${prefix}${formatDimText('│')}`);
     for (let i = 0; i < result.plan.operations.length; i++) {
       const op = result.plan.operations[i];
       if (!op) continue;
       const isLast = i === result.plan.operations.length - 1;
       const treeChar = isLast ? '└' : '├';
-      const opClass = formatDimText(`[${op.operationClass}]`);
-      lines.push(`${prefix}${formatDimText(treeChar)}─ ${op.label} ${opClass}`);
+      const opClassLabel =
+        op.operationClass === 'destructive'
+          ? formatYellow(`[${op.operationClass}]`)
+          : formatDimText(`[${op.operationClass}]`);
+      lines.push(`${prefix}${formatDimText(treeChar)}─ ${op.label} ${opClassLabel}`);
+    }
+
+    const hasDestructive = result.plan.operations.some((op) => op.operationClass === 'destructive');
+    if (hasDestructive) {
+      lines.push(`${prefix}`);
+      lines.push(
+        `${prefix}${formatYellow('⚠')} This migration contains destructive operations that may cause data loss.`,
+      );
     }
   }
 
@@ -872,10 +894,28 @@ export function formatDbInitPlanOutput(result: DbInitResult, flags: GlobalFlags)
   if (result.plan?.destination) {
     lines.push(`${prefix}`);
     lines.push(
-      `${prefix}${formatDimText(`Destination hash: ${result.plan.destination.coreHash}`)}`,
+      `${prefix}${formatDimText(`Destination hash: ${result.plan.destination.storageHash}`)}`,
     );
   }
 
+  // SQL DDL preview (SQL family only)
+  const planSql = result.plan?.sql;
+  if (planSql) {
+    lines.push(`${prefix}`);
+    lines.push(`${prefix}${formatDimText('DDL preview')}`);
+    if (planSql.length === 0) {
+      lines.push(`${prefix}${formatDimText('No DDL operations.')}`);
+    } else {
+      lines.push(`${prefix}`);
+      for (const statement of planSql) {
+        const trimmed = statement.trim();
+        if (!trimmed) continue;
+        const line = trimmed.endsWith(';') ? trimmed : `${trimmed};`;
+        lines.push(`${prefix}${line}`);
+      }
+    }
+  }
+
   // Timings in verbose mode
   if (isVerbose(flags, 1)) {
     lines.push(`${prefix}${formatDimText(`Total time: ${result.timings.total}ms`)}`);
@@ -889,10 +929,303 @@ export function formatDbInitPlanOutput(result: DbInitResult, flags: GlobalFlags)
   return lines.join('\n');
 }
 
+export interface MigrationApplyCommandOutputResult {
+  readonly migrationsApplied: number;
+  readonly markerHash: string;
+  readonly applied: readonly {
+    readonly dirName: string;
+    readonly operationsExecuted: number;
+  }[];
+  readonly summary: string;
+  readonly timings?: {
+    readonly total: number;
+  };
+}
+
+export interface MigrationVerifyCommandOutputResult {
+  readonly status: 'verified' | 'attested';
+  readonly migrationId?: string;
+}
+
+export function formatMigrationApplyCommandOutput(
+  result: MigrationApplyCommandOutputResult,
+  flags: GlobalFlags,
+): string {
+  if (flags.quiet) {
+    return '';
+  }
+
+  const lines: string[] = [];
+  const useColor = flags.color !== false;
+  const formatGreen = createColorFormatter(useColor, green);
+  const formatDimText = (text: string) => formatDim(useColor, text);
+
+  if (result.migrationsApplied === 0) {
+    lines.push(`${formatGreen('✔')} ${result.summary}`);
+    lines.push(formatDimText(`  marker: ${result.markerHash}`));
+    return lines.join('\n');
+  }
+
+  lines.push(`${formatGreen('✔')} ${result.summary}`);
+  lines.push('');
+
+  for (let i = 0; i < result.applied.length; i++) {
+    const migration = result.applied[i]!;
+    const isLast = i === result.applied.length - 1;
+    const treeChar = isLast ? '└' : '├';
+    lines.push(
+      `${formatDimText(treeChar)}─ ${migration.dirName} ${formatDimText(`[${migration.operationsExecuted} op(s)]`)}`,
+    );
+  }
+
+  lines.push('');
+  lines.push(formatDimText(`marker: ${result.markerHash}`));
+
+  if (isVerbose(flags, 1) && result.timings) {
+    lines.push('');
+    lines.push(formatDimText(`Total time: ${result.timings.total}ms`));
+  }
+
+  return lines.join('\n');
+}
+
+export function formatMigrationVerifyCommandOutput(
+  result: MigrationVerifyCommandOutputResult,
+  flags: GlobalFlags,
+): string {
+  if (flags.quiet) {
+    return '';
+  }
+
+  const lines: string[] = [];
+  const useColor = flags.color !== false;
+  const formatGreen = createColorFormatter(useColor, green);
+  const formatYellow = createColorFormatter(useColor, yellow);
+  const formatDimText = (text: string) => formatDim(useColor, text);
+
+  switch (result.status) {
+    case 'verified':
+      lines.push(`${formatGreen('✔')} Migration verified`);
+      lines.push(formatDimText(`  migrationId: ${result.migrationId}`));
+      break;
+    case 'attested':
+      lines.push(`${formatYellow('◉')} Draft migration attested`);
+      lines.push(formatDimText(`  migrationId: ${result.migrationId}`));
+      break;
+  }
+
+  return lines.join('\n');
+}
+
+interface MigrationShowResult {
+  readonly dirName: string;
+  readonly dirPath: string;
+  readonly from: string;
+  readonly to: string;
+  readonly migrationId: string | null;
+  readonly kind: string;
+  readonly createdAt: string;
+  readonly operations: readonly {
+    readonly id: string;
+    readonly label: string;
+    readonly operationClass: string;
+  }[];
+  readonly sql: readonly string[];
+  readonly summary: string;
+}
+
+export function formatMigrationShowOutput(result: MigrationShowResult, flags: GlobalFlags): string {
+  if (flags.quiet) {
+    return '';
+  }
+
+  const lines: string[] = [];
+  const prefix = createPrefix(flags);
+  const useColor = flags.color !== false;
+  const formatGreen = createColorFormatter(useColor, green);
+  const formatYellow = createColorFormatter(useColor, yellow);
+  const formatDimText = (text: string) => formatDim(useColor, text);
+
+  lines.push(`${prefix}${formatGreen('✔')} ${result.dirName}`);
+  lines.push(`${prefix}${formatDimText(`  kind: ${result.kind}`)}`);
+  lines.push(`${prefix}${formatDimText(`  from: ${result.from}`)}`);
+  lines.push(`${prefix}${formatDimText(`  to:   ${result.to}`)}`);
+  if (result.migrationId) {
+    lines.push(`${prefix}${formatDimText(`  migrationId: ${result.migrationId}`)}`);
+  } else {
+    lines.push(`${prefix}${formatYellow('  migrationId: (draft — not yet attested)')}`);
+  }
+  lines.push(`${prefix}${formatDimText(`  created: ${result.createdAt}`)}`);
+
+  lines.push(`${prefix}`);
+  lines.push(`${prefix}${result.operations.length} operation(s)`);
+
+  if (result.operations.length > 0) {
+    lines.push(`${prefix}${formatDimText('│')}`);
+    for (let i = 0; i < result.operations.length; i++) {
+      const op = result.operations[i]!;
+      const isLast = i === result.operations.length - 1;
+      const treeChar = isLast ? '└' : '├';
+      const opClassLabel =
+        op.operationClass === 'destructive'
+          ? formatYellow(`[${op.operationClass}]`)
+          : formatDimText(`[${op.operationClass}]`);
+      lines.push(`${prefix}${formatDimText(treeChar)}─ ${op.label} ${opClassLabel}`);
+    }
+
+    const hasDestructive = result.operations.some((op) => op.operationClass === 'destructive');
+    if (hasDestructive) {
+      lines.push(`${prefix}`);
+      lines.push(
+        `${prefix}${formatYellow('⚠')} This migration contains destructive operations that may cause data loss.`,
+      );
+    }
+  }
+
+  if (result.sql.length > 0) {
+    lines.push(`${prefix}`);
+    lines.push(`${prefix}${formatDimText('DDL preview')}`);
+    lines.push(`${prefix}`);
+    for (const statement of result.sql) {
+      const trimmed = statement.trim();
+      if (!trimmed) continue;
+      const line = trimmed.endsWith(';') ? trimmed : `${trimmed};`;
+      lines.push(`${prefix}${line}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+interface MigrationStatusEntry {
+  readonly dirName: string;
+  readonly to: string;
+  readonly migrationId: string | null;
+  readonly operationSummary: string;
+  readonly hasDestructive: boolean;
+  readonly status: 'applied' | 'pending' | 'unknown';
+}
+
+interface StatusDiagnostic {
+  readonly code: string;
+  readonly severity: 'warn' | 'info';
+  readonly message: string;
+  readonly hints: readonly string[];
+}
+
+interface MigrationStatusResult {
+  readonly mode: 'online' | 'offline';
+  readonly migrations: readonly MigrationStatusEntry[];
+  readonly markerHash?: string;
+  readonly leafHash: string;
+  readonly contractHash: string;
+  readonly summary: string;
+  readonly diagnostics?: readonly StatusDiagnostic[];
+}
+
+export function formatMigrationStatusOutput(
+  result: MigrationStatusResult,
+  flags: GlobalFlags,
+): string {
+  if (flags.quiet) {
+    return '';
+  }
+
+  const lines: string[] = [];
+  const prefix = createPrefix(flags);
+  const useColor = flags.color !== false;
+  const formatGreen = createColorFormatter(useColor, green);
+  const formatYellow = createColorFormatter(useColor, yellow);
+  const formatDimText = (text: string) => formatDim(useColor, text);
+  const formatCyan = createColorFormatter(useColor, cyan);
+
+  if (result.migrations.length === 0) {
+    lines.push(`${prefix}${formatDimText('No migrations found')}`);
+  } else {
+    lines.push(`${prefix}${formatDimText('∅ (empty)')}`);
+    lines.push(`${prefix}${formatDimText('│')}`);
+
+    for (let i = 0; i < result.migrations.length; i++) {
+      const entry = result.migrations[i]!;
+      const isLast = i === result.migrations.length - 1;
+      const treeChar = isLast ? '└' : '├';
+      const continueLine = isLast ? ' ' : '│';
+
+      let statusBadge = '';
+      if (entry.status === 'applied') {
+        statusBadge = formatGreen('  ✓ Applied');
+      } else if (entry.status === 'pending') {
+        statusBadge = formatYellow('  ⧗ Pending');
+      }
+
+      let marker = '';
+      if (result.mode === 'online') {
+        const isLastApplied =
+          entry.status === 'applied' &&
+          (i === result.migrations.length - 1 || result.migrations[i + 1]?.status !== 'applied');
+        if (isLastApplied) {
+          marker = formatCyan('  ◄ DB');
+        }
+      }
+      if (isLast && entry.to === result.contractHash) {
+        marker += `  ${formatCyan('◄ Contract')}`;
+      } else if (isLast && result.contractHash !== entry.to) {
+        marker += `  ${formatYellow('◄ Contract is ahead — run migration plan')}`;
+      }
+
+      lines.push(`${prefix}${formatDimText(treeChar)}─ ${entry.dirName}${statusBadge}${marker}`);
+
+      const opsSummary = entry.hasDestructive
+        ? formatYellow(entry.operationSummary)
+        : formatDimText(entry.operationSummary);
+      lines.push(`${prefix}${formatDimText(continueLine)}    ${opsSummary}`);
+
+      const hashDisplay = entry.to.length > 20 ? `${entry.to.slice(0, 20)}...` : entry.to;
+      lines.push(`${prefix}${formatDimText(continueLine)}    ${formatDimText(`→ ${hashDisplay}`)}`);
+
+      if (!isLast) {
+        lines.push(`${prefix}${formatDimText('│')}`);
+      }
+    }
+
+    lines.push(`${prefix}`);
+
+    if (result.mode === 'online') {
+      const hasUnknown = result.migrations.some((e) => e.status === 'unknown');
+      const pendingCount = result.migrations.filter((e) => e.status === 'pending').length;
+      if (hasUnknown) {
+        lines.push(`${prefix}${formatYellow('⚠')} ${result.summary}`);
+      } else if (pendingCount === 0) {
+        lines.push(`${prefix}${formatGreen('✔')} ${result.summary}`);
+      } else {
+        lines.push(`${prefix}${formatYellow('⧗')} ${result.summary}`);
+      }
+    } else {
+      lines.push(`${prefix}${result.summary}`);
+    }
+  }
+
+  const warnings = result.diagnostics?.filter((d) => d.severity === 'warn') ?? [];
+  if (warnings.length > 0) {
+    lines.push('');
+    for (const diag of warnings) {
+      lines.push(`${prefix}${formatYellow('⚠')} ${diag.message}`);
+      for (const hint of diag.hints) {
+        lines.push(`${prefix}  ${formatDimText(hint)}`);
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
 /**
- * Formats human-readable output for db init apply mode.
+ * Formats human-readable output for migration commands (db init, db update) in apply mode.
  */
-export function formatDbInitApplyOutput(result: DbInitResult, flags: GlobalFlags): string {
+export function formatMigrationApplyOutput(
+  result: MigrationCommandResult,
+  flags: GlobalFlags,
+): string {
   if (flags.quiet) {
     return '';
   }
@@ -906,11 +1239,15 @@ export function formatDbInitApplyOutput(result: DbInitResult, flags: GlobalFlags
   if (result.ok) {
     // Success summary
     const executed = result.execution?.operationsExecuted ?? 0;
-    lines.push(`${prefix}${formatGreen('✔')} Applied ${executed} operation(s)`);
+    if (executed === 0) {
+      lines.push(`${prefix}${formatGreen('✔')} Database already matches contract`);
+    } else {
+      lines.push(`${prefix}${formatGreen('✔')} Applied ${executed} operation(s)`);
+    }
 
     // Marker info
     if (result.marker) {
-      lines.push(`${prefix}${formatDimText(`  Marker written: ${result.marker.coreHash}`)}`);
+      lines.push(`${prefix}${formatDimText(`  Signature: ${result.marker.storageHash}`)}`);
       if (result.marker.profileHash) {
         lines.push(`${prefix}${formatDimText(`  Profile hash: ${result.marker.profileHash}`)}`);
       }
@@ -926,9 +1263,9 @@ export function formatDbInitApplyOutput(result: DbInitResult, flags: GlobalFlags
 }
 
 /**
- * Formats JSON output for db init command.
+ * Formats JSON output for migration commands (db init, db update).
  */
-export function formatDbInitJson(result: DbInitResult): string {
+export function formatMigrationJson(result: MigrationCommandResult): string {
   return JSON.stringify(result, null, 2);
 }
 
@@ -1241,6 +1578,7 @@ function getCommandDocsUrl(commandPath: string): string | undefined {
   const docsMap: Record<string, string> = {
     'contract emit': 'https://pris.ly/contract-emit',
     'db verify': 'https://pris.ly/db-verify',
+    'db update': 'https://pris.ly/db-update',
   };
   return docsMap[commandPath];
 }

package/src/utils/progress-adapter.ts

@@ -0,0 +1,86 @@
+import ora from 'ora';
+import type { ControlProgressEvent, OnControlProgress } from '../control-api/types';
+import type { GlobalFlags } from './global-flags';
+
+/**
+ * Options for creating a progress adapter.
+ */
+interface ProgressAdapterOptions {
+  /**
+   * Global flags that control progress output behavior (quiet, json, color).
+   */
+  readonly flags: GlobalFlags;
+}
+
+/**
+ * State for tracking active spans in the progress adapter.
+ */
+interface SpanState {
+  readonly spinner: ReturnType<typeof ora>;
+  readonly startTime: number;
+}
+
+/**
+ * Creates a progress adapter that converts control-api progress events
+ * into CLI spinner/progress output.
+ *
+ * The adapter:
+ * - Starts/succeeds spinners for top-level span boundaries
+ * - Prints per-operation lines for nested spans (e.g., migration operations under 'apply')
+ * - Respects quiet/json/non-TTY flags (no-op in those cases)
+ *
+ * @param options - Progress adapter configuration
+ * @returns An onProgress callback compatible with control-api operations
+ */
+export function createProgressAdapter(options: ProgressAdapterOptions): OnControlProgress {
+  const { flags } = options;
+
+  // Skip progress if quiet, JSON output, or non-TTY
+  const shouldShowProgress = !flags.quiet && flags.json !== 'object' && process.stdout.isTTY;
+
+  if (!shouldShowProgress) {
+    // Return a no-op callback
+    return () => {
+      // No-op
+    };
+  }
+
+  // Track active spans by spanId
+  const activeSpans = new Map<string, SpanState>();
+
+  return (event: ControlProgressEvent) => {
+    if (event.kind === 'spanStart') {
+      // Nested spans (with parentSpanId) are printed as lines, not spinners
+      if (event.parentSpanId) {
+        console.log(`  → ${event.label}...`);
+        return;
+      }
+
+      // Top-level spans get a spinner
+      const spinner = ora({
+        text: event.label,
+        color: flags.color !== false ? 'cyan' : false,
+      }).start();
+
+      activeSpans.set(event.spanId, {
+        spinner,
+        startTime: Date.now(),
+      });
+    } else if (event.kind === 'spanEnd') {
+      // Complete the spinner for this span (only top-level spans have spinners)
+      const spanState = activeSpans.get(event.spanId);
+      if (spanState) {
+        const elapsed = Date.now() - spanState.startTime;
+        if (event.outcome === 'error') {
+          spanState.spinner.fail(`${spanState.spinner.text} (failed)`);
+        } else if (event.outcome === 'skipped') {
+          spanState.spinner.info(`${spanState.spinner.text} (skipped)`);
+        } else {
+          spanState.spinner.succeed(`${spanState.spinner.text} (${elapsed}ms)`);
+        }
+        activeSpans.delete(event.spanId);
+      }
+      // Nested span ends are no-ops (could log completion if needed)
+    }
+  };
+}