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

package/src/commands/contract-infer.ts

@@ -0,0 +1,143 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { errorRuntime } from '@prisma-next/errors/execution';
+import { printPsl, validatePrintableSqlSchemaIR } from '@prisma-next/psl-printer';
+import {
+  createPostgresDefaultMapping,
+  createPostgresTypeMap,
+  extractEnumInfo,
+  parseRawDefault,
+} from '@prisma-next/psl-printer/postgres';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { Command } from 'commander';
+import { dirname, relative } from 'pathe';
+import type { CliStructuredError } from '../utils/cli-errors';
+import {
+  addGlobalOptions,
+  setCommandDescriptions,
+  setCommandExamples,
+} from '../utils/command-helpers';
+import { parseGlobalFlags } from '../utils/global-flags';
+import { handleResult } from '../utils/result-handler';
+import { TerminalUI } from '../utils/terminal-ui';
+import { resolveContractInferOutputPath } from './contract-infer-paths';
+import {
+  type InspectLiveSchemaOptions,
+  type InspectLiveSchemaResult,
+  inspectLiveSchema,
+} from './inspect-live-schema';
+
+interface ContractInferOptions extends InspectLiveSchemaOptions {
+  readonly output?: string;
+}
+
+interface ContractInferSuccessResult {
+  readonly ok: true;
+  readonly summary: string;
+  readonly target: InspectLiveSchemaResult['target'];
+  readonly psl: {
+    readonly path: string;
+  };
+  readonly meta: InspectLiveSchemaResult['meta'];
+  readonly timings: {
+    readonly total: number;
+  };
+}
+
+async function executeContractInferCommand(
+  options: ContractInferOptions,
+  ui: TerminalUI,
+  startTime: number,
+): Promise<Result<ContractInferSuccessResult, CliStructuredError>> {
+  const flags = parseGlobalFlags(options);
+  const inspectResult = await inspectLiveSchema(options, flags, ui, startTime, {
+    commandName: 'contract infer',
+    description: 'Infer a PSL contract from the live database schema',
+    url: 'https://pris.ly/contract-infer',
+  });
+
+  if (!inspectResult.ok) {
+    return inspectResult;
+  }
+
+  const { config, target, meta } = inspectResult.value;
+
+  if (target.familyId !== 'sql') {
+    return notOk(
+      errorRuntime(`contract infer is not supported for family "${target.familyId}"`, {
+        why: 'contract infer currently supports SQL targets only',
+        fix: 'Use an SQL target (e.g. Postgres) with this command',
+      }),
+    );
+  }
+
+  const schema = validatePrintableSqlSchemaIR(inspectResult.value.schema);
+  const outputPath = resolveContractInferOutputPath(options, config.contract?.output);
+  const enumInfo = extractEnumInfo(schema.annotations);
+  const pslContent = printPsl(schema, {
+    defaultMapping: createPostgresDefaultMapping(),
+    typeMap: createPostgresTypeMap(enumInfo.typeNames),
+    enumInfo,
+    parseRawDefault,
+  });
+
+  if (existsSync(outputPath) && !flags.json && !flags.quiet) {
+    ui.stderr(`\u26A0 Overwriting existing file: ${relative(process.cwd(), outputPath)}`);
+  }
+
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, pslContent, 'utf-8');
+
+  const pslPath = relative(process.cwd(), outputPath);
+  if (!flags.json && !flags.quiet) {
+    ui.stderr(`\u2714 Contract written to ${pslPath}`);
+  }
+
+  return ok({
+    ok: true,
+    summary: 'Contract inferred successfully',
+    target,
+    psl: {
+      path: pslPath,
+    },
+    meta,
+    timings: {
+      total: Date.now() - startTime,
+    },
+  });
+}
+
+export function createContractInferCommand(): Command {
+  const command = new Command('infer');
+  setCommandDescriptions(
+    command,
+    'Infer a PSL contract from the live database schema',
+    'Reads the live database schema and writes an inferred PSL contract to disk.\n' +
+      'This command stops at `contract.prisma`; follow it with `contract emit` and\n' +
+      '`db sign` as separate steps.',
+  );
+  setCommandExamples(command, [
+    'prisma-next contract infer --db $DATABASE_URL',
+    'prisma-next contract infer --db $DATABASE_URL --output ./prisma/contract.prisma',
+    'prisma-next contract infer --db $DATABASE_URL --json',
+  ]);
+  addGlobalOptions(command)
+    .option('--db <url>', 'Database connection string')
+    .option('--config <path>', 'Path to prisma-next.config.ts')
+    .option('--output <path>', 'Write the inferred PSL contract to the specified path')
+    .action(async (options: ContractInferOptions) => {
+      const flags = parseGlobalFlags(options);
+      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+      const startTime = Date.now();
+
+      const result = await executeContractInferCommand(options, ui, startTime);
+      const exitCode = handleResult(result, flags, ui, (value) => {
+        if (flags.json) {
+          ui.output(JSON.stringify(value, null, 2));
+        }
+      });
+
+      process.exit(exitCode);
+    });
+
+  return command;
+}

