@prisma-next/cli 0.3.0-dev.53 → 0.3.0-dev.55

package/src/commands/db-init.ts

@@ -1,51 +1,34 @@
-import { readFile } from 'node:fs/promises';
-import { relative, resolve } from 'node:path';
 import { ifDefined } from '@prisma-next/utils/defined';
 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 { ContractValidationError } from '../control-api/errors';
 import type { DbInitFailure } from '../control-api/types';
 import {
   CliStructuredError,
   errorContractValidationFailed,
-  errorDatabaseConnectionRequired,
-  errorDriverRequired,
-  errorFileNotFound,
   errorJsonFormatNotSupported,
   errorMigrationPlanningFailed,
+  errorRunnerFailed,
   errorRuntime,
-  errorTargetMigrationNotSupported,
   errorUnexpected,
 } from '../utils/cli-errors';
-import { setCommandDescriptions } from '../utils/command-helpers';
+import type { MigrationCommandOptions } from '../utils/command-helpers';
+import { sanitizeErrorMessage, setCommandDescriptions } from '../utils/command-helpers';
 import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
 import {
-  type DbInitResult,
+  addMigrationCommandOptions,
+  prepareMigrationContext,
+} from '../utils/migration-command-scaffold';
+import {
   formatCommandHelp,
-  formatDbInitApplyOutput,
-  formatDbInitJson,
-  formatDbInitPlanOutput,
-  formatStyledHeader,
+  formatMigrationApplyOutput,
+  formatMigrationJson,
+  formatMigrationPlanOutput,
+  type MigrationCommandResult,
 } from '../utils/output';
-import { createProgressAdapter } from '../utils/progress-adapter';
 import { handleResult } from '../utils/result-handler';
 
