@prisma-next/cli 0.3.0-pr.99.6 → 0.3.0

package/src/commands/db-sign.ts

@@ -1,48 +1,45 @@
 import { readFile } from 'node:fs/promises';
-import { relative, resolve } from 'node:path';
 import type {
   SignDatabaseResult,
   VerifyDatabaseSchemaResult,
-} from '@prisma-next/core-control-plane/types';
+} from '@prisma-next/framework-components/control';
 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 { createControlClient } from '../control-api/client';
+import { ContractValidationError } from '../control-api/errors';
 import {
   CliStructuredError,
   errorContractValidationFailed,
   errorDatabaseConnectionRequired,
   errorDriverRequired,
   errorFileNotFound,
-  errorJsonFormatNotSupported,
   errorUnexpected,
 } from '../utils/cli-errors';
-import { setCommandDescriptions } from '../utils/command-helpers';
-import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
 import {
-  formatCommandHelp,
+  addGlobalOptions,
+  maskConnectionUrl,
+  resolveContractPath,
+  setCommandDescriptions,
+  setCommandExamples,
+} from '../utils/command-helpers';
+import { formatStyledHeader } from '../utils/formatters/styled';
+import {
   formatSchemaVerifyJson,
   formatSchemaVerifyOutput,
   formatSignJson,
   formatSignOutput,
-  formatStyledHeader,
-} from '../utils/output';
+} from '../utils/formatters/verify';
+import type { CommonCommandOptions } from '../utils/global-flags';
+import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
 import { createProgressAdapter } from '../utils/progress-adapter';
 import { handleResult } from '../utils/result-handler';
+import { TerminalUI } from '../utils/terminal-ui';
 
