@prisma-next/cli 0.3.0-dev.11 → 0.3.0-dev.113

package/src/commands/contract-emit.ts

@@ -1,177 +1,270 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, relative, resolve } from 'node:path';
 import { errorContractConfigMissing } from '@prisma-next/core-control-plane/errors';
-import { createControlPlaneStack } from '@prisma-next/core-control-plane/types';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
+import { dirname, isAbsolute, join, relative, resolve } from 'pathe';
 import { loadConfig } from '../config-loader';
-import { performAction } from '../utils/action';
-import { setCommandDescriptions } from '../utils/command-helpers';
-import { parseGlobalFlags } from '../utils/global-flags';
+import { createControlClient } from '../control-api/client';
+import type { EmitFailure } from '../control-api/types';
 import {
-  formatCommandHelp,
+  CliStructuredError,
+  errorContractValidationFailed,
+  errorRuntime,
+  errorUnexpected,
+} from '../utils/cli-errors';
+import {
+  addGlobalOptions,
+  setCommandDescriptions,
+  setCommandExamples,
+} from '../utils/command-helpers';
+import {
+  type EmitContractResult,
   formatEmitJson,
   formatEmitOutput,
-  formatStyledHeader,
-  formatSuccessMessage,
-} from '../utils/output';
+} from '../utils/formatters/emit';
+import { formatStyledHeader, formatSuccessMessage } from '../utils/formatters/styled';
+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 { withSpinner } from '../utils/spinner';
+import { TerminalUI } from '../utils/terminal-ui';
 
