@prisma-next/cli 0.4.0-dev.9 → 0.5.0-dev.1

package/src/commands/migration-plan.ts

@@ -1,10 +1,15 @@
 import { readFile } from 'node:fs/promises';
 import type { Contract } from '@prisma-next/contract/types';
-import { createControlStack } from '@prisma-next/framework-components/control';
+import { getEmittedArtifactPaths } from '@prisma-next/emitter';
+import {
+  createControlStack,
+  type MigrationPlanOperation,
+} from '@prisma-next/framework-components/control';
+import { computeMigrationId } from '@prisma-next/migration-tools/attestation';
 import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
 import { findLatestMigration } from '@prisma-next/migration-tools/dag';
 import {
-  copyContractToMigrationDir,
+  copyFilesWithRename,
   formatMigrationDirName,
   writeMigrationPackage,
 } from '@prisma-next/migration-tools/io';
@@ -15,8 +20,6 @@ import { Command } from 'commander';
 import { join, relative } from 'pathe';
 import { loadConfig } from '../config-loader';
 import { extractSqlDdl } from '../control-api/operations/extract-sql-ddl';
-import { emitMigration } from '../lib/migration-emit';
-import { migrationStrategy } from '../lib/migration-strategy';
 import {
   type CliErrorConflict,
   CliStructuredError,
@@ -54,7 +57,6 @@ export interface MigrationPlanResult {
   readonly noOp: boolean;
   readonly from: string;
   readonly to: string;
-  readonly migrationId?: string;
   readonly dir?: string;
   readonly operations: readonly {
     readonly id: string;
@@ -63,6 +65,12 @@ export interface MigrationPlanResult {
   }[];
   readonly sql?: readonly string[];
   readonly summary: string;
+  /**
+   * When true, `migration.ts` was written but contains unfilled
+   * `placeholder(...)` calls. The user must edit the file and then run
+   * `node migration.ts` to self-emit `ops.json` / `migration.json`.
+   */
+  readonly pendingPlaceholders?: boolean;
   readonly timings: {
     readonly total: number;
   };
@@ -166,20 +174,10 @@ async function executeMigrationPlanCommand(
   // Read existing migrations and determine "from" contract
   let fromContract: Contract | null = null;
   let fromHash: string = EMPTY_CONTRACT_HASH;
+  let fromContractSourceDir: string | null = null;
 
   try {
-    const { attested: bundles, drafts, graph } = await loadAllBundles(migrationsDir);
-
-    // Check if a draft migration already targets this contract
-    const existingDraft = drafts.find((d) => d.manifest.to === toStorageHash);
-    if (existingDraft) {
-      return notOk(
-        errorRuntime('A draft migration to this contract already exists', {
-          why: `Draft migration at "${existingDraft.dirName}" already targets ${toStorageHash}`,
-          fix: `Run 'prisma-next migration emit --dir ${migrationsRelative}/${existingDraft.dirName}' to attest it, or delete it and re-plan.`,
-        }),
-      );
-    }
+    const { bundles, graph } = await loadAllBundles(migrationsDir);
 
     if (options.from) {
       const resolved = resolveBundleByPrefix(bundles, options.from);
@@ -199,6 +197,7 @@ async function executeMigrationPlanCommand(
       }
       fromHash = resolved.value.manifest.to;
       fromContract = resolved.value.manifest.toContract;
+      fromContractSourceDir = resolved.value.dirPath;
     } else {
       const latestMigration = findLatestMigration(graph);
       if (latestMigration) {
@@ -206,6 +205,7 @@ async function executeMigrationPlanCommand(
         const leafPkg = bundles.find((p) => p.manifest.migrationId === latestMigration.migrationId);
         if (leafPkg) {
           fromContract = leafPkg.manifest.toContract;
+          fromContractSourceDir = leafPkg.dirPath;
         }
       }
     }
@@ -245,18 +245,15 @@ async function executeMigrationPlanCommand(
     [config.target, config.adapter, ...(config.extensionPacks ?? [])],
   );
 
-  const strategy = migrationStrategy(migrations, config.target.targetId);
-
   // Build manifest and write migration package
   const timestamp = new Date();
   const slug = options.name ?? 'migration';
   const dirName = formatMigrationDirName(timestamp, slug);
   const packageDir = join(migrationsDir, dirName);
 
-  const manifest: MigrationManifest = {
+  const baseManifest: Omit<MigrationManifest, 'migrationId'> = {
     from: fromHash,
     to: toStorageHash,
-    migrationId: null,
     kind: 'regular',
     fromContract,
     toContract: toContractJson,
@@ -264,41 +261,42 @@ async function executeMigrationPlanCommand(
       used: [],
       applied: [],
       plannerVersion: '2.0.0',
-      planningStrategy: strategy === 'descriptor' ? 'descriptors' : 'class-based',
     },
     labels: [],
     createdAt: timestamp.toISOString(),
   };
 
-  const scaffoldContext = {
-    packageDir,
-    contractJsonPath: contractPathAbsolute,
-    fromHash,
-    toHash: toStorageHash,
-  };
-
   try {
-    let migrationTsContent: string;
+    const stack = createControlStack(config);
+    const familyInstance = config.family.create(stack);
+    const planner = migrations.createPlanner(familyInstance);
+    const fromSchema = migrations.contractToSchema(fromContract, frameworkComponents);
+    const plannerResult = planner.plan({
+      contract: toContractJson,
+      schema: fromSchema,
+      policy: { allowedOperationClasses: ['additive', 'widening', 'destructive', 'data'] },
+      fromHash,
+      fromContract,
+      frameworkComponents,
+    });
+    if (plannerResult.kind === 'failure') {
+      return notOk(
+        errorMigrationPlanningFailed({
+          conflicts: plannerResult.conflicts as readonly CliErrorConflict[],
+        }),
+      );
+    }
 
-    if (strategy === 'descriptor') {
-      if (!migrations.planWithDescriptors || !migrations.renderDescriptorTypeScript) {
-        throw errorTargetMigrationNotSupported({
-          why: `Target "${config.target.targetId}" advertises descriptor flow but is missing required hooks`,
-        });
-      }
-      const descriptorResult = migrations.planWithDescriptors({
-        fromContract,
-        toContract: toContractJson,
-        frameworkComponents,
-      });
-      if (!descriptorResult.ok) {
-        return notOk(
-          errorMigrationPlanningFailed({
-            conflicts: descriptorResult.conflicts as readonly CliErrorConflict[],
-          }),
-        );
-      }
-      if (descriptorResult.descriptors.length === 0) {
+    // Accessing .operations triggers toOp() on each call. If any call
+    // is a DataTransformCall with an unfilled placeholder stub, toOp()
+    // throws PN-MIG-2001. We catch that here so the migration can still
+    // be scaffolded with `ops: []`; the user fills the placeholder, then
+    // re-runs `node migration.ts` to attest with the real ops.
+    let plannedOps: readonly MigrationPlanOperation[] = [];
+    let hasPlaceholders = false;
+    try {
+      plannedOps = plannerResult.plan.operations;
+      if (plannedOps.length === 0) {
         return notOk(
           errorMigrationPlanningFailed({
             conflicts: [
@@ -312,75 +310,74 @@ async function executeMigrationPlanCommand(
           }),
         );
       }
-      migrationTsContent = migrations.renderDescriptorTypeScript(
-        descriptorResult.descriptors,
-        scaffoldContext,
-      );
-    } else {
-      const stack = createControlStack(config);
-      const familyInstance = config.family.create(stack);
-      const planner = migrations.createPlanner(familyInstance);
-      const fromSchema = migrations.contractToSchema(fromContract, frameworkComponents);
-      const plannerResult = planner.plan({
-        contract: toContractJson,
-        schema: fromSchema,
-        policy: { allowedOperationClasses: ['additive', 'widening', 'destructive', 'data'] },
-        fromHash,
-        frameworkComponents,
-      });
-      if (plannerResult.kind === 'failure') {
-        return notOk(
-          errorMigrationPlanningFailed({
-            conflicts: plannerResult.conflicts as readonly CliErrorConflict[],
-          }),
-        );
-      }
-      if (plannerResult.plan.operations.length === 0) {
-        return notOk(
-          errorMigrationPlanningFailed({
-            conflicts: [
-              {
-                kind: 'unsupportedChange',
-                summary:
-                  'Contract changed but planner produced no operations. ' +
-                  'This indicates unsupported or ignored changes.',
-              },
-            ],
-          }),
-        );
+    } catch (e) {
+      if (CliStructuredError.is(e) && e.domain === 'MIG' && e.code === '2001') {
+        hasPlaceholders = true;
+      } else {
+        throw e;
       }
-      migrationTsContent = plannerResult.plan.renderTypeScript();
     }
 
-    await writeMigrationPackage(packageDir, manifest, []);
-    await copyContractToMigrationDir(packageDir, contractPathAbsolute);
+    const migrationTsContent = plannerResult.plan.renderTypeScript();
+
+    // Always-attest: compute migrationId over (manifest, ops). When
+    // placeholders blocked lowering, ops is `[]` and the id hashes over
+    // the empty list — re-emitting after the user fills the placeholder
+    // produces a different id (over the real ops). This is intentional;
+    // there is no on-disk "draft" state.
+    const opsForWrite = hasPlaceholders ? [] : plannedOps;
+    const manifest: MigrationManifest = {
+      ...baseManifest,
+      migrationId: computeMigrationId(baseManifest, opsForWrite),
+    };
+
+    await writeMigrationPackage(packageDir, manifest, opsForWrite);
+    const destinationArtifacts = getEmittedArtifactPaths(contractPathAbsolute);
+    await copyFilesWithRename(packageDir, [
+      { sourcePath: destinationArtifacts.jsonPath, destName: 'end-contract.json' },
+      { sourcePath: destinationArtifacts.dtsPath, destName: 'end-contract.d.ts' },
+    ]);
+    if (fromContractSourceDir !== null) {
+      const sourceArtifacts = getEmittedArtifactPaths(
+        join(fromContractSourceDir, 'end-contract.json'),
+      );
+      await copyFilesWithRename(packageDir, [
+        { sourcePath: sourceArtifacts.jsonPath, destName: 'start-contract.json' },
+        { sourcePath: sourceArtifacts.dtsPath, destName: 'start-contract.d.ts' },
+      ]);
+    }
     await writeMigrationTs(packageDir, migrationTsContent);
 
-    // Always run emit inline. If migration.ts contains unfilled
-    // placeholders (e.g. user must hand-author a dataTransform body),
-    // emitMigration throws errorUnfilledPlaceholder (PN-MIG-2001) and
-    // we propagate that structured error to the user.
-    const { operations, migrationId } = await emitMigration(packageDir, {
-      targetId: config.target.targetId,
-      migrations,
-      frameworkComponents,
-    });
+    if (hasPlaceholders) {
+      const result: MigrationPlanResult = {
+        ok: true,
+        noOp: false,
+        from: fromHash,
+        to: toStorageHash,
+        dir: relative(process.cwd(), packageDir),
+        operations: [],
+        pendingPlaceholders: true,
+        summary:
+          'Planned migration with placeholder(s) — edit migration.ts then run `node migration.ts` to self-emit',
+        timings: { total: Date.now() - startTime },
+      };
+      return ok(result);
+    }
 
-    const sql = extractSqlDdl(operations);
+    const sql = extractSqlDdl(plannedOps);
     const result: MigrationPlanResult = {
       ok: true,
       noOp: false,
       from: fromHash,
       to: toStorageHash,
-      migrationId,
       dir: relative(process.cwd(), packageDir),
-      operations: operations.map((op) => ({
+      operations: plannedOps.map((op) => ({
         id: op.id,
         label: op.label,
         operationClass: op.operationClass,
       })),
       sql,
-      summary: `Planned ${operations.length} operation(s)`,
+      summary: `Planned ${plannedOps.length} operation(s)`,
       timings: { total: Date.now() - startTime },
     };
     return ok(result);
@@ -442,6 +439,22 @@ function formatMigrationPlanOutput(result: MigrationPlanResult, flags: GlobalFla
     return lines.join('\n');
   }
 
+  if (result.pendingPlaceholders) {
+    lines.push(`${yellow_('⚠')} ${result.summary}`);
+    lines.push('');
+    lines.push(dim_(`from: ${result.from}`));
+    lines.push(dim_(`to:   ${result.to}`));
+    if (result.dir) {
+      lines.push(dim_(`dir:  ${result.dir}`));
+    }
+    lines.push('');
+    lines.push(
+      'Open migration.ts and replace each `placeholder(...)` call with your actual query.',
+    );
+    lines.push(`Then run: ${green_(`node ${result.dir ?? '<dir>'}/migration.ts`)}`);
+    return lines.join('\n');
+  }
+
   lines.push(`${green_('✔')} ${result.summary}`);
   lines.push('');
 
@@ -470,13 +483,15 @@ function formatMigrationPlanOutput(result: MigrationPlanResult, flags: GlobalFla
 
   lines.push(dim_(`from:   ${result.from}`));
   lines.push(dim_(`to:     ${result.to}`));
-  if (result.migrationId) {
-    lines.push(dim_(`migrationId: ${result.migrationId}`));
-  }
   if (result.dir) {
     lines.push(dim_(`dir:    ${result.dir}`));
   }
 
+  lines.push('');
+  lines.push(
+    `Next: ${green_(`node ${result.dir ?? '<dir>'}/migration.ts`)} to emit ops.json and attest migrationId before running ${green_('prisma-next migration apply')}.`,
+  );
+
   if (result.sql && result.sql.length > 0) {
     lines.push('');
     lines.push(dim_('DDL preview'));

package/src/commands/migration-show.ts

@@ -2,7 +2,7 @@ import type { MigrationPlanOperation } from '@prisma-next/framework-components/c
 import { findLatestMigration, reconstructGraph } from '@prisma-next/migration-tools/dag';
 import { readMigrationPackage, readMigrationsDir } from '@prisma-next/migration-tools/io';
 import type { MigrationBundle } from '@prisma-next/migration-tools/types';
-import { isAttested, MigrationToolsError } from '@prisma-next/migration-tools/types';
+import { MigrationToolsError } from '@prisma-next/migration-tools/types';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { relative, resolve } from 'pathe';
@@ -31,7 +31,7 @@ export interface MigrationShowResult {
   readonly dirPath: string;
   readonly from: string;
   readonly to: string;
-  readonly migrationId: string | null;
+  readonly migrationId: string;
   readonly kind: string;
   readonly createdAt: string;
   readonly operations: readonly {
@@ -52,8 +52,7 @@ export function resolveByHashPrefix(
   prefix: string,
 ): Result<MigrationBundle, CliStructuredError> {
   const normalizedPrefix = prefix.startsWith('sha256:') ? prefix : `sha256:${prefix}`;
-  const attested = packages.filter((p) => typeof p.manifest.migrationId === 'string');
-  const matches = attested.filter((p) => p.manifest.migrationId!.startsWith(normalizedPrefix));
+  const matches = packages.filter((p) => p.manifest.migrationId.startsWith(normalizedPrefix));
 
   if (matches.length === 1) {
     return ok(matches[0]!);
@@ -62,7 +61,7 @@ export function resolveByHashPrefix(
   if (matches.length === 0) {
     return notOk(
       errorRuntime('No migration found matching prefix', {
-        why: `No attested migration has a migrationId starting with "${normalizedPrefix}"`,
+        why: `No migration has a migrationId starting with "${normalizedPrefix}"`,
         fix: 'Run `prisma-next migration show` (no argument) to see the latest migration, or check the migrations directory for available packages.',
       }),
     );
@@ -132,16 +131,7 @@ async function executeMigrationShowCommand(
         if (!resolved.ok) return resolved;
         pkg = resolved.value;
       } else {
-        const attested = allPackages.filter(isAttested);
-        if (attested.length === 0) {
-          return notOk(
-            errorRuntime('No attested migrations found', {
-              why: `All migrations in ${migrationsRelative} are drafts (migrationId: null)`,
-              fix: 'Run `prisma-next migration emit --dir <path>` to attest a draft migration.',
-            }),
-          );
-        }
-        const graph = reconstructGraph(attested);
+        const graph = reconstructGraph(allPackages);
         const latestMigration = findLatestMigration(graph);
         if (!latestMigration) {
           return notOk(
@@ -151,7 +141,7 @@ async function executeMigrationShowCommand(
             }),
           );
         }
-        const leafPkg = attested.find(
+        const leafPkg = allPackages.find(
           (p) => p.manifest.migrationId === latestMigration.migrationId,
         );
         if (!leafPkg) {

package/src/commands/migration-status.ts

@@ -8,8 +8,7 @@ import {
 import type { Refs } from '@prisma-next/migration-tools/refs';
 import { readRefs, resolveRef } from '@prisma-next/migration-tools/refs';
 import type {
-  AttestedMigrationBundle,
-  DraftMigrationBundle,
+  MigrationBundle,
   MigrationChainEntry,
   MigrationGraph,
 } from '@prisma-next/migration-tools/types';
@@ -62,7 +61,7 @@ export interface MigrationStatusEntry {
   readonly dirName: string;
   readonly from: string;
   readonly to: string;
-  readonly migrationId: string | null;
+  readonly migrationId: string;
   readonly operationCount: number;
   readonly operationSummary: string;
   readonly hasDestructive: boolean;
@@ -87,7 +86,7 @@ export interface MigrationStatusResult {
     readonly refName?: string;
     readonly selectedPath: readonly {
       readonly dirName: string;
-      readonly migrationId: string | null;
+      readonly migrationId: string;
       readonly from: string;
       readonly to: string;
     }[];
@@ -95,8 +94,7 @@ export interface MigrationStatusResult {
   readonly summary: string;
   readonly diagnostics: readonly StatusDiagnostic[];
   readonly graph?: MigrationGraph;
-  readonly bundles?: readonly AttestedMigrationBundle[];
-  readonly drafts?: readonly DraftMigrationBundle[];
+  readonly bundles?: readonly MigrationBundle[];
   readonly edgeStatuses?: readonly EdgeStatus[];
   readonly activeRefHash?: string;
   readonly activeRefName?: string;
@@ -227,7 +225,7 @@ export function deriveEdgeStatuses(
  */
 function buildMigrationEntries(
   chain: readonly MigrationChainEntry[],
-  packages: readonly AttestedMigrationBundle[],
+  packages: readonly MigrationBundle[],
   mode: 'online' | 'offline',
   markerHash: string | undefined,
   edgeStatuses?: readonly EdgeStatus[],
@@ -436,11 +434,10 @@ async function executeMigrationStatusCommand(
     });
   }
 
-  let attested: readonly AttestedMigrationBundle[];
-  let drafts: readonly DraftMigrationBundle[];
+  let bundles: readonly MigrationBundle[];
   let graph: MigrationGraph;
   try {
-    ({ attested, drafts, graph } = await loadAllBundles(migrationsDir));
+    ({ bundles, graph } = await loadAllBundles(migrationsDir));
   } catch (error) {
     if (MigrationToolsError.is(error)) {
       return notOk(
@@ -454,18 +451,7 @@ async function executeMigrationStatusCommand(
     );
   }
 
-  if (drafts.length > 0) {
-    diagnostics.push({
-      code: 'MIGRATION.DRAFTS',
-      severity: 'warn',
-      message: `${drafts.length} draft migration(s) found: ${drafts.map((d) => d.dirName).join(', ')}`,
-      hints: [
-        "Run 'prisma-next migration emit --dir <path>' to attest draft migrations before applying",
-      ],
-    });
-  }
-
-  if (attested.length === 0) {
+  if (bundles.length === 0) {
     if (contractHash !== EMPTY_CONTRACT_HASH) {
       diagnostics.push({
         code: 'CONTRACT.AHEAD',
@@ -576,7 +562,7 @@ async function executeMigrationStatusCommand(
       migrations: [],
       targetHash: EMPTY_CONTRACT_HASH,
       contractHash,
-      summary: `${attested.length} migration(s) on disk`,
+      summary: `${bundles.length} migration(s) on disk`,
       diagnostics,
       markerHash,
       ...(statusRefs.length > 0 ? { refs: statusRefs } : {}),
@@ -616,12 +602,12 @@ async function executeMigrationStatusCommand(
       migrations: [],
       targetHash: EMPTY_CONTRACT_HASH,
       contractHash,
-      summary: `${attested.length} migration(s) on disk`,
+      summary: `${bundles.length} migration(s) on disk`,
       diagnostics,
       ...ifDefined('markerHash', markerHash),
       ...(statusRefs.length > 0 ? { refs: statusRefs } : {}),
       graph,
-      bundles: attested,
+      bundles,
       diverged: true,
     });
   }
@@ -638,7 +624,7 @@ async function executeMigrationStatusCommand(
   }
 
   const edgeStatuses = deriveEdgeStatuses(graph, targetHash, contractHash, markerHash, mode);
-  const entries = buildMigrationEntries(chain, attested, mode, markerHash, edgeStatuses);
+  const entries = buildMigrationEntries(chain, bundles, mode, markerHash, edgeStatuses);
 
   const pendingCount = edgeStatuses.filter((e) => e.status === 'pending').length;
   const appliedCount = edgeStatuses.filter((e) => e.status === 'applied').length;
@@ -646,7 +632,7 @@ async function executeMigrationStatusCommand(
   let summary: string;
   if (mode === 'online') {
     if (markerHash !== undefined && !graph.nodes.has(markerHash) && markerHash === contractHash) {
-      summary = `${attested.length} migration(s) on disk`;
+      summary = `${bundles.length} migration(s) on disk`;
     } else if (activeRefHash && markerHash !== undefined) {
       summary = summarizeRefDistance(graph, markerHash, activeRefHash, activeRefName!);
     } else if (pendingCount === 0) {
@@ -706,8 +692,7 @@ async function executeMigrationStatusCommand(
     ...(statusRefs.length > 0 ? { refs: statusRefs } : {}),
     ...ifDefined('pathDecision', pathDecision),
     graph,
-    bundles: attested,
-    ...(drafts.length > 0 ? { drafts } : {}),
+    bundles,
     edgeStatuses,
     ...ifDefined('activeRefHash', activeRefHash),
     ...ifDefined('activeRefName', activeRefName),
@@ -768,11 +753,6 @@ export function createMigrationStatusCommand(): Command {
               activeRefHash: statusResult.activeRefHash,
               activeRefName: statusResult.activeRefName,
               edgeStatuses: statusResult.edgeStatuses,
-              draftEdges: statusResult.drafts?.map((d) => ({
-                from: d.manifest.from,
-                to: d.manifest.to,
-                dirName: d.dirName,
-              })),
             });
 
             const graphToRender =

package/src/config-loader.ts

@@ -1,4 +1,3 @@
-import { dirname, resolve } from 'node:path';
 import type { PrismaNextConfig } from '@prisma-next/config/config-types';
 import { ConfigValidationError, validateConfig } from '@prisma-next/config/config-validation';
 import {
@@ -6,7 +5,41 @@ import {
   errorConfigValidation,
   errorUnexpected,
 } from '@prisma-next/errors/control';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { loadConfig as loadConfigC12 } from 'c12';
+import { dirname, resolve } from 'pathe';
+import { finalizeConfig } from './config-path-validation';
+
+async function loadValidatedConfig(configPath?: string): Promise<PrismaNextConfig> {
+  const cwd = process.cwd();
+  const resolvedConfigPath = configPath ? resolve(cwd, configPath) : undefined;
+  const configCwd = resolvedConfigPath ? dirname(resolvedConfigPath) : cwd;
+
+  const result = await loadConfigC12<PrismaNextConfig>({
+    name: 'prisma-next',
+    ...ifDefined('configFile', resolvedConfigPath),
+    cwd: configCwd,
+  });
+
+  // When a specific config file was requested, verify it was actually loaded
+  // (c12 falls back to searching by name if the specified file doesn't exist)
+  if (resolvedConfigPath && result.configFile !== resolvedConfigPath) {
+    throw errorConfigFileNotFound(resolvedConfigPath);
+  }
+
+  // Check if config is missing or empty (c12 may return empty object when file doesn't exist)
+  if (!result.config || Object.keys(result.config).length === 0) {
+    // Use c12's configFile if available, otherwise use explicit configPath, otherwise omit path
+    const displayPath = result.configFile || resolvedConfigPath || configPath;
+    throw errorConfigFileNotFound(displayPath);
+  }
+
+  // Validate config structure
+  validateConfig(result.config);
+
+  const loadedConfigDir = result.configFile ? dirname(result.configFile) : configCwd;
+  return finalizeConfig(result.config, loadedConfigDir);
+}
 
 /**
  * Loads the Prisma Next config from a TypeScript file.
@@ -19,34 +52,7 @@ import { loadConfig as loadConfigC12 } from 'c12';
  */
 export async function loadConfig(configPath?: string): Promise<PrismaNextConfig> {
   try {
-    const cwd = process.cwd();
-    // Resolve config path to absolute path and set cwd to config directory when path is provided
-    const resolvedConfigPath = configPath ? resolve(cwd, configPath) : undefined;
-    const configCwd = resolvedConfigPath ? dirname(resolvedConfigPath) : cwd;
-
-    const result = await loadConfigC12<PrismaNextConfig>({
-      name: 'prisma-next',
-      ...(resolvedConfigPath ? { configFile: resolvedConfigPath } : {}),
-      cwd: configCwd,
-    });
-
-    // When a specific config file was requested, verify it was actually loaded
-    // (c12 falls back to searching by name if the specified file doesn't exist)
-    if (resolvedConfigPath && result.configFile !== resolvedConfigPath) {
-      throw errorConfigFileNotFound(resolvedConfigPath);
-    }
-
-    // Check if config is missing or empty (c12 may return empty object when file doesn't exist)
-    if (!result.config || Object.keys(result.config).length === 0) {
-      // Use c12's configFile if available, otherwise use explicit configPath, otherwise omit path
-      const displayPath = result.configFile || resolvedConfigPath || configPath;
-      throw errorConfigFileNotFound(displayPath);
-    }
-
-    // Validate config structure
-    validateConfig(result.config);
-
-    return result.config;
+    return await loadValidatedConfig(configPath);
   } catch (error) {
     if (error instanceof ConfigValidationError) {
       throw errorConfigValidation(error.field, {