@prisma-next/cli 0.3.0-pr.99.6 → 0.4.0-dev.1

package/src/cli.ts

@@ -1,13 +1,41 @@
 import { Command } from 'commander';
 import { createContractEmitCommand } from './commands/contract-emit';
+import { createContractInferCommand } from './commands/contract-infer';
+import { createInitCommand } from './commands/init';
+import { installShutdownHandlers } from './utils/shutdown';
+
+// Install SIGINT/SIGTERM handlers before anything else
+installShutdownHandlers();
+
 import { createDbInitCommand } from './commands/db-init';
-import { createDbIntrospectCommand } from './commands/db-introspect';
-import { createDbSchemaVerifyCommand } from './commands/db-schema-verify';
+import { createDbSchemaCommand } from './commands/db-schema';
 import { createDbSignCommand } from './commands/db-sign';
+import { createDbUpdateCommand } from './commands/db-update';
 import { createDbVerifyCommand } from './commands/db-verify';
+import { createMigrationApplyCommand } from './commands/migration-apply';
+import { createMigrationNewCommand } from './commands/migration-new';
+import { createMigrationPlanCommand } from './commands/migration-plan';
+import { createMigrationRefCommand } from './commands/migration-ref';
+import { createMigrationShowCommand } from './commands/migration-show';
+import { createMigrationStatusCommand } from './commands/migration-status';
+import { createMigrationVerifyCommand } from './commands/migration-verify';
 import { setCommandDescriptions } from './utils/command-helpers';
+import { formatCommandHelp, formatRootHelp } from './utils/formatters/help';
 import { parseGlobalFlags } from './utils/global-flags';
-import { formatCommandHelp, formatRootHelp } from './utils/output';
+import { suggestCommands } from './utils/suggest-command';
+
+/**
+ * Formats the "Did you mean ...?" hint for an unknown command.
+ */
+function formatSuggestion(input: string, candidates: readonly string[]): string {
+  const suggestions = suggestCommands(
+    input,
+    candidates.map((c) => c),
+  );
+  if (suggestions.length === 0) return '';
+  if (suggestions.length === 1) return `\nDid you mean ${suggestions[0]}?\n`;
+  return `\nDid you mean one of these?\n${suggestions.map((s) => `  ${s}`).join('\n')}\n`;
+}
 
 const program = new Command();
 