-interface ContractEmitOptions {
+interface ContractEmitOptions extends CommonCommandOptions {
   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;
+}
+
+function mapDiagnosticsToIssues(
+  failure: EmitFailure,
+): ReadonlyArray<{ kind: string; message: string }> {
+  const diagnostics = failure.diagnostics?.diagnostics ?? [];
+  return diagnostics.map((diagnostic) => {
+    const location =
+      diagnostic.sourceId && diagnostic.span
+        ? ` (${diagnostic.sourceId}:${diagnostic.span.start.line}:${diagnostic.span.start.column})`
+        : diagnostic.sourceId
+          ? ` (${diagnostic.sourceId})`
+          : '';
+    return {
+      kind: diagnostic.code,
+      message: `${diagnostic.message}${location}`,
+    };
+  });
+}
+
+/**
+ * Maps an EmitFailure to a CliStructuredError for consistent error handling.
+ */
+function mapEmitFailure(
+  failure: EmitFailure,
+  context?: { readonly configPath?: string },
+): CliStructuredError {
+  if (failure.code === 'CONTRACT_SOURCE_INVALID') {
+    const issues = mapDiagnosticsToIssues(failure);
+    return errorRuntime(failure.summary, {
+      why: failure.why ?? 'Contract source provider failed',
+      fix: 'Check your contract source provider in prisma-next.config.ts and ensure it returns Result<ContractIR, Diagnostics>',
+      ...(issues.length > 0 ? { meta: { issues } } : {}),
+    });
+  }
+
+  if (failure.code === 'CONTRACT_VALIDATION_FAILED') {
+    return errorContractValidationFailed(
+      failure.why ?? 'Contract validation failed while emitting',
+      context?.configPath ? { where: { path: context.configPath } } : undefined,
+    );
+  }
+
+  if (failure.code === 'EMIT_FAILED') {
+    return errorRuntime(failure.summary, {
+      why: failure.why ?? 'Failed to emit contract',
+      fix: 'Check your contract configuration and ensure the source is valid',
+    });
+  }
+
+  // Exhaustive check - TypeScript will error if a new code is added but not handled
+  const exhaustive: never = failure.code;
+  throw new Error(`Unhandled EmitFailure code: ${exhaustive}`);
+}
+
+/**
+ * Executes the contract emit command and returns a structured Result.
+ */
+async function executeContractEmitCommand(
+  options: ContractEmitOptions,
+  flags: GlobalFlags,
+  ui: TerminalUI,
+  startTime: number,
+): Promise<Result<EmitContractResult, CliStructuredError>> {
+  // Load config
+  let config: Awaited<ReturnType<typeof loadConfig>>;
+  try {
+    config = await loadConfig(options.config);
+  } catch (error) {
+    // Convert thrown CliStructuredError to Result
+    if (error instanceof CliStructuredError) {
+      return notOk(error);
+    }
+    return notOk(
+      errorUnexpected(error instanceof Error ? error.message : String(error), {
+        why: 'Failed to load config',
+      }),
+    );
+  }
+
+  const configPath = options.config
+    ? relative(process.cwd(), resolve(options.config))
+    : 'prisma-next.config.ts';
+
+  // Resolve contract from config
+  if (!config.contract) {
+    return notOk(
+      errorContractConfigMissing({
+        why: 'Config.contract is required for emit. Define it in your config: contract: { source: ..., output: ... }',
+      }),
+    );
+  }
+
+  // Contract config is already normalized by defineConfig() with defaults applied
+  const contractConfig = config.contract;
+
+  // Resolve artifact paths from config (already normalized by defineConfig() with defaults)
+  if (!contractConfig.output) {
+    return notOk(
+      errorContractConfigMissing({
+        why: 'Contract config must have output path. This should not happen if defineConfig() was used.',
+      }),
+    );
+  }
+  if (!contractConfig.output.endsWith('.json')) {
+    return notOk(
+      errorContractConfigMissing({
+        why: 'Contract config output path must end with .json (e.g., "src/prisma/contract.json")',
+      }),
+    );
+  }
+  const configDir = options.config ? dirname(resolve(options.config)) : process.cwd();
+  const outputJsonPath = isAbsolute(contractConfig.output)
+    ? contractConfig.output
+    : join(configDir, contractConfig.output);
+  // Colocate .d.ts with .json (contract.json → contract.d.ts)
+  const outputDtsPath = `${outputJsonPath.slice(0, -5)}.d.ts`;
+
+  // Output header to stderr (decoration)
+  if (!flags.json && !flags.quiet) {
+    const contractPath = relative(process.cwd(), outputJsonPath);
+    const typesPath = relative(process.cwd(), outputDtsPath);
+    const header = formatStyledHeader({
+      command: 'contract emit',
+      description: 'Emit your contract artifacts',
+      url: 'https://pris.ly/contract-emit',
+      details: [
+        { label: 'config', value: configPath },
+        { label: 'contract', value: contractPath },
+        { label: 'types', value: typesPath },
+      ],
+      flags,
+    });
+    ui.stderr(header);
+  }
+
+  // Create control client (no driver needed for emit)
+  const client = createControlClient({
+    family: config.family,
+    target: config.target,
+    adapter: config.adapter,
+    extensionPacks: config.extensionPacks ?? [],
+  });
+
+  // Create progress adapter
+  const onProgress = createProgressAdapter({ ui, flags });
+
+  try {
+    // Call emit with progress callback
+    const result = await client.emit({
+      contractConfig: {
+        sourceProvider: contractConfig.source,
+        output: outputJsonPath,
+      },
+      onProgress,
+    });
+
+    // Handle failures by mapping to CLI structured error
+    if (!result.ok) {
+      return notOk(mapEmitFailure(result.failure, { configPath }));
+    }
+
+    // Create directories if needed
+    mkdirSync(dirname(outputJsonPath), { recursive: true });
+    mkdirSync(dirname(outputDtsPath), { recursive: true });
+
+    // Write the results to files
+    writeFileSync(outputJsonPath, result.value.contractJson, 'utf-8');
+    writeFileSync(outputDtsPath, result.value.contractDts, 'utf-8');
+
+    // Convert success result to CLI output format
+    const emitResult: EmitContractResult = {
+      storageHash: result.value.storageHash,
+      ...(result.value.executionHash ? { executionHash: result.value.executionHash } : {}),
+      profileHash: result.value.profileHash,
+      outDir: dirname(outputJsonPath),
+      files: {
+        json: outputJsonPath,
+        dts: outputDtsPath,
+      },
+      timings: { total: Date.now() - startTime },
+    };
+
+    return ok(emitResult);
+  } catch (error) {
+    // Use static type guard to work across module boundaries
+    if (CliStructuredError.is(error)) {
+      return notOk(error);
+    }
+
+    // Wrap unexpected errors
+    return notOk(
+      errorUnexpected('Unexpected error during contract emit', {
+        why: error instanceof Error ? error.message : String(error),
+      }),
+    );
+  } finally {
+    await client.close();
+  }
 }
 
 export function createContractEmitCommand(): Command {
   const command = new Command('emit');
   setCommandDescriptions(
     command,
-    'Write your contract to JSON and sign it',
+    'Emit your contract artifacts',
     'Reads your contract source (TypeScript or Prisma schema) and emits contract.json and\n' +
       'contract.d.ts. The contract.json contains the canonical contract structure, and\n' +
       'contract.d.ts provides TypeScript types for type-safe query building.',
   );
-  command
-    .configureHelp({
-      formatHelp: (cmd) => {
-        const flags = parseGlobalFlags({});
-        return formatCommandHelp({ command: cmd, flags });
-      },
-    })
+  setCommandExamples(command, [
+    'prisma-next contract emit',
+    'prisma-next contract emit --config ./custom-config.ts',
+  ]);
+  addGlobalOptions(command)
     .option('--config <path>', 'Path to prisma-next.config.ts')
-    .option('--json [format]', 'Output as JSON (object or ndjson)', 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: ContractEmitOptions) => {
       const flags = parseGlobalFlags(options);
+      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+      const startTime = Date.now();
 
-      const result = await performAction(async () => {
-        // Load config
-        const config = await loadConfig(options.config);
-
-        // Resolve contract from config
-        if (!config.contract) {
-          throw errorContractConfigMissing({
-            why: 'Config.contract is required for emit. Define it in your config: contract: { source: ..., output: ..., types: ... }',
-          });
-        }
-
-        // Contract config is already normalized by defineConfig() with defaults applied
-        const contractConfig = config.contract;
-
-        // Resolve artifact paths from config (already normalized by defineConfig() with defaults)
-        if (!contractConfig.output || !contractConfig.types) {
-          throw errorContractConfigMissing({
-            why: 'Contract config must have output and types paths. This should not happen if defineConfig() was used.',
-          });
-        }
-        const outputJsonPath = resolve(contractConfig.output);
-        const outputDtsPath = resolve(contractConfig.types);
-
-        // Output header (only for human-readable output)
-        if (flags.json !== 'object' && !flags.quiet) {
-          // 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';
-          // Convert absolute paths to relative paths for display
-          const contractPath = relative(process.cwd(), outputJsonPath);
-          const typesPath = relative(process.cwd(), outputDtsPath);
-          const header = formatStyledHeader({
-            command: 'contract emit',
-            description: 'Write your contract to JSON and sign it',
-            url: 'https://pris.ly/contract-emit',
-            details: [
-              { label: 'config', value: configPath },
-              { label: 'contract', value: contractPath },
-              { label: 'types', value: typesPath },
-            ],
-            flags,
-          });
-          console.log(header);
-        }
-
-        const stack = createControlPlaneStack({
-          target: config.target,
-          adapter: config.adapter,
-          driver: config.driver,
-          extensionPacks: config.extensionPacks,
-        });
-        const familyInstance = config.family.create(stack);
-
-        // Resolve contract source from config (user's config handles loading)
-        let contractRaw: unknown;
-        if (typeof contractConfig.source === 'function') {
-          contractRaw = await contractConfig.source();
-        } else {
-          contractRaw = contractConfig.source;
-        }
-
-        // Call emitContract on family instance (handles stripping mappings and validation internally)
-        const emitResult = await withSpinner(
-          () => familyInstance.emitContract({ contractIR: contractRaw }),
-          {
-            message: 'Emitting contract...',
-            flags,
-          },
-        );
-
-        // Create directories if needed
-        mkdirSync(dirname(outputJsonPath), { recursive: true });
-        mkdirSync(dirname(outputDtsPath), { recursive: true });
-
-        // Write the results to files
-        writeFileSync(outputJsonPath, emitResult.contractJson, 'utf-8');
-        writeFileSync(outputDtsPath, emitResult.contractDts, 'utf-8');
-
-        // Add blank line after all async operations if spinners were shown
-        if (!flags.quiet && flags.json !== 'object' && process.stdout.isTTY) {
-          console.log('');
-        }
-
-        // Return result with file paths for output formatting
-        return {
-          coreHash: emitResult.coreHash,
-          profileHash: emitResult.profileHash,
-          outDir: dirname(outputJsonPath),
-          files: {
-            json: outputJsonPath,
-            dts: outputDtsPath,
-          },
-          timings: {
-            total: 0, // Timing is handled by emitContract internally if needed
-          },
-        };
-      });
+      const result = await executeContractEmitCommand(options, flags, ui, startTime);
 
       // Handle result - formats output and returns exit code
-      const exitCode = handleResult(result, flags, (emitResult) => {
-        // Output based on flags
-        if (flags.json === 'object') {
-          // JSON output to stdout
-          console.log(formatEmitJson(emitResult));
+      const exitCode = handleResult(result, flags, ui, (emitResult) => {
+        if (flags.json) {
+          ui.output(formatEmitJson(emitResult));
         } else {
-          // Human-readable output to stdout
           const output = formatEmitOutput(emitResult, flags);
           if (output) {
-            console.log(output);
+            ui.log(output);
           }
-          // Output success message
           if (!flags.quiet) {
-            console.log(formatSuccessMessage(flags));
+            ui.success(formatSuccessMessage(flags));
           }
         }
       });

package/src/commands/contract-infer-paths.ts

@@ -0,0 +1,32 @@
+import { dirname, resolve } from 'pathe';
+
+interface ContractInferPathOptions {
+  readonly output?: string;
+  readonly config?: string;
+}
+
+/**
+ * Resolves the output path for the inferred PSL contract.
+ *
+ * Priority:
+ * 1. --output <path> flag (resolved relative to cwd)
+ * 2. contract.prisma next to config.contract.output
+ * 3. Canonical default: contract.prisma in the config directory
+ */
+export function resolveContractInferOutputPath(
+  options: ContractInferPathOptions,
+  contractOutput: string | undefined,
+): string {
+  const configDir = options.config
+    ? dirname(resolve(process.cwd(), options.config))
+    : process.cwd();
+
+  if (options.output) {
+    return resolve(process.cwd(), options.output);
+  }
+  if (contractOutput) {
+    const contractPath = resolve(configDir, contractOutput);
+    return resolve(dirname(contractPath), 'contract.prisma');
+  }
+  return resolve(configDir, 'contract.prisma');
+}

package/src/commands/contract-infer.ts

@@ -0,0 +1,131 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { printPsl } from '@prisma-next/psl-printer';
+import {
+  createPostgresDefaultMapping,
+  createPostgresTypeMap,
+  extractEnumInfo,
+  parseRawDefault,
+} from '@prisma-next/psl-printer/postgres';
+import { 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, schema, target, meta } = inspectResult.value;
+  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;
+}