-interface DbInitOptions {
-  readonly db?: string;
-  readonly config?: string;
-  readonly plan?: boolean;
-  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;
-}
+type DbInitOptions = MigrationCommandOptions;
 
 /**
  * Maps a DbInitFailure to a CliStructuredError for consistent error handling.
@@ -77,9 +60,9 @@ function mapDbInitFailure(failure: DbInitFailure): CliStructuredError {
     }
 
     return errorRuntime(
-      `Existing contract marker does not match plan destination.${mismatchParts.length > 0 ? ` Mismatch in ${mismatchParts.join(' and ')}.` : ''}`,
+      `Existing database signature does not match plan destination.${mismatchParts.length > 0 ? ` Mismatch in ${mismatchParts.join(' and ')}.` : ''}`,
       {
-        why: 'Database has an existing contract marker that does not match the target contract',
+        why: 'Database has an existing signature (marker) that does not match the target contract',
         fix: 'If bootstrapping, drop/reset the database then re-run `prisma-next db init`; otherwise reconcile schema/marker using your migration workflow',
         meta: {
           code: 'MARKER_ORIGIN_MISMATCH',
@@ -93,13 +76,12 @@ function mapDbInitFailure(failure: DbInitFailure): CliStructuredError {
   }
 
   if (failure.code === 'RUNNER_FAILED') {
-    return errorRuntime(failure.summary, {
+    return errorRunnerFailed(failure.summary, {
       why: failure.why ?? 'Migration runner failed',
       fix: 'Fix the schema mismatch (db init is additive-only), or drop/reset the database and re-run `prisma-next db init`',
-      meta: {
-        code: 'RUNNER_FAILED',
-        ...(failure.meta ?? {}),
-      },
+      ...(failure.meta
+        ? { meta: { code: 'RUNNER_FAILED', ...failure.meta } }
+        : { meta: { code: 'RUNNER_FAILED' } }),
     });
   }
 
@@ -115,110 +97,20 @@ async function executeDbInitCommand(
   options: DbInitOptions,
   flags: GlobalFlags,
   startTime: number,
-): Promise<Result<DbInitResult, 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 });
-    }
-    if (options.plan) {
-      details.push({ label: 'mode', value: 'plan (dry run)' });
-    }
-    const header = formatStyledHeader({
-      command: 'db init',
-      description: 'Bootstrap a database to match the current contract',
-      url: 'https://pris.ly/db-init',
-      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 init (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 init' }));
-  }
-
-  // Check target supports migrations via the migrations capability
-  if (!config.target.migrations) {
-    return notOk(
-      errorTargetMigrationNotSupported({
-        why: `Target "${config.target.id}" does not support migrations`,
-      }),
-    );
-  }
-
-  // Create control client
-  const client = createControlClient({
-    family: config.family,
-    target: config.target,
-    adapter: config.adapter,
-    driver: config.driver,
-    extensionPacks: config.extensionPacks ?? [],
+): Promise<Result<MigrationCommandResult, CliStructuredError>> {
+  // Prepare shared migration context (config, contract, connection, client)
+  const ctxResult = await prepareMigrationContext(options, flags, {
+    commandName: 'db init',
+    description: 'Bootstrap a database to match the current contract',
+    url: 'https://pris.ly/db-init',
   });
-
-  // Create progress adapter
-  const onProgress = createProgressAdapter({ flags });
+  if (!ctxResult.ok) {
+    return ctxResult;
+  }
+  const { client, contractJson, dbConnection, onProgress, contractPathAbsolute } = ctxResult.value;
 
   try {
     // Call dbInit with connection and progress callback
-    // Connection happens inside dbInit with a 'connect' progress span
     const result = await client.dbInit({
       contractIR: contractJson,
       mode: options.plan ? 'plan' : 'apply',
@@ -232,15 +124,14 @@ async function executeDbInitCommand(
     }
 
     // Convert success result to CLI output format
-    const profileHash = result.value.marker?.profileHash;
-    const dbInitResult: DbInitResult = {
+    const dbInitResult: MigrationCommandResult = {
       ok: true,
       mode: result.value.mode,
       plan: {
-        targetId: config.target.targetId,
+        targetId: ctxResult.value.config.target.targetId,
         destination: {
-          storageHash: result.value.marker?.storageHash ?? '',
-          ...ifDefined('profileHash', profileHash),
+          storageHash: result.value.destination.storageHash,
+          ...ifDefined('profileHash', result.value.destination.profileHash),
         },
         operations: result.value.plan.operations.map((op) => ({
           id: op.id,
@@ -271,15 +162,26 @@ async function executeDbInitCommand(
     return ok(dbInitResult);
   } catch (error) {
     // Driver already throws CliStructuredError for connection failures
-    // Use static type guard to work across module boundaries
     if (CliStructuredError.is(error)) {
       return notOk(error);
     }
 
-    // Wrap unexpected errors
+    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(error instanceof Error ? error.message : String(error), {
-        why: `Unexpected error during db init: ${error instanceof Error ? error.message : String(error)}`,
+      errorUnexpected(safeMessage, {
+        why: `Unexpected error during db init: ${safeMessage}`,
       }),
     );
   } finally {
@@ -291,65 +193,55 @@ export function createDbInitCommand(): Command {
   const command = new Command('init');
   setCommandDescriptions(
     command,
-    'Bootstrap a database to match the current contract and write the contract marker',
+    'Bootstrap a database to match the current contract and sign it',
     'Initializes a database to match your emitted contract using additive-only operations.\n' +
       'Creates any missing tables, columns, indexes, and constraints defined in your contract.\n' +
       'Leaves existing compatible structures in place, surfaces conflicts when destructive changes\n' +
-      'would be required, and writes a contract marker to track the database state. Use --plan to\n' +
+      'would be required, and signs the database to track contract state. Use --plan to\n' +
       'preview changes without applying.',
   );
-  command
-    .configureHelp({
-      formatHelp: (cmd) => {
-        const flags = parseGlobalFlags({});
-        return formatCommandHelp({ command: cmd, flags });
-      },
-    })
-    .option('--db <url>', 'Database connection string')
-    .option('--config <path>', 'Path to prisma-next.config.ts')
-    .option('--plan', 'Preview planned operations without applying', 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')
-    .option('--timestamps', 'Add timestamps to output')
-    .option('--color', 'Force color output')
-    .option('--no-color', 'Disable color output')
-    .action(async (options: DbInitOptions) => {
-      const flags = parseGlobalFlags(options);
-      const startTime = Date.now();
-
-      // Validate JSON format option
-      if (flags.json === 'ndjson') {
-        const result = notOk(
-          errorJsonFormatNotSupported({
-            command: 'db init',
-            format: 'ndjson',
-            supportedFormats: ['object'],
-          }),
-        );
-        const exitCode = handleResult(result, flags);
-        process.exit(exitCode);
-      }
-
-      const result = await executeDbInitCommand(options, flags, startTime);
+  addMigrationCommandOptions(command);
+  command.configureHelp({
+    formatHelp: (cmd) => {
+      const flags = parseGlobalFlags({});
+      return formatCommandHelp({ command: cmd, flags });
+    },
+  });
+  command.action(async (options: DbInitOptions) => {
+    const flags = parseGlobalFlags(options);
+    const startTime = Date.now();
+
+    // Validate JSON format option
+    if (flags.json === 'ndjson') {
+      const result = notOk(
+        errorJsonFormatNotSupported({
+          command: 'db init',
+          format: 'ndjson',
+          supportedFormats: ['object'],
+        }),
+      );
+      const exitCode = handleResult(result, flags);
+      process.exit(exitCode);
+    }
 
-      const exitCode = handleResult(result, flags, (dbInitResult) => {
-        if (flags.json === 'object') {
-          console.log(formatDbInitJson(dbInitResult));
-        } else {
-          const output =
-            dbInitResult.mode === 'plan'
-              ? formatDbInitPlanOutput(dbInitResult, flags)
-              : formatDbInitApplyOutput(dbInitResult, flags);
-          if (output) {
-            console.log(output);
-          }
+    const result = await executeDbInitCommand(options, flags, startTime);
+
+    const exitCode = handleResult(result, flags, (dbInitResult) => {
+      if (flags.json === 'object') {
+        console.log(formatMigrationJson(dbInitResult));
+      } else {
+        const output =
+          dbInitResult.mode === 'plan'
+            ? formatMigrationPlanOutput(dbInitResult, flags)
+            : formatMigrationApplyOutput(dbInitResult, flags);
+        if (output) {
+          console.log(output);
         }
-      });
-
-      process.exit(exitCode);
+      }
     });
 
+    process.exit(exitCode);
+  });
+
   return command;
 }

package/src/commands/db-introspect.ts

@@ -12,7 +12,7 @@ import {
   errorJsonFormatNotSupported,
   errorUnexpected,
 } from '../utils/cli-errors';
-import { setCommandDescriptions } from '../utils/command-helpers';
+import { maskConnectionUrl, setCommandDescriptions } from '../utils/command-helpers';
 import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
 import {
   formatCommandHelp,
@@ -63,13 +63,9 @@ async function executeDbIntrospectCommand(
       { label: 'config', value: configPath },
     ];
     if (options.db) {
-      // Mask password in URL for security
-      const maskedUrl = options.db.replace(/:([^:@]+)@/, ':****@');
-      details.push({ label: 'database', value: maskedUrl });
+      details.push({ label: 'database', value: maskConnectionUrl(options.db) });
     } else if (config.db?.connection && typeof config.db.connection === 'string') {
-      // Mask password in URL for security
-      const maskedUrl = config.db.connection.replace(/:([^:@]+)@/, ':****@');
-      details.push({ label: 'database', value: maskedUrl });
+      details.push({ label: 'database', value: maskConnectionUrl(config.db.connection) });
     }
     const header = formatStyledHeader({
       command: 'db introspect',
@@ -127,7 +123,7 @@ async function executeDbIntrospectCommand(
 
     // Get masked connection URL for meta (only for string connections)
     const connectionForMeta =
-      typeof dbConnection === 'string' ? dbConnection.replace(/:([^:@]+)@/, ':****@') : undefined;
+      typeof dbConnection === 'string' ? maskConnectionUrl(dbConnection) : undefined;
 
     const introspectResult: IntrospectSchemaResult<unknown> = {
       ok: true,

package/src/commands/db-schema-verify.ts

@@ -5,6 +5,7 @@ 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 { ContractValidationError } from '../control-api/errors';
 import {
   CliStructuredError,
   errorContractValidationFailed,
@@ -14,7 +15,7 @@ import {
   errorJsonFormatNotSupported,
   errorUnexpected,
 } from '../utils/cli-errors';
-import { setCommandDescriptions } from '../utils/command-helpers';
+import { maskConnectionUrl, setCommandDescriptions } from '../utils/command-helpers';
 import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
 import {
   formatCommandHelp,
@@ -65,7 +66,7 @@ async function executeDbSchemaVerifyCommand(
       { 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 schema-verify',
@@ -156,6 +157,14 @@ async function executeDbSchemaVerifyCommand(
       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), {

package/src/commands/db-sign.ts

@@ -8,6 +8,7 @@ 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 { ContractValidationError } from '../control-api/errors';
 import {
   CliStructuredError,
   errorContractValidationFailed,
@@ -17,7 +18,7 @@ import {
   errorJsonFormatNotSupported,
   errorUnexpected,
 } from '../utils/cli-errors';
-import { setCommandDescriptions } from '../utils/command-helpers';
+import { maskConnectionUrl, setCommandDescriptions } from '../utils/command-helpers';
 import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
 import {
   formatCommandHelp,
@@ -77,7 +78,7 @@ async function executeDbSignCommand(
       { 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',
@@ -186,6 +187,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,8 +212,8 @@ 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