-interface DbSignOptions {
+interface DbSignOptions extends CommonCommandOptions {
   readonly db?: string;
   readonly config?: string;
-  readonly json?: string | boolean;
-  readonly quiet?: boolean;
-  readonly q?: boolean;
-  readonly verbose?: boolean;
-  readonly v?: boolean;
-  readonly vv?: boolean;
-  readonly trace?: boolean;
-  readonly timestamps?: boolean;
-  readonly color?: boolean;
-  readonly 'no-color'?: boolean;
 }
 
 /**
@@ -59,25 +56,24 @@ type DbSignFailure = CliStructuredError | VerifyDatabaseSchemaResult;
 async function executeDbSignCommand(
   options: DbSignOptions,
   flags: GlobalFlags,
+  ui: TerminalUI,
 ): Promise<Result<SignDatabaseResult, DbSignFailure>> {
   // 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 contractPathAbsolute = resolveContractPath(config);
   const contractPath = relative(process.cwd(), contractPathAbsolute);
 
   // Output header
-  if (flags.json !== 'object' && !flags.quiet) {
+  if (!flags.json && !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 });
+      details.push({ label: 'database', value: maskConnectionUrl(options.db) });
     }
     const header = formatStyledHeader({
       command: 'db sign',
@@ -86,7 +82,7 @@ async function executeDbSignCommand(
       details,
       flags,
     });
-    console.log(header);
+    ui.stderr(header);
   }
 
   // Load contract file
@@ -127,6 +123,7 @@ async function executeDbSignCommand(
     return notOk(
       errorDatabaseConnectionRequired({
         why: `Database connection is required for db sign (set db.connection in ${configPath}, or pass --db <url>)`,
+        commandName: 'db sign',
       }),
     );
   }
@@ -146,12 +143,12 @@ async function executeDbSignCommand(
   });
 
   // Create progress adapter
-  const onProgress = createProgressAdapter({ flags });
+  const onProgress = createProgressAdapter({ ui, flags });
 
   try {
     // Step 1: Schema verification - connect here
     const schemaVerifyResult = await client.schemaVerify({
-      contractIR: contractJson,
+      contract: contractJson,
       strict: false,
       connection: dbConnection,
       onProgress,
@@ -159,26 +156,17 @@ async function executeDbSignCommand(
 
     // If schema verification failed, return as failure
     if (!schemaVerifyResult.ok) {
-      // Add blank line after all async operations if spinners were shown
-      if (!flags.quiet && flags.json !== 'object' && process.stdout.isTTY) {
-        console.log('');
-      }
       return notOk(schemaVerifyResult);
     }
 
     // Step 2: Sign (already connected from schemaVerify)
     const signResult = await client.sign({
-      contractIR: contractJson,
+      contract: contractJson,
       contractPath,
       configPath,
       onProgress,
     });
 
-    // Add blank line after all async operations if spinners were shown
-    if (!flags.quiet && flags.json !== 'object' && process.stdout.isTTY) {
-      console.log('');
-    }
-
     return ok(signResult);
   } catch (error) {
     // Driver already throws CliStructuredError for connection failures
@@ -186,6 +174,14 @@ async function executeDbSignCommand(
       return notOk(error);
     }
 
+    if (error instanceof ContractValidationError) {
+      return notOk(
+        errorContractValidationFailed(`Contract validation failed: ${error.message}`, {
+          where: { path: contractPathAbsolute },
+        }),
+      );
+    }
+
     // Wrap unexpected errors
     return notOk(
       errorUnexpected(error instanceof Error ? error.message : String(error), {
@@ -203,52 +199,29 @@ export function createDbSignCommand(): Command {
     command,
     'Sign the database with your contract so you can safely run queries',
     'Verifies that your database schema satisfies the emitted contract, and if so, writes or\n' +
-      'updates the contract marker in the database. This command is idempotent and safe to run\n' +
-      'in CI/deployment pipelines. The marker records that this database instance is aligned\n' +
+      'updates the database signature. This command is idempotent and safe to run\n' +
+      'in CI/deployment pipelines. The signature records that this database instance is aligned\n' +
       'with a specific contract version.',
   );
-  command
-    .configureHelp({
-      formatHelp: (cmd) => {
-        const flags = parseGlobalFlags({});
-        return formatCommandHelp({ command: cmd, flags });
-      },
-    })
+  setCommandExamples(command, ['prisma-next db sign --db $DATABASE_URL']);
+  addGlobalOptions(command)
     .option('--db <url>', 'Database connection string')
     .option('--config <path>', 'Path to prisma-next.config.ts')
-    .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')
-    .option('--timestamps', 'Add timestamps to output')
-    .option('--color', 'Force color output')
-    .option('--no-color', 'Disable color output')
     .action(async (options: DbSignOptions) => {
       const flags = parseGlobalFlags(options);
 
-      // Validate JSON format option
-      if (flags.json === 'ndjson') {
-        const result = notOk(
-          errorJsonFormatNotSupported({
-            command: 'db sign',
-            format: 'ndjson',
-            supportedFormats: ['object'],
-          }),
-        );
-        const exitCode = handleResult(result, flags);
-        process.exit(exitCode);
-      }
+      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
 
-      const result = await executeDbSignCommand(options, flags);
+      const result = await executeDbSignCommand(options, flags, ui);
 
       if (result.ok) {
         // Success - format sign output
-        if (flags.json === 'object') {
-          console.log(formatSignJson(result.value));
+        if (flags.json) {
+          ui.output(formatSignJson(result.value));
         } else {
           const output = formatSignOutput(result.value, flags);
           if (output) {
-            console.log(output);
+            ui.log(output);
           }
         }
         process.exit(0);
@@ -259,17 +232,17 @@ export function createDbSignCommand(): Command {
 
       if (failure instanceof CliStructuredError) {
         // Infrastructure error - use standard handler
-        const exitCode = handleResult(result as Result<never, CliStructuredError>, flags);
+        const exitCode = handleResult(result as Result<never, CliStructuredError>, flags, ui);
         process.exit(exitCode);
       }
 
       // Schema verification failed - format and print schema verification output
-      if (flags.json === 'object') {
-        console.log(formatSchemaVerifyJson(failure));
+      if (flags.json) {
+        ui.output(formatSchemaVerifyJson(failure));
       } else {
         const output = formatSchemaVerifyOutput(failure, flags);
         if (output) {
-          console.log(output);
+          ui.log(output);
         }
       }
       process.exit(1);

package/src/commands/db-update.ts

@@ -0,0 +1,236 @@
+import { ifDefined } from '@prisma-next/utils/defined';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { Command } from 'commander';
+import { ContractValidationError } from '../control-api/errors';
+import type { DbUpdateFailure } from '../control-api/types';
+import {
+  CliStructuredError,
+  ERROR_CODE_DESTRUCTIVE_CHANGES,
+  errorContractValidationFailed,
+  errorDestructiveChanges,
+  errorMigrationPlanningFailed,
+  errorRunnerFailed,
+  errorUnexpected,
+} from '../utils/cli-errors';
+import type { MigrationCommandOptions } from '../utils/command-helpers';
+import {
+  sanitizeErrorMessage,
+  setCommandDescriptions,
+  setCommandExamples,
+} from '../utils/command-helpers';
+import {
+  formatMigrationApplyOutput,
+  formatMigrationJson,
+  formatMigrationPlanOutput,
+  type MigrationCommandResult,
+} from '../utils/formatters/migrations';
+import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
+import {
+  addMigrationCommandOptions,
+  prepareMigrationContext,
+} from '../utils/migration-command-scaffold';
+import { handleResult } from '../utils/result-handler';
+import { TerminalUI } from '../utils/terminal-ui';
+
+type DbUpdateOptions = MigrationCommandOptions;
+
+/**
+ * Maps a DbUpdateFailure to a CliStructuredError for consistent error handling.
+ */
+function mapDbUpdateFailure(failure: DbUpdateFailure): CliStructuredError {
+  if (failure.code === 'PLANNING_FAILED') {
+    return errorMigrationPlanningFailed({ conflicts: failure.conflicts ?? [] });
+  }
+
+  if (failure.code === 'RUNNER_FAILED') {
+    return errorRunnerFailed(failure.summary, {
+      why: failure.why ?? 'Migration runner failed',
+      fix: 'Inspect the reported conflict, reconcile schema drift if needed, then re-run `prisma-next db update`',
+      ...ifDefined('meta', failure.meta),
+    });
+  }
+
+  if (failure.code === 'DESTRUCTIVE_CHANGES') {
+    return errorDestructiveChanges(failure.summary, {
+      ...ifDefined('why', failure.why),
+      fix: 'Re-run with `-y` to apply destructive changes, or use `--dry-run` to preview first',
+      ...ifDefined('meta', failure.meta),
+    });
+  }
+
+  const exhaustive: never = failure.code;
+  throw new Error(`Unhandled DbUpdateFailure code: ${exhaustive}`);
+}
+
+/**
+ * Executes the db update command and returns a structured Result.
+ */
+async function executeDbUpdateCommand(
+  options: DbUpdateOptions,
+  flags: GlobalFlags,
+  ui: TerminalUI,
+  startTime: number,
+): Promise<Result<MigrationCommandResult, CliStructuredError>> {
+  // Prepare shared migration context (config, contract, connection, client)
+  const ctxResult = await prepareMigrationContext(options, flags, ui, {
+    commandName: 'db update',
+    description: 'Update your database schema to match your contract',
+    url: 'https://pris.ly/db-update',
+  });
+  if (!ctxResult.ok) {
+    return ctxResult;
+  }
+  const { client, contractJson, dbConnection, onProgress, contractPathAbsolute } = ctxResult.value;
+
+  try {
+    // Call dbUpdate with connection and progress callback
+    const result = await client.dbUpdate({
+      contract: contractJson,
+      mode: options.dryRun ? 'plan' : 'apply',
+      connection: dbConnection,
+      ...(flags.yes ? { acceptDataLoss: true } : {}),
+      onProgress,
+    });
+
+    // Handle failures by mapping to CLI structured error
+    if (!result.ok) {
+      return notOk(mapDbUpdateFailure(result.failure));
+    }
+
+    // Convert success result to CLI output format
+    const dbUpdateResult: MigrationCommandResult = {
+      ok: true,
+      mode: result.value.mode,
+      plan: {
+        targetId: ctxResult.value.config.target.targetId,
+        destination: {
+          storageHash: result.value.destination.storageHash,
+          ...ifDefined('profileHash', result.value.destination.profileHash),
+        },
+        operations: result.value.plan.operations.map((op) => ({
+          id: op.id,
+          label: op.label,
+          operationClass: op.operationClass,
+        })),
+        ...ifDefined('sql', result.value.plan.sql),
+      },
+      ...ifDefined(
+        'execution',
+        result.value.execution
+          ? {
+              operationsPlanned: result.value.execution.operationsPlanned,
+              operationsExecuted: result.value.execution.operationsExecuted,
+            }
+          : undefined,
+      ),
+      ...ifDefined(
+        'marker',
+        result.value.marker
+          ? {
+              storageHash: result.value.marker.storageHash,
+              ...ifDefined('profileHash', result.value.marker.profileHash),
+            }
+          : undefined,
+      ),
+      summary: result.value.summary,
+      timings: { total: Date.now() - startTime },
+    };
+
+    return ok(dbUpdateResult);
+  } catch (error) {
+    if (CliStructuredError.is(error)) {
+      return notOk(error);
+    }
+
+    if (error instanceof ContractValidationError) {
+      return notOk(
+        errorContractValidationFailed(`Contract validation failed: ${error.message}`, {
+          where: { path: contractPathAbsolute },
+        }),
+      );
+    }
+
+    const rawMessage = error instanceof Error ? error.message : String(error);
+    const safeMessage = sanitizeErrorMessage(
+      rawMessage,
+      typeof dbConnection === 'string' ? dbConnection : undefined,
+    );
+    return notOk(
+      errorUnexpected(safeMessage, {
+        why: `Unexpected error during db update: ${safeMessage}`,
+      }),
+    );
+  } finally {
+    await client.close();
+  }
+}
+
+export function createDbUpdateCommand(): Command {
+  const command = new Command('update');
+  setCommandDescriptions(
+    command,
+    'Update your database schema to match your contract',
+    'Compares your database schema to the emitted contract and applies the necessary\n' +
+      'changes. Works on any database, whether or not it has been initialized with `db init`.\n' +
+      'Destructive operations prompt for confirmation in interactive mode. Use -y to\n' +
+      'auto-accept or --dry-run to preview first.',
+  );
+  setCommandExamples(command, [
+    'prisma-next db update --db $DATABASE_URL',
+    'prisma-next db update --db $DATABASE_URL --dry-run',
+  ]);
+  addMigrationCommandOptions(command);
+  command.action(async (options: DbUpdateOptions) => {
+    const flags = parseGlobalFlags(options);
+    const startTime = Date.now();
+
+    const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+
+    let result = await executeDbUpdateCommand(options, flags, ui, startTime);
+
+    // Interactive confirmation for destructive operations:
+    // When the control API rejects destructive changes, prompt the user instead of failing.
+    // In non-interactive mode (CI, piped, --no-interactive, --json), the error is returned as-is.
+    if (
+      !result.ok &&
+      result.failure.code === ERROR_CODE_DESTRUCTIVE_CHANGES &&
+      flags.interactive &&
+      !flags.json &&
+      !flags.yes
+    ) {
+      const meta = result.failure.meta as
+        | { destructiveOperations?: readonly { id: string; label: string }[] }
+        | undefined;
+      const destructiveOps = meta?.destructiveOperations ?? [];
+
+      if (destructiveOps.length > 0) {
+        ui.warn(
+          `${destructiveOps.length} destructive operation(s) that may cause data loss:\n${destructiveOps.map((op) => `  ${ui.yellow('▸')} ${op.label}`).join('\n')}`,
+        );
+      }
+
+      const confirmed = await ui.confirm('Apply destructive changes? This cannot be undone.');
+
+      if (confirmed) {
+        result = await executeDbUpdateCommand(options, { ...flags, yes: true }, ui, Date.now());
+      }
+    }
+
+    const exitCode = handleResult(result, flags, ui, (dbUpdateResult) => {
+      if (flags.json) {
+        ui.output(formatMigrationJson(dbUpdateResult));
+      } else {
+        const output =
+          dbUpdateResult.mode === 'plan'
+            ? formatMigrationPlanOutput(dbUpdateResult, flags)
+            : formatMigrationApplyOutput(dbUpdateResult, flags);
+        if (output) {
+          ui.log(output);
+        }
+      }
+    });
+    process.exit(exitCode);
+  });
+
+  return command;
+}