package/src/commands/db-init.ts

@@ -1,50 +1,37 @@
-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,
+  setCommandExamples,
+} from '../utils/command-helpers';
+import {
+  formatMigrationApplyOutput,
+  formatMigrationJson,
+  formatMigrationPlanOutput,
+  type MigrationCommandResult,
+} from '../utils/formatters/migrations';
 import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
 import {
-  type DbInitResult,
-  formatCommandHelp,
-  formatDbInitApplyOutput,
-  formatDbInitJson,
-  formatDbInitPlanOutput,
-  formatStyledHeader,
-} from '../utils/output';
-import { createProgressAdapter } from '../utils/progress-adapter';
+  addMigrationCommandOptions,
+  prepareMigrationContext,
+} from '../utils/migration-command-scaffold';
 import { handleResult } from '../utils/result-handler';
+import { TerminalUI } from '../utils/terminal-ui';
 
-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.
@@ -57,12 +44,12 @@ function mapDbInitFailure(failure: DbInitFailure): CliStructuredError {
   if (failure.code === 'MARKER_ORIGIN_MISMATCH') {
     const mismatchParts: string[] = [];
     if (
-      failure.marker?.coreHash !== failure.destination?.coreHash &&
-      failure.marker?.coreHash &&
-      failure.destination?.coreHash
+      failure.marker?.storageHash !== failure.destination?.storageHash &&
+      failure.marker?.storageHash &&
+      failure.destination?.storageHash
     ) {
       mismatchParts.push(
-        `coreHash (marker: ${failure.marker.coreHash}, destination: ${failure.destination.coreHash})`,
+        `storageHash (marker: ${failure.marker.storageHash}, destination: ${failure.destination.storageHash})`,
       );
     }
     if (
@@ -76,33 +63,28 @@ 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',
-          ...(failure.marker?.coreHash ? { markerCoreHash: failure.marker.coreHash } : {}),
-          ...(failure.destination?.coreHash
-            ? { destinationCoreHash: failure.destination.coreHash }
-            : {}),
-          ...(failure.marker?.profileHash ? { markerProfileHash: failure.marker.profileHash } : {}),
-          ...(failure.destination?.profileHash
-            ? { destinationProfileHash: failure.destination.profileHash }
-            : {}),
+          ...ifDefined('markerStorageHash', failure.marker?.storageHash),
+          ...ifDefined('destinationStorageHash', failure.destination?.storageHash),
+          ...ifDefined('markerProfileHash', failure.marker?.profileHash),
+          ...ifDefined('destinationProfileHash', failure.destination?.profileHash),
         },
       },
     );
   }
 
   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' } }),
     });
   }
 
