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

package/src/commands/migration-verify.ts

@@ -0,0 +1,180 @@
+import type { OperationDescriptor } from '@prisma-next/framework-components/control';
+import { attestMigration, verifyMigration } from '@prisma-next/migration-tools/attestation';
+import { readMigrationPackage, writeMigrationOps } from '@prisma-next/migration-tools/io';
+import { evaluateMigrationTs, hasMigrationTs } from '@prisma-next/migration-tools/migration-ts';
+import { MigrationToolsError } from '@prisma-next/migration-tools/types';
+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 {
+  CliStructuredError,
+  errorRuntime,
+  errorTargetMigrationNotSupported,
+  errorUnexpected,
+} from '../utils/cli-errors';
+import {
+  addGlobalOptions,
+  getTargetMigrations,
+  setCommandDescriptions,
+  setCommandExamples,
+} from '../utils/command-helpers';
+import { formatMigrationVerifyCommandOutput } from '../utils/formatters/migrations';
+import { formatStyledHeader } from '../utils/formatters/styled';
+import { assertFrameworkComponentsCompatible } from '../utils/framework-components';
+import type { CommonCommandOptions } from '../utils/global-flags';
+import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
+import { handleResult } from '../utils/result-handler';
+import { TerminalUI } from '../utils/terminal-ui';
+
+interface MigrationVerifyOptions extends CommonCommandOptions {
+  readonly dir: string;
+  readonly config?: string;
+}
+
+export interface MigrationVerifyResult {
+  readonly ok: boolean;
+  readonly status: 'verified' | 'attested';
+  readonly dir: string;
+  readonly migrationId?: string;
+  readonly storedMigrationId?: string;
+  readonly computedMigrationId?: string;
+  readonly summary: string;
+}
+
+async function executeMigrationVerifyCommand(
+  options: MigrationVerifyOptions,
+  flags: GlobalFlags,
+  ui: TerminalUI,
+): Promise<Result<MigrationVerifyResult, CliStructuredError>> {
+  const dir = options.dir;
+
+  if (!flags.json && !flags.quiet) {
+    const header = formatStyledHeader({
+      command: 'migration verify',
+      description: 'Verify migration package integrity',
+      details: [{ label: 'dir', value: dir }],
+      flags,
+    });
+    ui.stderr(header);
+  }
+
+  try {
+    // If migration.ts exists, always evaluate and resolve to ops.json.
+    // This ensures ops.json is always fresh relative to migration.ts.
+    if (await hasMigrationTs(dir)) {
+      const pkg = await readMigrationPackage(dir);
+      const descriptors = await evaluateMigrationTs(dir);
+
+      const config = await loadConfig(options.config);
+      const migrations = getTargetMigrations(config.target);
+      if (!migrations?.resolveDescriptors) {
+        throw errorTargetMigrationNotSupported({
+          why: `Target "${config.target.targetId}" does not implement resolveDescriptors; cannot verify a migration package that uses migration.ts`,
+        });
+      }
+
+      const frameworkComponents = assertFrameworkComponentsCompatible(
+        config.family.familyId,
+        config.target.targetId,
+        [config.target, config.adapter, ...(config.extensionPacks ?? [])],
+      );
+
+      const resolvedOps = migrations.resolveDescriptors(descriptors as OperationDescriptor[], {
+        fromContract: pkg.manifest.fromContract,
+        toContract: pkg.manifest.toContract,
+        frameworkComponents,
+      });
+
+      await writeMigrationOps(dir, resolvedOps);
+    }
+
+    // Now verify/attest with the (potentially updated) ops.json
+    const result = await verifyMigration(dir);
+
+    if (result.ok) {
+      return ok({
+        ok: true,
+        status: 'verified',
+        dir,
+        ...ifDefined('migrationId', result.storedMigrationId),
+        ...ifDefined('storedMigrationId', result.storedMigrationId),
+        ...ifDefined('computedMigrationId', result.computedMigrationId),
+        summary: 'Migration package verified — migrationId matches',
+      });
+    }
+
+    if (result.reason === 'draft') {
+      const migrationId = await attestMigration(dir);
+      return ok({
+        ok: true,
+        status: 'attested',
+        dir,
+        migrationId,
+        summary: `Draft migration attested with migrationId: ${migrationId}`,
+      });
+    }
+
+    // Mismatch — ops.json was just rewritten by migration.ts evaluation above,
+    // so this means the stored migrationId is stale. Re-attest.
+    const migrationId = await attestMigration(dir);
+    return ok({
+      ok: true,
+      status: 'attested',
+      dir,
+      migrationId,
+      summary: `Migration re-attested with migrationId: ${migrationId}`,
+    });
+  } catch (error) {
+    if (CliStructuredError.is(error)) {
+      return notOk(error);
+    }
+    if (MigrationToolsError.is(error)) {
+      return notOk(
+        errorRuntime(error.message, {
+          why: error.why,
+          fix: error.fix,
+          meta: { code: error.code, ...(error.details ?? {}) },
+        }),
+      );
+    }
+    return notOk(
+      errorUnexpected(error instanceof Error ? error.message : String(error), {
+        why: `Failed to verify migration: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+    );
+  }
+}
+
+export function createMigrationVerifyCommand(): Command {
+  const command = new Command('verify');
+  setCommandDescriptions(
+    command,
+    'Verify a migration package migrationId',
+    'Recomputes the content-addressed migrationId for a migration package and compares\n' +
+      'it against the stored value. Draft migrations (migrationId: null) are automatically\n' +
+      'attested. If migration.ts exists, it is always re-evaluated and ops.json is refreshed.',
+  );
+  setCommandExamples(command, ['prisma-next migration verify --dir migrations/20250101-add-users']);
+  addGlobalOptions(command)
+    .requiredOption('--dir <path>', 'Path to the migration package directory')
+    .option('--config <path>', 'Path to prisma-next.config.ts (required when migration.ts exists)')
+    .action(async (options: MigrationVerifyOptions) => {
+      const flags = parseGlobalFlags(options);
+      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+
+      const result = await executeMigrationVerifyCommand(options, flags, ui);
+
+      const exitCode = handleResult(result, flags, ui, (verifyResult) => {
+        if (flags.json) {
+          ui.output(JSON.stringify(verifyResult, null, 2));
+        } else if (!flags.quiet) {
+          ui.log(formatMigrationVerifyCommandOutput(verifyResult, flags));
+        }
+      });
+
+      process.exit(exitCode);
+    });
+
+  return command;
+}

package/src/config-loader.ts

@@ -1,7 +1,11 @@
 import { dirname, resolve } from 'node:path';
-import type { PrismaNextConfig } from '@prisma-next/core-control-plane/config-types';
-import { validateConfig } from '@prisma-next/core-control-plane/config-validation';
-import { errorConfigFileNotFound, errorUnexpected } from '@prisma-next/core-control-plane/errors';
+import type { PrismaNextConfig } from '@prisma-next/config/config-types';
+import { ConfigValidationError, validateConfig } from '@prisma-next/config/config-validation';
+import {
+  errorConfigFileNotFound,
+  errorConfigValidation,
+  errorUnexpected,
+} from '@prisma-next/errors/control';
 import { loadConfig as loadConfigC12 } from 'c12';
 
 /**
@@ -44,6 +48,12 @@ export async function loadConfig(configPath?: string): Promise<PrismaNextConfig>
 
     return result.config;
   } catch (error) {
+    if (error instanceof ConfigValidationError) {
+      throw errorConfigValidation(error.field, {
+        why: error.why,
+      });
+    }
+
     // Re-throw structured errors as-is
     if (
       error instanceof Error &&