@prisma-next/cli 0.5.0-dev.26 → 0.5.0-dev.28

package/src/commands/migration-plan.ts

@@ -3,9 +3,10 @@ import type { Contract } from '@prisma-next/contract/types';
 import { getEmittedArtifactPaths } from '@prisma-next/emitter';
 import {
   createControlStack,
+  hasOperationPreview,
   type MigrationPlanOperation,
+  type OperationPreview,
 } from '@prisma-next/framework-components/control';
-import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
 import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
 import { computeMigrationHash } from '@prisma-next/migration-tools/hash';
 import { deriveProvidedInvariants } from '@prisma-next/migration-tools/invariants';
@@ -21,7 +22,6 @@ import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { join, relative } from 'pathe';
 import { loadConfig } from '../config-loader';
-import { extractSqlDdl } from '../control-api/operations/extract-sql-ddl';
 import {
   type CliErrorConflict,
   CliStructuredError,
@@ -58,7 +58,7 @@ interface MigrationPlanOptions extends CommonCommandOptions {
 export interface MigrationPlanResult {
   readonly ok: boolean;
   readonly noOp: boolean;
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
   readonly dir?: string;
   readonly operations: readonly {
@@ -66,7 +66,12 @@ export interface MigrationPlanResult {
     readonly label: string;
     readonly operationClass: string;
   }[];
-  readonly sql?: readonly string[];
+  /**
+   * Family-agnostic textual preview of the migration plan operations.
+   * Replaces the previous `sql?: readonly string[]` field; consumers should
+   * read `result.preview?.statements`.
+   */
+  readonly preview?: OperationPreview;
   readonly summary: string;
   /**
    * When true, `migration.ts` was written but contains unfilled
@@ -160,7 +165,7 @@ async function executeMigrationPlanCommand(
 
   // Read existing migrations and determine "from" contract
   let fromContract: Contract | null = null;
-  let fromHash: string = EMPTY_CONTRACT_HASH;
+  let fromHash: string | null = null;
   let fromContractSourceDir: string | null = null;
 
   try {
@@ -252,7 +257,6 @@ async function executeMigrationPlanCommand(
   const baseMetadata: Omit<MigrationMetadata, 'migrationHash' | 'providedInvariants'> = {
     from: fromHash,
     to: toStorageHash,
-    kind: 'regular',
     fromContract,
     toContract: toContractJson,
     hints: {
@@ -366,7 +370,9 @@ async function executeMigrationPlanCommand(
       return ok(result);
     }
 
-    const sql = extractSqlDdl(plannedOps);
+    const preview = hasOperationPreview(familyInstance)
+      ? familyInstance.toOperationPreview(plannedOps)
+      : undefined;
     const result: MigrationPlanResult = {
       ok: true,
       noOp: false,
@@ -378,7 +384,7 @@ async function executeMigrationPlanCommand(
         label: op.label,
         operationClass: op.operationClass,
       })),
-      sql,
+      ...(preview !== undefined ? { preview } : {}),
       summary: `Planned ${plannedOps.length} operation(s)`,
       timings: { total: Date.now() - startTime },
     };
@@ -505,14 +511,17 @@ function formatMigrationPlanOutput(result: MigrationPlanResult, flags: GlobalFla
     `Next: review ${green_(result.dir ?? '<dir>')} if needed, then run ${green_('prisma-next migration apply')}.`,
   );
 
-  if (result.sql && result.sql.length > 0) {
+  if (result.preview && result.preview.statements.length > 0) {
+    // The non-empty length is already guaranteed by the surrounding check, so
+    // a plain `every` here is equivalent to the helper in formatters/migrations.ts.
+    const allSql = result.preview.statements.every((s) => s.language === 'sql');
     lines.push('');
-    lines.push(dim_('DDL preview'));
+    lines.push(dim_(allSql ? 'DDL preview' : 'Operation preview'));
     lines.push('');
-    for (const statement of result.sql) {
-      const trimmed = statement.trim();
+    for (const statement of result.preview.statements) {
+      const trimmed = statement.text.trim();
       if (!trimmed) continue;
-      const line = trimmed.endsWith(';') ? trimmed : `${trimmed};`;
+      const line = statement.language === 'sql' && !trimmed.endsWith(';') ? `${trimmed};` : trimmed;
       lines.push(line);
     }
   }

package/src/commands/migration-show.ts

@@ -1,4 +1,7 @@
-import type { MigrationPlanOperation } from '@prisma-next/framework-components/control';
+import type {
+  MigrationPlanOperation,
+  OperationPreview,
+} from '@prisma-next/framework-components/control';
 import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
 import { readMigrationPackage, readMigrationsDir } from '@prisma-next/migration-tools/io';
 import {
@@ -10,7 +13,7 @@ import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { relative, resolve } from 'pathe';
 import { loadConfig } from '../config-loader';
-import { extractOperationStatements } from '../control-api/operations/extract-operation-statements';
+import { createControlClient } from '../control-api/client';
 import {
   type CliStructuredError,
   errorRuntime,
@@ -37,17 +40,22 @@ export interface MigrationShowResult {
   readonly ok: true;
   readonly dirName: string;
   readonly dirPath: string;
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
   readonly migrationHash: string;
-  readonly kind: string;
   readonly createdAt: string;
   readonly operations: readonly {
     readonly id: string;
     readonly label: string;
     readonly operationClass: string;
   }[];
-  readonly sql: readonly string[];
+  /**
+   * Family-agnostic textual preview of the migration's operations. Replaces
+   * the previous string-array DDL field. Always defined; statements is empty
+   * for a no-op migration or a family that does not implement the
+   * `OperationPreviewCapable` capability.
+   */
+  readonly preview: OperationPreview;
   readonly summary: string;
 }
 
@@ -175,7 +183,18 @@ async function executeMigrationShowCommand(
   }
 
   const ops = pkg.ops as readonly MigrationPlanOperation[];
-  const sql = extractOperationStatements(config.family.familyId, ops) ?? [];
+
+  // `migration show` is an offline command; the control client is constructed
+  // purely to dispatch the family-specific `toOperationPreview` capability and
+  // is not connected to a database.
+  const client = createControlClient({
+    family: config.family,
+    target: config.target,
+    adapter: config.adapter,
+    ...(config.driver ? { driver: config.driver } : {}),
+    extensionPacks: config.extensionPacks ?? [],
+  });
+  const preview: OperationPreview = client.toOperationPreview(ops) ?? { statements: [] };
 
   const result: MigrationShowResult = {
     ok: true,
@@ -184,14 +203,13 @@ async function executeMigrationShowCommand(
     from: pkg.metadata.from,
     to: pkg.metadata.to,
     migrationHash: pkg.metadata.migrationHash,
-    kind: pkg.metadata.kind,
     createdAt: pkg.metadata.createdAt,
     operations: ops.map((op) => ({
       id: op.id,
       label: op.label,
       operationClass: op.operationClass,
     })),
-    sql,
+    preview,
     summary: `${ops.length} operation(s)`,
   };
   return ok(result);
@@ -202,7 +220,7 @@ export function createMigrationShowCommand(): Command {
   setCommandDescriptions(
     command,
     'Display migration package contents',
-    'Shows the operations, DDL preview, and metadata for a migration package.\n' +
+    'Shows the operations, statement preview, and metadata for a migration package.\n' +
       'Accepts a directory path, a hash prefix (git-style), or defaults to the\n' +
       'latest migration.',
   );

package/src/control-api/client.ts

@@ -6,6 +6,8 @@ import type {
   ControlFamilyInstance,
   ControlStack,
   CoreSchemaView,
+  MigrationPlanOperation,
+  OperationPreview,
   SignDatabaseResult,
   VerifyDatabaseResult,
   VerifyDatabaseSchemaResult,
@@ -13,8 +15,11 @@ import type {
 import {
   createControlStack,
   hasMigrations,
+  hasOperationPreview,
+  hasPslContractInfer,
   hasSchemaView,
 } from '@prisma-next/framework-components/control';
+import type { PslDocumentAst } from '@prisma-next/framework-components/psl-ast';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok } from '@prisma-next/utils/result';
 import { assertFrameworkComponentsCompatible } from '../utils/framework-components';
@@ -469,6 +474,22 @@ class ControlClientImpl implements ControlClient {
     return undefined;
   }
 
+  inferPslContract(schemaIR: unknown): PslDocumentAst | undefined {
+    this.init();
+    if (this.familyInstance && hasPslContractInfer(this.familyInstance)) {
+      return this.familyInstance.inferPslContract(schemaIR);
+    }
+    return undefined;
+  }
+
+  toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview | undefined {
+    this.init();
+    if (this.familyInstance && hasOperationPreview(this.familyInstance)) {
+      return this.familyInstance.toOperationPreview(operations);
+    }
+    return undefined;
+  }
+
   async emit(options: EmitOptions): Promise<EmitResult> {
     const { onProgress, contractConfig } = options;
 

package/src/control-api/operations/db-init.ts

@@ -8,10 +8,10 @@ import type {
   MigrationRunnerResult,
   TargetMigrationsCapability,
 } from '@prisma-next/framework-components/control';
+import { hasOperationPreview } from '@prisma-next/framework-components/control';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok } from '@prisma-next/utils/result';
 import type { DbInitResult, DbInitSuccess, OnControlProgress } from '../types';
-import { extractOperationStatements } from './extract-operation-statements';
 import { createOperationCallbacks, stripOperations } from './migration-helpers';
 
 /**
@@ -84,8 +84,9 @@ export async function executeDbInit<TFamilyId extends string, TTargetId extends
     schema: schemaIR,
     policy,
     // `db init` does not produce a `migration.ts`, so the from-hash on the
-    // resulting plan is never surfaced to authoring — pass empty string.
-    fromHash: '',
+    // resulting plan is never surfaced to authoring — pass null (the
+    // baseline encoding for `MigrationPlanner.plan({ fromHash })`).
+    fromHash: null,
     frameworkComponents,
   });
 
@@ -194,12 +195,14 @@ export async function executeDbInit<TFamilyId extends string, TTargetId extends
 
   // Plan mode - don't execute
   if (mode === 'plan') {
-    const planSql = extractOperationStatements(familyInstance.familyId, migrationPlan.operations);
+    const preview = hasOperationPreview(familyInstance)
+      ? familyInstance.toOperationPreview(migrationPlan.operations)
+      : undefined;
     const result: DbInitSuccess = {
       mode: 'plan',
       plan: {
         operations: stripOperations(migrationPlan.operations),
-        ...ifDefined('sql', planSql),
+        ...ifDefined('preview', preview),
       },
       destination: {
         storageHash: migrationPlan.destination.storageHash,

package/src/control-api/operations/db-update.ts

@@ -7,10 +7,10 @@ import type {
   MigrationRunnerResult,
   TargetMigrationsCapability,
 } from '@prisma-next/framework-components/control';
+import { hasOperationPreview } from '@prisma-next/framework-components/control';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok } from '@prisma-next/utils/result';
 import type { DbUpdateResult, DbUpdateSuccess, OnControlProgress } from '../types';
-import { extractOperationStatements } from './extract-operation-statements';
 import { createOperationCallbacks, stripOperations } from './migration-helpers';
 
 // F12: db update allows additive, widening, and destructive operations.
@@ -84,8 +84,9 @@ export async function executeDbUpdate<TFamilyId extends string, TTargetId extend
     schema: schemaIR,
     policy,
     // `db update` does not produce a `migration.ts`, so the from-hash on the
-    // resulting plan is never surfaced to authoring — pass empty string.
-    fromHash: '',
+    // resulting plan is never surfaced to authoring — pass null (the
+    // baseline encoding for `MigrationPlanner.plan({ fromHash })`).
+    fromHash: null,
     frameworkComponents,
   });
   if (plannerResult.kind === 'failure') {
@@ -113,12 +114,14 @@ export async function executeDbUpdate<TFamilyId extends string, TTargetId extend
   const migrationPlan = plannerResult.plan;
 
   if (mode === 'plan') {
-    const planSql = extractOperationStatements(familyInstance.familyId, migrationPlan.operations);
+    const preview = hasOperationPreview(familyInstance)
+      ? familyInstance.toOperationPreview(migrationPlan.operations)
+      : undefined;
     const result: DbUpdateSuccess = {
       mode: 'plan',
       plan: {
         operations: stripOperations(migrationPlan.operations),
-        ...(planSql !== undefined ? { sql: planSql } : {}),
+        ...ifDefined('preview', preview),
       },
       destination: {
         storageHash: migrationPlan.destination.storageHash,

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

@@ -79,15 +79,19 @@ export async function executeMigrationApply<TFamilyId extends string, TTargetId
 
   const firstMigration = pendingMigrations[0]!;
   const lastMigration = pendingMigrations[pendingMigrations.length - 1]!;
-  if (firstMigration.from !== originHash || lastMigration.to !== destinationHash) {
+  // Manifest `from` is `string | null` (null = baseline). The live-marker
+  // layer encodes "no prior state" as EMPTY_CONTRACT_HASH; bridge here so the
+  // string comparisons below work uniformly.
+  const firstFromMarker = firstMigration.from ?? EMPTY_CONTRACT_HASH;
+  if (firstFromMarker !== originHash || lastMigration.to !== destinationHash) {
     return notOk({
       code: 'MIGRATION_PATH_NOT_FOUND' as const,
       summary: 'Migration apply path does not match requested origin and destination',
-      why: `Path resolved as ${firstMigration.from} -> ${lastMigration.to}, but requested ${originHash} -> ${destinationHash}`,
+      why: `Path resolved as ${firstFromMarker} -> ${lastMigration.to}, but requested ${originHash} -> ${destinationHash}`,
       meta: {
         originHash,
         destinationHash,
-        pathOrigin: firstMigration.from,
+        pathOrigin: firstFromMarker,
         pathDestination: lastMigration.to,
       },
     });
@@ -96,18 +100,19 @@ export async function executeMigrationApply<TFamilyId extends string, TTargetId
   for (let i = 1; i < pendingMigrations.length; i++) {
     const previous = pendingMigrations[i - 1]!;
     const current = pendingMigrations[i]!;
-    if (previous.to !== current.from) {
+    const currentFromMarker = current.from ?? EMPTY_CONTRACT_HASH;
+    if (previous.to !== currentFromMarker) {
       return notOk({
         code: 'MIGRATION_PATH_NOT_FOUND' as const,
         summary: 'Migration apply path contains a discontinuity between adjacent migrations',
-        why: `Migration "${previous.dirName}" ends at ${previous.to}, but next migration "${current.dirName}" starts at ${current.from}`,
+        why: `Migration "${previous.dirName}" ends at ${previous.to}, but next migration "${current.dirName}" starts at ${currentFromMarker}`,
         meta: {
           originHash,
           destinationHash,
           previousDirName: previous.dirName,
           previousTo: previous.to,
           currentDirName: current.dirName,
-          currentFrom: current.from,
+          currentFrom: currentFromMarker,
           discontinuityIndex: i,
         },
       });
@@ -135,11 +140,11 @@ export async function executeMigrationApply<TFamilyId extends string, TTargetId
       allowedOperationClasses: ['additive', 'widening', 'destructive', 'data'] as const,
     };
 
-    // EMPTY_CONTRACT_HASH means "no prior state" — the runner expects origin: null
-    // for a fresh database (no marker present).
+    // Manifest `from === null` means "no prior state" — the runner expects
+    // `origin: null` for a fresh database (no marker present).
     const plan = {
       targetId,
-      origin: migration.from === EMPTY_CONTRACT_HASH ? null : { storageHash: migration.from },
+      origin: migration.from === null ? null : { storageHash: migration.from },
       destination: { storageHash: migration.to },
       operations,
     };

package/src/control-api/types.ts

@@ -12,10 +12,12 @@ import type {
   CoreSchemaView,
   MigrationPlannerConflict,
   MigrationPlanOperation,
+  OperationPreview,
   SignDatabaseResult,
   VerifyDatabaseResult,
   VerifyDatabaseSchemaResult,
 } from '@prisma-next/framework-components/control';
+import type { PslDocumentAst } from '@prisma-next/framework-components/psl-ast';
 import type { Result } from '@prisma-next/utils/result';
 
 // ============================================================================
@@ -283,7 +285,14 @@ export interface DbInitSuccess {
       readonly label: string;
       readonly operationClass: string;
     }>;
-    readonly sql?: ReadonlyArray<string>;
+    /**
+     * Family-agnostic textual preview of the planned operations, e.g.
+     * `language: 'sql'` for SQL families and `language: 'mongodb-shell'`
+     * for the Mongo family. Replaces the previous `sql?: readonly string[]`
+     * field; consumers that previously read `plan.sql` should read
+     * `plan.preview?.statements.map((s) => s.text)`.
+     */
+    readonly preview?: OperationPreview;
   };
   readonly destination: {
     readonly storageHash: string;
@@ -341,7 +350,14 @@ export interface DbUpdateSuccess {
       readonly label: string;
       readonly operationClass: string;
     }>;
-    readonly sql?: ReadonlyArray<string>;
+    /**
+     * Family-agnostic textual preview of the planned operations, e.g.
+     * `language: 'sql'` for SQL families and `language: 'mongodb-shell'`
+     * for the Mongo family. Replaces the previous `sql?: readonly string[]`
+     * field; consumers that previously read `plan.sql` should read
+     * `plan.preview?.statements.map((s) => s.text)`.
+     */
+    readonly preview?: OperationPreview;
   };
   readonly destination: {
     readonly storageHash: string;
@@ -432,7 +448,7 @@ export type EmitResult = Result<EmitSuccess, EmitFailure>;
  */
 export interface MigrationApplyStep {
   readonly dirName: string;
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
   readonly toContract: Contract;
   readonly operations: readonly MigrationPlanOperation[];
@@ -471,7 +487,7 @@ export interface MigrationApplyOptions {
  */
 export interface MigrationApplyAppliedEntry {
   readonly dirName: string;
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
   readonly operationsExecuted: number;
 }
@@ -691,6 +707,25 @@ export interface ControlClient {
    */
   toSchemaView(schemaIR: unknown): CoreSchemaView | undefined;
 
+  /**
+   * Infers a PSL contract AST from an introspected schema IR.
+   * Delegates to the family instance's inferPslContract method.
+   *
+   * @param schemaIR - The schema IR from introspect()
+   * @returns PslDocumentAst if the family supports the capability, undefined otherwise
+   */
+  inferPslContract(schemaIR: unknown): PslDocumentAst | undefined;
+
+  /**
+   * Renders a textual preview of a migration plan's operations for the CLI's
+   * "DDL preview" output. Delegates to the family instance's
+   * `toOperationPreview` method.
+   *
+   * @param operations - The migration plan operations to render
+   * @returns OperationPreview if the family supports the capability, undefined otherwise
+   */
+  toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview | undefined;
+
   /**
    * Emits the contract to JSON and TypeScript declarations.
    * This is an offline operation that does NOT require a database connection.

package/src/utils/formatters/migrations.ts

@@ -1,8 +1,41 @@
+import type { OperationPreview } from '@prisma-next/framework-components/control';
 import { green, yellow } from 'colorette';
 
 import type { GlobalFlags } from '../global-flags';
 import { createColorFormatter, formatDim, isVerbose } from './helpers';
 
+/**
+ * Render a single statement of an `OperationPreview` for the human-readable
+ * preview block. SQL statements get a trailing `;` if missing — matches the
+ * legacy `string[]`-based renderer byte-for-byte (per spec OQ-4). Other
+ * languages (`'mongodb-shell'`) render verbatim.
+ */
+function renderPreviewStatement(text: string, language: string): string | undefined {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  if (language === 'sql') {
+    return trimmed.endsWith(';') ? trimmed : `${trimmed};`;
+  }
+  return trimmed;
+}
+
+/**
+ * Choose the header label for a preview block. SQL-only previews keep the
+ * legacy `DDL preview` label (preserves CLI byte-identity for SQL targets per
+ * spec OQ-4); previews from any other family — or a mix that includes any
+ * non-SQL language — use the family-agnostic `Operation preview` label.
+ *
+ * An empty `statements` array deliberately renders as `Operation preview`
+ * rather than `DDL preview`: `Array.prototype.every` is vacuously true for
+ * empty arrays, but we have no evidence the preview is SQL-only when no
+ * statements are present, so the family-agnostic label is the safer default.
+ */
+export function previewBlockHeader(preview: OperationPreview): string {
+  const allSql =
+    preview.statements.length > 0 && preview.statements.every((s) => s.language === 'sql');
+  return allSql ? 'DDL preview' : 'Operation preview';
+}
+
 // ============================================================================
 // Migration Command Output Formatters (shared by db init and db update)
 // ============================================================================
@@ -24,7 +57,12 @@ export interface MigrationCommandResult {
       readonly label: string;
       readonly operationClass: string;
     }[];
-    readonly sql?: readonly string[];
+    /**
+     * Family-agnostic textual preview of the planned operations. Replaces the
+     * previous `sql?: readonly string[]`. Consumers should read
+     * `plan.preview?.statements`.
+     */
+    readonly preview?: OperationPreview;
   };
   readonly execution?: {
     readonly operationsPlanned: number;
@@ -92,20 +130,20 @@ export function formatMigrationPlanOutput(
     lines.push(`${formatDimText(`Destination hash: ${result.plan.destination.storageHash}`)}`);
   }
 
-  // SQL DDL preview (SQL family only)
-  const planSql = result.plan?.sql;
-  if (planSql) {
+  // Statement preview (any family that implements OperationPreviewCapable)
+  const preview = result.plan?.preview;
+  if (preview) {
     lines.push('');
-    lines.push(`${formatDimText('DDL preview')}`);
-    if (planSql.length === 0) {
-      lines.push(`${formatDimText('No DDL operations.')}`);
+    lines.push(`${formatDimText(previewBlockHeader(preview))}`);
+    if (preview.statements.length === 0) {
+      lines.push(`${formatDimText('No operations.')}`);
     } else {
       lines.push('');
-      for (const statement of planSql) {
-        const trimmed = statement.trim();
-        if (!trimmed) continue;
-        const line = trimmed.endsWith(';') ? trimmed : `${trimmed};`;
-        lines.push(`${line}`);
+      for (const statement of preview.statements) {
+        const rendered = renderPreviewStatement(statement.text, statement.language);
+        if (rendered) {
+          lines.push(rendered);
+        }
       }
     }
   }
@@ -181,17 +219,16 @@ export function formatMigrationApplyCommandOutput(
 interface MigrationShowResult {
   readonly dirName: string;
   readonly dirPath: string;
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
   readonly migrationHash: string;
-  readonly kind: string;
   readonly createdAt: string;
   readonly operations: readonly {
     readonly id: string;
     readonly label: string;
     readonly operationClass: string;
   }[];
-  readonly sql: readonly string[];
+  readonly preview: OperationPreview;
   readonly summary: string;
 }
 
@@ -208,8 +245,7 @@ export function formatMigrationShowOutput(result: MigrationShowResult, flags: Gl
   const formatDimText = (text: string) => formatDim(useColor, text);
 
   lines.push(`${formatGreen('✔')} ${result.dirName}`);
-  lines.push(`${formatDimText(`  kind: ${result.kind}`)}`);
-  lines.push(`${formatDimText(`  from: ${result.from}`)}`);
+  lines.push(`${formatDimText(`  from: ${result.from ?? '(baseline)'}`)}`);
   lines.push(`${formatDimText(`  to:   ${result.to}`)}`);
   lines.push(`${formatDimText(`  migrationHash: ${result.migrationHash}`)}`);
   lines.push(`${formatDimText(`  created: ${result.createdAt}`)}`);
@@ -239,15 +275,15 @@ export function formatMigrationShowOutput(result: MigrationShowResult, flags: Gl
     }
   }
 
-  if (result.sql.length > 0) {
+  if (result.preview.statements.length > 0) {
     lines.push('');
-    lines.push(`${formatDimText('DDL preview')}`);
+    lines.push(`${formatDimText(previewBlockHeader(result.preview))}`);
     lines.push('');
-    for (const statement of result.sql) {
-      const trimmed = statement.trim();
-      if (!trimmed) continue;
-      const line = trimmed.endsWith(';') ? trimmed : `${trimmed};`;
-      lines.push(`${line}`);
+    for (const statement of result.preview.statements) {
+      const rendered = renderPreviewStatement(statement.text, statement.language);
+      if (rendered) {
+        lines.push(rendered);
+      }
     }
   }