@prisma-next/cli 0.3.0-dev.17 → 0.3.0-dev.18

package/src/commands/db-verify.ts

@@ -1,32 +1,33 @@
 import { readFile } from 'node:fs/promises';
 import { relative, resolve } from 'node:path';
-import type { ContractIR } from '@prisma-next/contract/ir';
+import type { VerifyDatabaseResult } from '@prisma-next/core-control-plane/types';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { Command } from 'commander';
+import { loadConfig } from '../config-loader';
+import { createControlClient } from '../control-api/client';
 import {
+  CliStructuredError,
+  errorContractValidationFailed,
   errorDatabaseConnectionRequired,
   errorDriverRequired,
   errorFileNotFound,
   errorHashMismatch,
+  errorJsonFormatNotSupported,
   errorMarkerMissing,
   errorRuntime,
   errorTargetMismatch,
   errorUnexpected,
-} from '@prisma-next/core-control-plane/errors';
-import type { VerifyDatabaseResult } from '@prisma-next/core-control-plane/types';
-import { createControlPlaneStack } from '@prisma-next/core-control-plane/types';
-import { Command } from 'commander';
-import { loadConfig } from '../config-loader';
-import { performAction } from '../utils/action';
+} from '../utils/cli-errors';
 import { setCommandDescriptions } from '../utils/command-helpers';
-import { assertContractRequirementsSatisfied } from '../utils/framework-components';
-import { parseGlobalFlags } from '../utils/global-flags';
+import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
 import {
   formatCommandHelp,
   formatStyledHeader,
   formatVerifyJson,
   formatVerifyOutput,
 } from '../utils/output';
+import { createProgressAdapter } from '../utils/progress-adapter';
 import { handleResult } from '../utils/result-handler';