@@ -117,114 +99,25 @@ function mapDbInitFailure(failure: DbInitFailure): CliStructuredError {
 async function executeDbInitCommand(
   options: DbInitOptions,
   flags: GlobalFlags,
+  ui: TerminalUI,
   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, ui, {
+    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',
+      contract: contractJson,
+      mode: options.dryRun ? 'plan' : 'apply',
       connection: dbConnection,
       onProgress,
     });
@@ -235,15 +128,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: {
-          coreHash: result.value.marker?.coreHash ?? '',
-          ...(profileHash ? { profileHash } : {}),
+          storageHash: result.value.destination.storageHash,
+          ...ifDefined('profileHash', result.value.destination.profileHash),
         },
         operations: result.value.plan.operations.map((op) => ({
           id: op.id,
@@ -262,10 +154,8 @@ async function executeDbInitCommand(
       ...(result.value.marker
         ? {
             marker: {
-              coreHash: result.value.marker.coreHash,
-              ...(result.value.marker.profileHash
-                ? { profileHash: result.value.marker.profileHash }
-                : {}),
+              storageHash: result.value.marker.storageHash,
+              ...ifDefined('profileHash', result.value.marker.profileHash),
             },
           }
         : {}),
@@ -276,15 +166,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 {
@@ -296,65 +197,42 @@ 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 --dry-run 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);
-
-      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);
-          }
+  setCommandExamples(command, [
+    'prisma-next db init --db $DATABASE_URL',
+    'prisma-next db init --db $DATABASE_URL --dry-run',
+  ]);
+  addMigrationCommandOptions(command);
+  command.action(async (options: DbInitOptions) => {
+    const flags = parseGlobalFlags(options);
+    const startTime = Date.now();
+
+    const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+
+    const result = await executeDbInitCommand(options, flags, ui, startTime);
+
+    const exitCode = handleResult(result, flags, ui, (dbInitResult) => {
+      if (flags.json) {
+        ui.output(formatMigrationJson(dbInitResult));
+      } else {
+        const output =
+          dbInitResult.mode === 'plan'
+            ? formatMigrationPlanOutput(dbInitResult, flags)
+            : formatMigrationApplyOutput(dbInitResult, flags);
+        if (output) {
+          ui.log(output);
         }
-      });
-
-      process.exit(exitCode);
+      }
     });
 
+    process.exit(exitCode);
+  });
+
   return command;
 }

package/src/commands/db-schema.ts

@@ -0,0 +1,77 @@
+import type { IntrospectSchemaResult } from '@prisma-next/framework-components/control';
+import { Command } from 'commander';
+import {
+  addGlobalOptions,
+  setCommandDescriptions,
+  setCommandExamples,
+} from '../utils/command-helpers';
+import { formatIntrospectJson, formatIntrospectOutput } from '../utils/formatters/verify';
+import { parseGlobalFlags } from '../utils/global-flags';
+import { handleResult } from '../utils/result-handler';
+import { TerminalUI } from '../utils/terminal-ui';
+import {
+  type InspectLiveSchemaOptions,
+  type InspectLiveSchemaResult,
+  inspectLiveSchema,
+} from './inspect-live-schema';
+
+function toIntrospectSchemaResult(
+  result: InspectLiveSchemaResult,
+): IntrospectSchemaResult<unknown> {
+  return {
+    ok: true,
+    summary: 'Schema read successfully',
+    target: result.target,
+    schema: result.schema,
+    meta: result.meta,
+    timings: result.timings,
+  };
+}
+
+export function createDbSchemaCommand(): Command {
+  const command = new Command('schema');
+  setCommandDescriptions(
+    command,
+    'Inspect the live database schema',
+    'Reads the live database schema and prints it as a tree by default or as JSON with\n' +
+      '--json. This command is always read-only and never writes files. To save machine-\n' +
+      'readable output, use shell redirection, for example `prisma-next db schema --json > schema.json`.',
+  );
+  setCommandExamples(command, [
+    'prisma-next db schema --db $DATABASE_URL',
+    'prisma-next db schema --db $DATABASE_URL --json',
+    'prisma-next db schema --db $DATABASE_URL --json > schema.json',
+  ]);
+  addGlobalOptions(command)
+    .option('--db <url>', 'Database connection string')
+    .option('--config <path>', 'Path to prisma-next.config.ts')
+    .action(async (options: InspectLiveSchemaOptions) => {
+      const flags = parseGlobalFlags(options);
+      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+      const startTime = Date.now();
+
+      const result = await inspectLiveSchema(options, flags, ui, startTime, {
+        commandName: 'db schema',
+        description: 'Inspect the live database schema',
+        url: 'https://pris.ly/db-schema',
+      });
+
+      const exitCode = handleResult(result, flags, ui, (value) => {
+        const introspectResult = toIntrospectSchemaResult(value);
+
+        if (flags.json) {
+          ui.output(formatIntrospectJson(introspectResult));
+          return;
+        }
+
+        const output = formatIntrospectOutput(introspectResult, value.schemaView, flags);
+        if (output) {
+          ui.log(output);
+        }
+      });
+
+      process.exit(exitCode);
+    });
+
+  return command;
+}