@@ -43,14 +71,11 @@ program.configureHelp({
 // Commands handle structured errors themselves via process.exit()
 program.exitOverride((err) => {
   if (err) {
-    // Help requests are not errors - allow Commander to output help and exit normally
-    // Commander throws errors with codes like 'commander.help', 'commander.helpDisplayed', or 'outputHelp'
     const errorCode = (err as { code?: string }).code;
     const errorMessage = String(err.message ?? '');
     const errorName = err.name ?? '';
 
-    // Check for unknown command errors first (before other checks)
-    // Commander.js uses code 'commander.unknownCommand' or error message contains 'unknown command'
+    // Unknown command/argument → exit 2 (CLI usage error)
     const isUnknownCommandError =
       errorCode === 'commander.unknownCommand' ||
       errorCode === 'commander.unknownArgument' ||
@@ -58,40 +83,34 @@ program.exitOverride((err) => {
         (errorMessage.includes('unknown command') || errorMessage.includes('unknown argument')));
     if (isUnknownCommandError) {
       const flags = parseGlobalFlags({});
-      // Extract the command/subcommand name from the error message
-      // Error message format: "unknown command 'command-name'"
       const match = errorMessage.match(/unknown command ['"]([^'"]+)['"]/);
       const commandName = match ? match[1] : process.argv[3] || process.argv[2] || 'unknown';
 
-      // Determine which command context we're in
-      // Check if the first argument is a recognized parent command
       const firstArg = process.argv[2];
       const parentCommand = firstArg
         ? program.commands.find((cmd) => cmd.name() === firstArg)
         : undefined;
 
       if (parentCommand && commandName !== firstArg) {
-        // Unrecognized subcommand - show parent command help
-        // eslint-disable-next-line no-console
-        console.error(`Unknown command: ${commandName}`);
-        // eslint-disable-next-line no-console
-        console.error('');
+        const subNames = parentCommand.commands.map((c) => c.name());
+        process.stderr.write(
+          `Unknown command: ${commandName}${formatSuggestion(commandName!, subNames)}\n`,
+        );
         const helpText = formatCommandHelp({ command: parentCommand, flags });
-        // eslint-disable-next-line no-console
-        console.log(helpText);
+        process.stderr.write(`${helpText}\n`);
       } else {
-        // Unrecognized top-level command - show root help
-        // eslint-disable-next-line no-console
-        console.error(`Unknown command: ${commandName}`);
-        // eslint-disable-next-line no-console
-        console.error('');
+        const topNames = program.commands.map((c) => c.name());
+        process.stderr.write(
+          `Unknown command: ${commandName}${formatSuggestion(commandName!, topNames)}\n`,
+        );
         const helpText = formatRootHelp({ program, flags });
-        // eslint-disable-next-line no-console
-        console.log(helpText);
+        process.stderr.write(`${helpText}\n`);
       }
-      process.exit(1);
+      process.exit(2);
       return;
     }
+
+    // Help requests → exit 0
     const isHelpError =
       errorCode === 'commander.help' ||
       errorCode === 'commander.helpDisplayed' ||
@@ -103,25 +122,22 @@ program.exitOverride((err) => {
       process.exit(0);
       return;
     }
-    // Missing required arguments/subcommands - show help and exit with 0
-    // Commander throws errors with code 'commander.missingArgument' or 'commander.missingMandatoryOptionValue'
-    // or when a command with subcommands is called without a subcommand
+
+    // Missing required arguments → exit 2 (CLI usage error)
     const isMissingArgumentError =
       errorCode === 'commander.missingArgument' ||
       errorCode === 'commander.missingMandatoryOptionValue' ||
       (errorName === 'CommanderError' &&
         (errorMessage.includes('missing') || errorMessage.includes('required')));
     if (isMissingArgumentError) {
-      // Help was already displayed by Commander.js, just exit with 0
-      process.exit(0);
+      process.exit(2);
       return;
     }
-    // Unhandled error - fail fast with exit code 1
-    // eslint-disable-next-line no-console
-    console.error(`Unhandled error: ${err.message}`);
+
+    // Unhandled error → exit 1
+    process.stderr.write(`Unhandled error: ${err.message}\n`);
     if (err.stack) {
-      // eslint-disable-next-line no-console
-      console.error(err.stack);
+      process.stderr.write(`${err.stack}\n`);
     }
     process.exit(1);
   }
@@ -148,6 +164,10 @@ contractCommand.configureHelp({
 const contractEmitCommand = createContractEmitCommand();
 contractCommand.addCommand(contractEmitCommand);
 
+// Add infer subcommand to contract
+const contractInferCommand = createContractInferCommand();
+contractCommand.addCommand(contractInferCommand);
+
 // Register contract command
 program.addCommand(contractCommand);
 
@@ -175,13 +195,13 @@ dbCommand.addCommand(dbVerifyCommand);
 const dbInitCommand = createDbInitCommand();
 dbCommand.addCommand(dbInitCommand);
 
-// Add introspect subcommand to db
-const dbIntrospectCommand = createDbIntrospectCommand();
-dbCommand.addCommand(dbIntrospectCommand);
+// Add update subcommand to db
+const dbUpdateCommand = createDbUpdateCommand();
+dbCommand.addCommand(dbUpdateCommand);
 
-// Add schema-verify subcommand to db
-const dbSchemaVerifyCommand = createDbSchemaVerifyCommand();
-dbCommand.addCommand(dbSchemaVerifyCommand);
+// Add schema subcommand to db
+const dbSchemaCommand = createDbSchemaCommand();
+dbCommand.addCommand(dbSchemaCommand);
 
 // Add sign subcommand to db
 const dbSignCommand = createDbSignCommand();
@@ -190,6 +210,49 @@ dbCommand.addCommand(dbSignCommand);
 // Register db command
 program.addCommand(dbCommand);
 
+// Register migration subcommand
+const migrationCommand = new Command('migration');
+setCommandDescriptions(
+  migrationCommand,
+  'On-disk migration management commands',
+  'Plan, apply, verify, and scaffold on-disk migration packages. Migrations are\n' +
+    'contract-to-contract edges stored as versioned directories under migrations/.',
+);
+migrationCommand.configureHelp({
+  formatHelp: (cmd) => {
+    const flags = parseGlobalFlags({});
+    return formatCommandHelp({ command: cmd, flags });
+  },
+  subcommandDescription: () => '',
+});
+
+const migrationPlanCommand = createMigrationPlanCommand();
+migrationCommand.addCommand(migrationPlanCommand);
+
+const migrationNewCommand = createMigrationNewCommand();
+migrationCommand.addCommand(migrationNewCommand);
+
+const migrationShowCommand = createMigrationShowCommand();
+migrationCommand.addCommand(migrationShowCommand);
+
+const migrationStatusCommand = createMigrationStatusCommand();
+migrationCommand.addCommand(migrationStatusCommand);
+
+const migrationVerifyCommand = createMigrationVerifyCommand();
+migrationCommand.addCommand(migrationVerifyCommand);
+
+const migrationApplyCommand = createMigrationApplyCommand();
+migrationCommand.addCommand(migrationApplyCommand);
+
+const migrationRefCommand = createMigrationRefCommand();
+migrationCommand.addCommand(migrationRefCommand);
+
+program.addCommand(migrationCommand);
+
+// Register init command (top-level, not nested)
+const initCommand = createInitCommand();
+program.addCommand(initCommand);
+
 // Create help command
 const helpCommand = new Command('help')
   .description('Show usage instructions')
@@ -202,8 +265,8 @@ const helpCommand = new Command('help')
   .action(() => {
     const flags = parseGlobalFlags({});
     const helpText = formatRootHelp({ program, flags });
-    // eslint-disable-next-line no-console
-    console.log(helpText);
+    // Help is decoration → stderr
+    process.stderr.write(`${helpText}\n`);
     process.exit(0);
   });
 
@@ -213,8 +276,7 @@ program.addCommand(helpCommand);
 program.action(() => {
   const flags = parseGlobalFlags({});
   const helpText = formatRootHelp({ program, flags });
-  // eslint-disable-next-line no-console
-  console.log(helpText);
+  process.stderr.write(`${helpText}\n`);
   process.exit(0);
 });
 
@@ -225,8 +287,8 @@ if (args.length > 0) {
   const commandName = args[0];
   // Handle version option explicitly since we suppress default output
   if (commandName === '--version' || commandName === '-V') {
-    // eslint-disable-next-line no-console
-    console.log(program.version());
+    // Version is data → stdout
+    process.stdout.write(`${program.version()}\n`);
     process.exit(0);
   }
   // Skip command check for global options like --help, -h
@@ -236,22 +298,20 @@ if (args.length > 0) {
     const command = program.commands.find((cmd) => cmd.name() === commandName);
 
     if (!command) {
-      // Unrecognized command - show error message and usage
+      // Unrecognized command → exit 2 (CLI usage error)
       const flags = parseGlobalFlags({});
-      // eslint-disable-next-line no-console
-      console.error(`Unknown command: ${commandName}`);
-      // eslint-disable-next-line no-console
-      console.error('');
+      const topNames = program.commands.map((c) => c.name());
+      process.stderr.write(
+        `Unknown command: ${commandName}${formatSuggestion(commandName!, topNames)}\n`,
+      );
       const helpText = formatRootHelp({ program, flags });
-      // eslint-disable-next-line no-console
-      console.log(helpText);
-      process.exit(1);
+      process.stderr.write(`${helpText}\n`);
+      process.exit(2);
     } else if (command.commands.length > 0 && args.length === 1) {
       // Parent command called with no subcommand - show help and exit with 0
       const flags = parseGlobalFlags({});
       const helpText = formatCommandHelp({ command, flags });
-      // eslint-disable-next-line no-console
-      console.log(helpText);
+      process.stderr.write(`${helpText}\n`);
       process.exit(0);
     }
   }

package/src/commands/contract-emit.ts

@@ -1,50 +1,79 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, relative, resolve } from 'node:path';
-import { errorContractConfigMissing } from '@prisma-next/core-control-plane/errors';
+import { errorContractConfigMissing } from '@prisma-next/errors/control';
 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 { createControlClient } from '../control-api/client';
-import type { EmitContractSource, EmitFailure } from '../control-api/types';
-import { CliStructuredError, errorRuntime, errorUnexpected } from '../utils/cli-errors';
-import { setCommandDescriptions } from '../utils/command-helpers';
-import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
+import type { EmitFailure } from '../control-api/types';
+import {
+  CliStructuredError,
+  errorContractValidationFailed,
+  errorRuntime,
+  errorUnexpected,
+} from '../utils/cli-errors';
+import {
+  addGlobalOptions,
+  setCommandDescriptions,
+  setCommandExamples,
+} from '../utils/command-helpers';
 import {
   type EmitContractResult,
-  formatCommandHelp,
   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 { 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): CliStructuredError {
+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 is invalid',
-      fix: 'Check your contract source configuration in prisma-next.config.ts',
+      why: failure.why ?? 'Contract source provider failed',
+      fix: 'Check your contract source provider in prisma-next.config.ts and ensure it returns Result<Contract, 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',
@@ -63,6 +92,7 @@ function mapEmitFailure(failure: EmitFailure): CliStructuredError {
 async function executeContractEmitCommand(
   options: ContractEmitOptions,
   flags: GlobalFlags,
+  ui: TerminalUI,
   startTime: number,
 ): Promise<Result<EmitContractResult, CliStructuredError>> {
   // Load config
@@ -81,11 +111,15 @@ async function executeContractEmitCommand(
     );
   }
 
+  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: ..., types: ... }',
+        why: 'Config.contract is required for emit. Define it in your config: contract: { source: ..., output: ... }',
       }),
     );
   }
@@ -94,28 +128,34 @@ async function executeContractEmitCommand(
   const contractConfig = config.contract;
 
   // Resolve artifact paths from config (already normalized by defineConfig() with defaults)
-  if (!contractConfig.output || !contractConfig.types) {
+  if (!contractConfig.output) {
     return notOk(
       errorContractConfigMissing({
-        why: 'Contract config must have output and types paths. This should not happen if defineConfig() was used.',
+        why: 'Contract config must have output path. This should not happen if defineConfig() was used.',
       }),
     );
   }
-  const outputJsonPath = resolve(contractConfig.output);
-  const outputDtsPath = resolve(contractConfig.types);
+  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 (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
+  // 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: 'Write your contract to JSON and sign it',
+      description: 'Emit your contract artifacts',
       url: 'https://pris.ly/contract-emit',
       details: [
         { label: 'config', value: configPath },
@@ -124,7 +164,7 @@ async function executeContractEmitCommand(
       ],
       flags,
     });
-    console.log(header);
+    ui.stderr(header);
   }
 
   // Create control client (no driver needed for emit)
@@ -136,29 +176,21 @@ async function executeContractEmitCommand(
   });
 
   // Create progress adapter
-  const onProgress = createProgressAdapter({ flags });
+  const onProgress = createProgressAdapter({ ui, flags });
 
   try {
-    // Convert user config source to discriminated union
-    // Type assertion is safe: we check typeof to determine if it's a function
-    const source: EmitContractSource =
-      typeof contractConfig.source === 'function'
-        ? { kind: 'loader', load: contractConfig.source as () => unknown | Promise<unknown> }
-        : { kind: 'value', value: contractConfig.source };
-
     // Call emit with progress callback
     const result = await client.emit({
       contractConfig: {
-        source,
+        sourceProvider: contractConfig.source,
         output: outputJsonPath,
-        types: outputDtsPath,
       },
       onProgress,
     });
 
     // Handle failures by mapping to CLI structured error
     if (!result.ok) {
-      return notOk(mapEmitFailure(result.failure));
+      return notOk(mapEmitFailure(result.failure, { configPath }));
     }
 
     // Create directories if needed
@@ -169,14 +201,17 @@ async function executeContractEmitCommand(
     writeFileSync(outputJsonPath, result.value.contractJson, 'utf-8');
     writeFileSync(outputDtsPath, result.value.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('');
+    // Validate that contract.d.ts type imports are resolvable
+    const { validateContractDeps } = await import('../utils/validate-contract-deps');
+    const depsValidation = validateContractDeps(result.value.contractDts, dirname(outputDtsPath));
+    if (depsValidation.warning) {
+      ui.warn(depsValidation.warning);
     }
 
     // Convert success result to CLI output format
     const emitResult: EmitContractResult = {
-      coreHash: result.value.coreHash,
+      storageHash: result.value.storageHash,
+      ...(result.value.executionHash ? { executionHash: result.value.executionHash } : {}),
       profileHash: result.value.profileHash,
       outDir: dirname(outputJsonPath),
       files: {
@@ -208,47 +243,35 @@ 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 executeContractEmitCommand(options, flags, startTime);
+      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');
+}