-import { withSpinner } from '../utils/spinner';
 
 interface DbVerifyOptions {
   readonly db?: string;
@@ -43,6 +44,161 @@ interface DbVerifyOptions {
   readonly 'no-color'?: boolean;
 }
 
+/**
+ * Maps a VerifyDatabaseResult failure to a CliStructuredError.
+ */
+function mapVerifyFailure(verifyResult: VerifyDatabaseResult): CliStructuredError {
+  if (!verifyResult.ok && verifyResult.code) {
+    if (verifyResult.code === 'PN-RTM-3001') {
+      return errorMarkerMissing();
+    }
+    if (verifyResult.code === 'PN-RTM-3002') {
+      return errorHashMismatch({
+        expected: verifyResult.contract.coreHash,
+        ...(verifyResult.marker?.coreHash ? { actual: verifyResult.marker.coreHash } : {}),
+      });
+    }
+    if (verifyResult.code === 'PN-RTM-3003') {
+      return errorTargetMismatch(
+        verifyResult.target.expected,
+        verifyResult.target.actual ?? 'unknown',
+      );
+    }
+    // Unknown code - fall through to runtime error
+  }
+  return errorRuntime(verifyResult.summary);
+}
+
+/**
+ * Executes the db verify command and returns a structured Result.
+ */
+async function executeDbVerifyCommand(
+  options: DbVerifyOptions,
+  flags: GlobalFlags,
+): Promise<Result<VerifyDatabaseResult, CliStructuredError>> {
+  // Load config
+  const config = await loadConfig(options.config);
+  const configPath = options.config
+    ? relative(process.cwd(), resolve(options.config))
+    : 'prisma-next.config.ts';
+  const contractPathAbsolute = config.contract?.output
+    ? resolve(config.contract.output)
+    : resolve('src/prisma/contract.json');
+  const contractPath = relative(process.cwd(), contractPathAbsolute);
+
+  // Output header
+  if (flags.json !== 'object' && !flags.quiet) {
+    const details: Array<{ label: string; value: string }> = [
+      { label: 'config', value: configPath },
+      { label: 'contract', value: contractPath },
+    ];
+    if (options.db) {
+      details.push({ label: 'database', value: options.db });
+    }
+    const header = formatStyledHeader({
+      command: 'db verify',
+      description: 'Check whether the database has been signed with your contract',
+      url: 'https://pris.ly/db-verify',
+      details,
+      flags,
+    });
+    console.log(header);
+  }
+
+  // Load contract file
+  let contractJsonContent: string;
+  try {
+    contractJsonContent = await readFile(contractPathAbsolute, 'utf-8');
+  } catch (error) {
+    if (error instanceof Error && (error as { code?: string }).code === 'ENOENT') {
+      return notOk(
+        errorFileNotFound(contractPathAbsolute, {
+          why: `Contract file not found at ${contractPathAbsolute}`,
+          fix: `Run \`prisma-next contract emit\` to generate ${contractPath}, or update \`config.contract.output\` in ${configPath}`,
+        }),
+      );
+    }
+    return notOk(
+      errorUnexpected(error instanceof Error ? error.message : String(error), {
+        why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+    );
+  }
+
+  let contractJson: Record<string, unknown>;
+  try {
+    contractJson = JSON.parse(contractJsonContent) as Record<string, unknown>;
+  } catch (error) {
+    return notOk(
+      errorContractValidationFailed(
+        `Contract JSON is invalid: ${error instanceof Error ? error.message : String(error)}`,
+        { where: { path: contractPathAbsolute } },
+      ),
+    );
+  }
+
+  // Resolve database connection (--db flag or config.db.connection)
+  const dbConnection = options.db ?? config.db?.connection;
+  if (!dbConnection) {
+    return notOk(
+      errorDatabaseConnectionRequired({
+        why: `Database connection is required for db verify (set db.connection in ${configPath}, or pass --db <url>)`,
+      }),
+    );
+  }
+
+  // Check for driver
+  if (!config.driver) {
+    return notOk(errorDriverRequired({ why: 'Config.driver is required for db verify' }));
+  }
+
+  // Create control client
+  const client = createControlClient({
+    family: config.family,
+    target: config.target,
+    adapter: config.adapter,
+    driver: config.driver,
+    extensionPacks: config.extensionPacks ?? [],
+  });
+
+  // Create progress adapter
+  const onProgress = createProgressAdapter({ flags });
+
+  try {
+    const verifyResult = await client.verify({
+      contractIR: contractJson,
+      connection: dbConnection,
+      onProgress,
+    });
+
+    // Add blank line after all async operations if spinners were shown
+    if (!flags.quiet && flags.json !== 'object' && process.stdout.isTTY) {
+      console.log('');
+    }
+
+    // If verification failed, map to CLI structured error
+    if (!verifyResult.ok) {
+      return notOk(mapVerifyFailure(verifyResult));
+    }
+
+    return ok(verifyResult);
+  } catch (error) {
+    // Driver already throws CliStructuredError for connection failures
+    if (error instanceof CliStructuredError) {
+      return notOk(error);
+    }
+
+    // Wrap unexpected errors
+    return notOk(
+      errorUnexpected(error instanceof Error ? error.message : String(error), {
+        why: `Unexpected error during db verify: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+    );
+  } finally {
+    await client.close();
+  }
+}
+
 export function createDbVerifyCommand(): Command {
   const command = new Command('verify');
   setCommandDescriptions(
@@ -60,7 +216,7 @@ export function createDbVerifyCommand(): Command {
     })
     .option('--db <url>', 'Database connection string')
     .option('--config <path>', 'Path to prisma-next.config.ts')
-    .option('--json [format]', 'Output as JSON (object or ndjson)', false)
+    .option('--json [format]', 'Output as JSON (object)', false)
     .option('-q, --quiet', 'Quiet mode: errors only')
     .option('-v, --verbose', 'Verbose output: debug info, timings')
     .option('-vv, --trace', 'Trace output: deep internals, stack traces')
@@ -70,151 +226,25 @@ export function createDbVerifyCommand(): Command {
     .action(async (options: DbVerifyOptions) => {
       const flags = parseGlobalFlags(options);
 
-      const result = await performAction(async () => {
-        // Load config (file I/O)
-        const config = await loadConfig(options.config);
-        // Normalize config path for display (match contract path format - no ./ prefix)
-        const configPath = options.config
-          ? relative(process.cwd(), resolve(options.config))
-          : 'prisma-next.config.ts';
-        const contractPathAbsolute = config.contract?.output
-          ? resolve(config.contract.output)
-          : resolve('src/prisma/contract.json');
-        // Convert to relative path for display
-        const contractPath = relative(process.cwd(), contractPathAbsolute);
-
-        // Output header (only for human-readable output)
-        if (flags.json !== 'object' && !flags.quiet) {
-          const details: Array<{ label: string; value: string }> = [
-            { label: 'config', value: configPath },
-            { label: 'contract', value: contractPath },
-          ];
-          if (options.db) {
-            details.push({ label: 'database', value: options.db });
-          }
-          const header = formatStyledHeader({
+      // Validate JSON format option
+      if (flags.json === 'ndjson') {
+        const result = notOk(
+          errorJsonFormatNotSupported({
             command: 'db verify',
-            description: 'Check whether the database has been signed with your contract',
-            url: 'https://pris.ly/db-verify',
-            details,
-            flags,
-          });
-          console.log(header);
-        }
-
-        // Load contract file (file I/O)
-        let contractJsonContent: string;
-        try {
-          contractJsonContent = await readFile(contractPathAbsolute, 'utf-8');
-        } catch (error) {
-          if (error instanceof Error && (error as { code?: string }).code === 'ENOENT') {
-            throw errorFileNotFound(contractPathAbsolute, {
-              why: `Contract file not found at ${contractPathAbsolute}`,
-            });
-          }
-          throw errorUnexpected(error instanceof Error ? error.message : String(error), {
-            why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}`,
-          });
-        }
-        const contractJson = JSON.parse(contractJsonContent) as Record<string, unknown>;
-
-        // Resolve database connection (--db flag or config.db.connection)
-        const dbConnection = options.db ?? config.db?.connection;
-        if (!dbConnection) {
-          throw errorDatabaseConnectionRequired();
-        }
+            format: 'ndjson',
+            supportedFormats: ['object'],
+          }),
+        );
+        const exitCode = handleResult(result, flags);
+        process.exit(exitCode);
+      }
 
-        // Check for driver
-        if (!config.driver) {
-          throw errorDriverRequired();
-        }
-
-        // Store driver descriptor after null check
-        const driverDescriptor = config.driver;
-
-        const driver = await withSpinner(() => driverDescriptor.create(dbConnection), {
-          message: 'Connecting to database...',
-          flags,
-        });
-
-        try {
-          // Create family instance
-          const stack = createControlPlaneStack({
-            target: config.target,
-            adapter: config.adapter,
-            driver: driverDescriptor,
-            extensionPacks: config.extensionPacks,
-          });
-          const familyInstance = config.family.create(stack);
-
-          // Validate contract using instance validator
-          const contractIR = familyInstance.validateContractIR(contractJson) as ContractIR;
-          assertContractRequirementsSatisfied({ contract: contractIR, stack });
-
-          // Call family instance verify method
-          let verifyResult: VerifyDatabaseResult;
-          try {
-            verifyResult = await withSpinner(
-              () =>
-                familyInstance.verify({
-                  driver,
-                  contractIR,
-                  expectedTargetId: config.target.targetId,
-                  contractPath: contractPathAbsolute,
-                  configPath,
-                }),
-              {
-                message: 'Verifying database schema...',
-                flags,
-              },
-            );
-          } catch (error) {
-            // Wrap errors from verify() in structured error
-            throw errorUnexpected(error instanceof Error ? error.message : String(error), {
-              why: `Failed to verify database: ${error instanceof Error ? error.message : String(error)}`,
-            });
-          }
-
-          // If verification failed, throw structured error
-          if (!verifyResult.ok && verifyResult.code) {
-            if (verifyResult.code === 'PN-RTM-3001') {
-              throw errorMarkerMissing();
-            }
-            if (verifyResult.code === 'PN-RTM-3002') {
-              throw errorHashMismatch({
-                expected: verifyResult.contract.coreHash,
-                ...(verifyResult.marker?.coreHash ? { actual: verifyResult.marker.coreHash } : {}),
-              });
-            }
-            if (verifyResult.code === 'PN-RTM-3003') {
-              throw errorTargetMismatch(
-                verifyResult.target.expected,
-                verifyResult.target.actual ?? 'unknown',
-              );
-            }
-            throw errorRuntime(verifyResult.summary);
-          }
-
-          // Add blank line after all async operations if spinners were shown
-          if (!flags.quiet && flags.json !== 'object' && process.stdout.isTTY) {
-            console.log('');
-          }
-
-          return verifyResult;
-        } finally {
-          // Ensure driver connection is closed
-          await driver.close();
-        }
-      });
+      const result = await executeDbVerifyCommand(options, flags);
 
-      // Handle result - formats output and returns exit code
       const exitCode = handleResult(result, flags, (verifyResult) => {
-        // Output based on flags
         if (flags.json === 'object') {
-          // JSON output to stdout
           console.log(formatVerifyJson(verifyResult));
         } else {
-          // Human-readable output to stdout
           const output = formatVerifyOutput(verifyResult, flags);
           if (output) {
             console.log(output);

package/src/control-api/client.ts

@@ -1,4 +1,5 @@
 import type { TargetBoundComponentDescriptor } from '@prisma-next/contract/framework-components';
+import type { CoreSchemaView } from '@prisma-next/core-control-plane/schema-view';
 import { createControlPlaneStack } from '@prisma-next/core-control-plane/stack';
 import type {
   ControlDriverInstance,
@@ -148,51 +149,220 @@ class ControlClientImpl implements ControlClient {
   }
 
   async verify(options: VerifyOptions): Promise<VerifyDatabaseResult> {
+    const { onProgress } = options;
+
+    // Connect with progress span if connection provided
+    if (options.connection !== undefined) {
+      onProgress?.({
+        action: 'verify',
+        kind: 'spanStart',
+        spanId: 'connect',
+        label: 'Connecting to database...',
+      });
+      try {
+        await this.connect(options.connection);
+        onProgress?.({
+          action: 'verify',
+          kind: 'spanEnd',
+          spanId: 'connect',
+          outcome: 'ok',
+        });
+      } catch (error) {
+        onProgress?.({
+          action: 'verify',
+          kind: 'spanEnd',
+          spanId: 'connect',
+          outcome: 'error',
+        });
+        throw error;
+      }
+    }
+
     const { driver, familyInstance } = await this.ensureConnected();
 
     // Validate contract using family instance
     const contractIR = familyInstance.validateContractIR(options.contractIR);
 
-    // Delegate to family instance verify method
-    // Note: We pass empty strings for contractPath/configPath since the programmatic
-    // API doesn't deal with file paths. The family instance accepts these as optional
-    // metadata for error reporting.
-    return familyInstance.verify({
-      driver,
-      contractIR,
-      expectedTargetId: this.options.target.targetId,
-      contractPath: '',
+    // Emit verify span
+    onProgress?.({
+      action: 'verify',
+      kind: 'spanStart',
+      spanId: 'verify',
+      label: 'Verifying contract marker...',
     });
+
+    try {
+      // Delegate to family instance verify method
+      // Note: We pass empty strings for contractPath/configPath since the programmatic
+      // API doesn't deal with file paths. The family instance accepts these as optional
+      // metadata for error reporting.
+      const result = await familyInstance.verify({
+        driver,
+        contractIR,
+        expectedTargetId: this.options.target.targetId,
+        contractPath: '',
+      });
+
+      onProgress?.({
+        action: 'verify',
+        kind: 'spanEnd',
+        spanId: 'verify',
+        outcome: result.ok ? 'ok' : 'error',
+      });
+
+      return result;
+    } catch (error) {
+      onProgress?.({
+        action: 'verify',
+        kind: 'spanEnd',
+        spanId: 'verify',
+        outcome: 'error',
+      });
+      throw error;
+    }
   }
 
   async schemaVerify(options: SchemaVerifyOptions): Promise<VerifyDatabaseSchemaResult> {
+    const { onProgress } = options;
+
+    // Connect with progress span if connection provided
+    if (options.connection !== undefined) {
+      onProgress?.({
+        action: 'schemaVerify',
+        kind: 'spanStart',
+        spanId: 'connect',
+        label: 'Connecting to database...',
+      });
+      try {
+        await this.connect(options.connection);
+        onProgress?.({
+          action: 'schemaVerify',
+          kind: 'spanEnd',
+          spanId: 'connect',
+          outcome: 'ok',
+        });
+      } catch (error) {
+        onProgress?.({
+          action: 'schemaVerify',
+          kind: 'spanEnd',
+          spanId: 'connect',
+          outcome: 'error',
+        });
+        throw error;
+      }
+    }
+
     const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
 
     // Validate contract using family instance
     const contractIR = familyInstance.validateContractIR(options.contractIR);
 
-    // Delegate to family instance schemaVerify method
-    return familyInstance.schemaVerify({
-      driver,
-      contractIR,
-      strict: options.strict ?? false,
-      contractPath: '',
-      frameworkComponents,
+    // Emit schemaVerify span
+    onProgress?.({
+      action: 'schemaVerify',
+      kind: 'spanStart',
+      spanId: 'schemaVerify',
+      label: 'Verifying database schema...',
     });
+
+    try {
+      // Delegate to family instance schemaVerify method
+      const result = await familyInstance.schemaVerify({
+        driver,
+        contractIR,
+        strict: options.strict ?? false,
+        contractPath: '',
+        frameworkComponents,
+      });
+
+      onProgress?.({
+        action: 'schemaVerify',
+        kind: 'spanEnd',
+        spanId: 'schemaVerify',
+        outcome: result.ok ? 'ok' : 'error',
+      });
+
+      return result;
+    } catch (error) {
+      onProgress?.({
+        action: 'schemaVerify',
+        kind: 'spanEnd',
+        spanId: 'schemaVerify',
+        outcome: 'error',
+      });
+      throw error;
+    }
   }
 
   async sign(options: SignOptions): Promise<SignDatabaseResult> {
+    const { onProgress } = options;
+
+    // Connect with progress span if connection provided
+    if (options.connection !== undefined) {
+      onProgress?.({
+        action: 'sign',
+        kind: 'spanStart',
+        spanId: 'connect',
+        label: 'Connecting to database...',
+      });
+      try {
+        await this.connect(options.connection);
+        onProgress?.({
+          action: 'sign',
+          kind: 'spanEnd',
+          spanId: 'connect',
+          outcome: 'ok',
+        });
+      } catch (error) {
+        onProgress?.({
+          action: 'sign',
+          kind: 'spanEnd',
+          spanId: 'connect',
+          outcome: 'error',
+        });
+        throw error;
+      }
+    }
+
     const { driver, familyInstance } = await this.ensureConnected();
 
     // Validate contract using family instance
     const contractIR = familyInstance.validateContractIR(options.contractIR);
 
-    // Delegate to family instance sign method
-    return familyInstance.sign({
-      driver,
-      contractIR,
-      contractPath: '',
+    // Emit sign span
+    onProgress?.({
+      action: 'sign',
+      kind: 'spanStart',
+      spanId: 'sign',
+      label: 'Signing database...',
     });
+
+    try {
+      // Delegate to family instance sign method
+      const result = await familyInstance.sign({
+        driver,
+        contractIR,
+        contractPath: options.contractPath ?? '',
+        ...(options.configPath ? { configPath: options.configPath } : {}),
+      });
+
+      onProgress?.({
+        action: 'sign',
+        kind: 'spanEnd',
+        spanId: 'sign',
+        outcome: 'ok',
+      });
+
+      return result;
+    } catch (error) {
+      onProgress?.({
+        action: 'sign',
+        kind: 'spanEnd',
+        spanId: 'sign',
+        outcome: 'error',
+      });
+      throw error;
+    }
   }
 
   async dbInit(options: DbInitOptions): Promise<DbInitResult> {
@@ -248,12 +418,76 @@ class ControlClientImpl implements ControlClient {
   }
 
   async introspect(options?: IntrospectOptions): Promise<unknown> {
+    const onProgress = options?.onProgress;
+
+    // Connect with progress span if connection provided
+    if (options?.connection !== undefined) {
+      onProgress?.({
+        action: 'introspect',
+        kind: 'spanStart',
+        spanId: 'connect',
+        label: 'Connecting to database...',
+      });
+      try {
+        await this.connect(options.connection);
+        onProgress?.({
+          action: 'introspect',
+          kind: 'spanEnd',
+          spanId: 'connect',
+          outcome: 'ok',
+        });
+      } catch (error) {
+        onProgress?.({
+          action: 'introspect',
+          kind: 'spanEnd',
+          spanId: 'connect',
+          outcome: 'error',
+        });
+        throw error;
+      }
+    }
+
     const { driver, familyInstance } = await this.ensureConnected();
 
     // TODO: Pass schema option to familyInstance.introspect when schema filtering is implemented
     const _schema = options?.schema;
     void _schema;
 
-    return familyInstance.introspect({ driver });
+    // Emit introspect span
+    onProgress?.({
+      action: 'introspect',
+      kind: 'spanStart',
+      spanId: 'introspect',
+      label: 'Introspecting database schema...',
+    });
+
+    try {
+      const result = await familyInstance.introspect({ driver });
+
+      onProgress?.({
+        action: 'introspect',
+        kind: 'spanEnd',
+        spanId: 'introspect',
+        outcome: 'ok',
+      });
+
+      return result;
+    } catch (error) {
+      onProgress?.({
+        action: 'introspect',
+        kind: 'spanEnd',
+        spanId: 'introspect',
+        outcome: 'error',
+      });
+      throw error;
+    }
+  }
+
+  toSchemaView(schemaIR: unknown): CoreSchemaView | undefined {
+    this.init();
+    if (this.familyInstance?.toSchemaView) {
+      return this.familyInstance.toSchemaView(schemaIR);
+    }
+    return undefined;
   }
 }