@prisma-next/cli 0.4.0-dev.4 → 0.4.0-dev.6

package/src/commands/migration-emit.ts

@@ -0,0 +1,132 @@
+import { MigrationToolsError } from '@prisma-next/migration-tools/types';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { Command } from 'commander';
+import { loadConfig } from '../config-loader';
+import { emitMigration } from '../lib/migration-emit';
+import {
+  CliStructuredError,
+  errorRuntime,
+  errorTargetMigrationNotSupported,
+  errorUnexpected,
+} from '../utils/cli-errors';
+import {
+  addGlobalOptions,
+  getTargetMigrations,
+  setCommandDescriptions,
+  setCommandExamples,
+} from '../utils/command-helpers';
+import { formatMigrationEmitCommandOutput } 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';
+
+export interface MigrationEmitOptions extends CommonCommandOptions {
+  readonly dir: string;
+  readonly config?: string;
+}
+
+export interface MigrationEmitResult {
+  readonly ok: boolean;
+  readonly dir: string;
+  readonly migrationId: string;
+  readonly summary: string;
+}
+
+async function executeMigrationEmitCommand(
+  options: MigrationEmitOptions,
+  flags: GlobalFlags,
+  ui: TerminalUI,
+): Promise<Result<MigrationEmitResult, CliStructuredError>> {
+  const dir = options.dir;
+
+  if (!flags.json && !flags.quiet) {
+    const header = formatStyledHeader({
+      command: 'migration emit',
+      description: 'Emit ops.json from migration.ts and compute migrationId',
+      details: [{ label: 'dir', value: dir }],
+      flags,
+    });
+    ui.stderr(header);
+  }
+
+  try {
+    const config = await loadConfig(options.config);
+    const migrations = getTargetMigrations(config.target);
+    if (!migrations) {
+      throw errorTargetMigrationNotSupported({
+        why: `Target "${config.target.id}" does not support migrations`,
+      });
+    }
+    const frameworkComponents = assertFrameworkComponentsCompatible(
+      config.family.familyId,
+      config.target.targetId,
+      [config.target, config.adapter, ...(config.extensionPacks ?? [])],
+    );
+
+    const { migrationId } = await emitMigration(dir, {
+      targetId: config.target.targetId,
+      migrations,
+      frameworkComponents,
+    });
+
+    return ok({
+      ok: true,
+      dir,
+      migrationId,
+      summary: `Emitted ops.json and attested 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 emit migration: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+    );
+  }
+}
+
+export function createMigrationEmitCommand(): Command {
+  const command = new Command('emit');
+  setCommandDescriptions(
+    command,
+    'Emit ops.json from migration.ts and compute migrationId',
+    'Evaluates migration.ts in the package directory, resolves it to ops.json,\n' +
+      'then computes and persists the content-addressed migrationId in manifest.json.',
+  );
+  setCommandExamples(command, ['prisma-next migration emit --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')
+    .action(async (options: MigrationEmitOptions) => {
+      const flags = parseGlobalFlags(options);
+      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+
+      const result = await executeMigrationEmitCommand(options, flags, ui);
+
+      const exitCode = handleResult(result, flags, ui, (emitResult) => {
+        if (flags.json) {
+          ui.output(JSON.stringify(emitResult, null, 2));
+        } else if (!flags.quiet) {
+          ui.log(formatMigrationEmitCommandOutput(emitResult, flags));
+        }
+      });
+
+      process.exit(exitCode);
+    });
+
+  return command;
+}

package/src/commands/migration-new.ts

@@ -1,7 +1,7 @@
 /**
  * `migration new` — scaffolds a migration package with a migration.ts file
  * for manual authoring. The user writes operation descriptors and data
- * transforms; `migration verify` resolves them to ops.json.
+ * transforms; `migration emit` resolves them to ops.json.
  */
 
 import { readFileSync } from 'node:fs';
@@ -214,7 +214,7 @@ export function createMigrationNewCommand(): Command {
     'Scaffold a new migration for manual authoring',
     'Creates a migration package with a migration.ts file for manual authoring.\n' +
       'Write operation descriptors and data transforms in migration.ts, then run\n' +
-      '`migration verify` to resolve and attest the package.',
+      '`migration emit` to resolve and attest the package.',
   );
   setCommandExamples(command, [
     'prisma-next migration new --name split-name',
@@ -248,7 +248,7 @@ export function createMigrationNewCommand(): Command {
           ui.output(`  from: ${value.from}`);
           ui.output(`  to:   ${value.to}`);
           ui.output(
-            `\nEdit migration.ts, then run \`prisma-next migration verify --dir ${value.dir}\` to attest.`,
+            `\nEdit migration.ts, then run \`prisma-next migration emit --dir "${value.dir}"\` to attest.`,
           );
         }
       });

package/src/commands/migration-plan.ts

@@ -1,24 +1,16 @@
 import { readFile } from 'node:fs/promises';
 import type { Contract } from '@prisma-next/contract/types';
-import type { OperationDescriptor } from '@prisma-next/framework-components/control';
-import { attestMigration } 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 {
-  formatMigrationDirName,
-  writeMigrationOps,
-  writeMigrationPackage,
-} from '@prisma-next/migration-tools/io';
-import {
-  evaluateMigrationTs,
-  scaffoldMigrationTs,
-} from '@prisma-next/migration-tools/migration-ts';
+import { formatMigrationDirName, writeMigrationPackage } from '@prisma-next/migration-tools/io';
+import { scaffoldMigrationTs } from '@prisma-next/migration-tools/migration-ts';
 import { type MigrationManifest, MigrationToolsError } from '@prisma-next/migration-tools/types';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 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 {
   type CliErrorConflict,
   CliStructuredError,
@@ -178,7 +170,7 @@ async function executeMigrationPlanCommand(
       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 verify --dir ${migrationsRelative}/${existingDraft.dirName}' to attest it, or delete it and re-plan.`,
+          fix: `Run 'prisma-next migration emit --dir ${migrationsRelative}/${existingDraft.dirName}' to attest it, or delete it and re-plan.`,
         }),
       );
     }
@@ -302,56 +294,22 @@ async function executeMigrationPlanCommand(
     };
 
     try {
-      // Always write migration.ts with the descriptors
-      // Write package with empty ops first (draft)
       await writeMigrationPackage(packageDir, manifest, []);
       await scaffoldMigrationTs(packageDir, {
         descriptors: descriptorResult.descriptors,
         contractJsonPath: contractPathAbsolute,
       });
 
-      if (descriptorResult.needsDataMigration) {
-        // Draft — user must fill in dataTransform and run verify
-        const result: MigrationPlanResult = {
-          ok: true,
-          noOp: false,
-          from: fromHash,
-          to: toStorageHash,
-          dir: relative(process.cwd(), packageDir),
-          operations: descriptorResult.descriptors.map((d) => ({
-            id: (d as { kind: string }).kind,
-            label: (d as { kind: string }).kind,
-            operationClass: 'data' as const,
-          })),
-          sql: [],
-          summary: `Planned ${descriptorResult.descriptors.length} operation(s) — data migration required. Edit migration.ts and run \`migration verify --dir ${relative(process.cwd(), packageDir)}\` to attest.`,
-          timings: { total: Date.now() - startTime },
-        };
-        return ok(result);
-      }
-
-      // No data migration — evaluate, resolve, write ops, attest
-      const evaluatedDescriptors = await evaluateMigrationTs(packageDir);
-
-      if (!migrations.resolveDescriptors) {
-        throw errorTargetMigrationNotSupported({
-          why: `Target "${config.target.targetId}" does not implement resolveDescriptors; cannot finalize migration plan with migration.ts`,
-        });
-      }
-
-      const resolvedOps = migrations.resolveDescriptors(
-        evaluatedDescriptors as OperationDescriptor[],
-        {
-          fromContract,
-          toContract: toContractJson,
-          frameworkComponents,
-        },
-      );
-
-      await writeMigrationOps(packageDir, resolvedOps);
-      const migrationId = await attestMigration(packageDir);
+      // Always run emit inline; structured errors thrown during evaluation
+      // (e.g. invalid migration.ts shape, missing file) propagate through
+      // emitMigration to the CLI envelope.
+      const { operations, migrationId } = await emitMigration(packageDir, {
+        targetId: config.target.targetId,
+        migrations,
+        frameworkComponents,
+      });
 
-      const sql = extractSqlDdl(resolvedOps);
+      const sql = extractSqlDdl(operations);
       const result: MigrationPlanResult = {
         ok: true,
         noOp: false,
@@ -359,13 +317,13 @@ async function executeMigrationPlanCommand(
         to: toStorageHash,
         migrationId,
         dir: relative(process.cwd(), packageDir),
-        operations: resolvedOps.map((op) => ({
+        operations: operations.map((op) => ({
           id: op.id,
           label: op.label,
           operationClass: op.operationClass,
         })),
         sql,
-        summary: `Planned ${resolvedOps.length} operation(s)`,
+        summary: `Planned ${operations.length} operation(s)`,
         timings: { total: Date.now() - startTime },
       };
       return ok(result);

package/src/commands/migration-show.ts

@@ -137,7 +137,7 @@ async function executeMigrationShowCommand(
           return notOk(
             errorRuntime('No attested migrations found', {
               why: `All migrations in ${migrationsRelative} are drafts (migrationId: null)`,
-              fix: 'Run `prisma-next migration verify --dir <path>` to attest a draft migration.',
+              fix: 'Run `prisma-next migration emit --dir <path>` to attest a draft migration.',
             }),
           );
         }

package/src/commands/migration-status.ts

@@ -460,7 +460,7 @@ async function executeMigrationStatusCommand(
       severity: 'warn',
       message: `${drafts.length} draft migration(s) found: ${drafts.map((d) => d.dirName).join(', ')}`,
       hints: [
-        "Run 'prisma-next migration verify --dir <path>' to attest draft migrations before applying",
+        "Run 'prisma-next migration emit --dir <path>' to attest draft migrations before applying",
       ],
     });
   }

package/src/lib/migration-emit.ts

@@ -0,0 +1,113 @@
+/**
+ * Shared helper for emitting `ops.json` from a migration package's
+ * `migration.ts`.
+ *
+ * Two flows are dispatched here:
+ *  - Descriptor flow (Postgres): the framework evaluates `migration.ts` (which
+ *    re-exports the planner's descriptor list), calls the target's
+ *    `resolveDescriptors` to produce display-oriented operations, and writes
+ *    `ops.json` + `manifest.json`.
+ *  - Class flow (Mongo): the target owns the source-loading and ops
+ *    serialization step via its `emit` capability. The capability
+ *    dynamic-imports `migration.ts`, invokes its class to produce
+ *    operations, and calls `writeMigrationOps`. The framework helper
+ *    then attests the package (single source of truth for
+ *    `migrationId`).
+ *
+ * Used by `migration emit` (always) and `migration plan` (always, after
+ * scaffolding `migration.ts`). Both flows run in-process so that structured
+ * errors thrown during evaluation propagate as real exceptions and the
+ * CLI's error envelope renders them with full structured metadata.
+ */
+
+import assert from 'node:assert/strict';
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type {
+  MigrationPlanOperation,
+  OperationDescriptor,
+  TargetMigrationsCapability,
+} from '@prisma-next/framework-components/control';
+import { attestMigration } 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 { errorMigrationFileMissing, errorTargetMigrationNotSupported } from '../utils/cli-errors';
+
+/**
+ * Context passed to `emitMigration`. Captures everything the helper needs to
+ * dispatch to the right flow without re-loading the config.
+ */
+export interface EmitMigrationContext {
+  readonly targetId: string;
+  readonly migrations: TargetMigrationsCapability;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<string, string>>;
+}
+
+/**
+ * Result of a successful emit: the operations that were written to `ops.json`
+ * (display-oriented shape) and the content-addressed migrationId persisted to
+ * `manifest.json`.
+ */
+export interface EmitMigrationResult {
+  readonly operations: readonly MigrationPlanOperation[];
+  readonly migrationId: string;
+}
+
+/**
+ * Emit `ops.json` and attest `migrationId` for the migration package at `dir`.
+ *
+ * Dispatches to descriptor flow when the target implements `resolveDescriptors`,
+ * otherwise to the target's `emit` capability. Throws a structured error if
+ * `migration.ts` is missing or the target supports neither flow. Other
+ * structured errors thrown during evaluation propagate unchanged.
+ */
+export async function emitMigration(
+  dir: string,
+  ctx: EmitMigrationContext,
+): Promise<EmitMigrationResult> {
+  if (!(await hasMigrationTs(dir))) {
+    throw errorMigrationFileMissing(dir);
+  }
+
+  if (ctx.migrations.resolveDescriptors) {
+    return emitDescriptorFlow(dir, ctx.migrations, ctx);
+  }
+
+  if (ctx.migrations.emit) {
+    const operations = await ctx.migrations.emit({
+      dir,
+      frameworkComponents: ctx.frameworkComponents,
+    });
+    const migrationId = await attestMigration(dir);
+    return { operations, migrationId };
+  }
+
+  throw errorTargetMigrationNotSupported({
+    why: `Target "${ctx.targetId}" does not implement resolveDescriptors or emit; cannot emit a migration package`,
+  });
+}
+
+/**
+ * Descriptor flow: evaluate `migration.ts` to obtain a list of operation
+ * descriptors, hand them to the target's `resolveDescriptors` along with the
+ * manifest's contract bookends, then persist `ops.json` and attest the package.
+ */
+async function emitDescriptorFlow(
+  dir: string,
+  migrations: TargetMigrationsCapability,
+  ctx: EmitMigrationContext,
+): Promise<EmitMigrationResult> {
+  assert(
+    migrations.resolveDescriptors,
+    'emitDescriptorFlow requires resolveDescriptors; gated by caller',
+  );
+  const pkg = await readMigrationPackage(dir);
+  const descriptors = await evaluateMigrationTs(dir);
+  const operations = migrations.resolveDescriptors(descriptors as OperationDescriptor[], {
+    fromContract: pkg.manifest.fromContract,
+    toContract: pkg.manifest.toContract,
+    frameworkComponents: ctx.frameworkComponents,
+  });
+  await writeMigrationOps(dir, operations);
+  const migrationId = await attestMigration(dir);
+  return { operations, migrationId };
+}

package/src/utils/cli-errors.ts

@@ -30,3 +30,8 @@ export {
   errorSchemaVerificationFailed,
   errorTargetMismatch,
 } from '@prisma-next/errors/execution';
+export {
+  errorMigrationFileMissing,
+  errorMigrationInvalidDefaultExport,
+  errorMigrationPlanNotArray,
+} from '@prisma-next/errors/migration';

package/src/utils/formatters/help.ts

@@ -137,7 +137,7 @@ function getCommandDocsUrl(commandPath: string): string | undefined {
     'migration apply': 'https://pris.ly/migration-apply',
     'migration show': 'https://pris.ly/migration-show',
     'migration status': 'https://pris.ly/migration-status',
-    'migration verify': 'https://pris.ly/migration-verify',
+    'migration emit': 'https://pris.ly/migration-emit',
   };
   return docsMap[commandPath];
 }

package/src/utils/formatters/migrations.ts

@@ -136,9 +136,8 @@ export interface MigrationApplyCommandOutputResult {
   };
 }
 
-export interface MigrationVerifyCommandOutputResult {
-  readonly status: 'verified' | 'attested';
-  readonly migrationId?: string;
+export interface MigrationEmitCommandOutputResult {
+  readonly migrationId: string;
 }
 
 export function formatMigrationApplyCommandOutput(
@@ -183,8 +182,8 @@ export function formatMigrationApplyCommandOutput(
   return lines.join('\n');
 }
 
-export function formatMigrationVerifyCommandOutput(
-  result: MigrationVerifyCommandOutputResult,
+export function formatMigrationEmitCommandOutput(
+  result: MigrationEmitCommandOutputResult,
   flags: GlobalFlags,
 ): string {
   if (flags.quiet) {
@@ -194,23 +193,10 @@ export function formatMigrationVerifyCommandOutput(
   const lines: string[] = [];
   const useColor = flags.color !== false;
   const formatGreen = createColorFormatter(useColor, green);
-  const formatYellow = createColorFormatter(useColor, yellow);
   const formatDimText = (text: string) => formatDim(useColor, text);
 
-  switch (result.status) {
-    case 'verified':
-      lines.push(`${formatGreen('✔')} Migration verified`);
-      if (result.migrationId) {
-        lines.push(formatDimText(`  migrationId: ${result.migrationId}`));
-      }
-      break;
-    case 'attested':
-      lines.push(`${formatYellow('◉')} Draft migration attested`);
-      if (result.migrationId) {
-        lines.push(formatDimText(`  migrationId: ${result.migrationId}`));
-      }
-      break;
-  }
+  lines.push(`${formatGreen('✔')} Emitted ops.json and attested migration`);
+  lines.push(formatDimText(`  migrationId: ${result.migrationId}`));
 
   return lines.join('\n');
 }

package/dist/cli-errors-BDCYR5ap.mjs

@@ -1,4 +0,0 @@
-import { CliStructuredError, errorConfigValidation as errorConfigValidation$1, errorContractConfigMissing as errorContractConfigMissing$1, errorContractValidationFailed, errorDatabaseConnectionRequired, errorDriverRequired, errorFileNotFound, errorMigrationPlanningFailed, errorTargetMigrationNotSupported, errorUnexpected as errorUnexpected$1 } from "@prisma-next/errors/control";
-import { ERROR_CODE_DESTRUCTIVE_CHANGES, errorDestructiveChanges, errorHashMismatch, errorMarkerMissing, errorRunnerFailed, errorRuntime as errorRuntime$1, errorTargetMismatch } from "@prisma-next/errors/execution";
-
-export { errorUnexpected$1 as _, errorContractValidationFailed as a, errorDriverRequired as c, errorMarkerMissing as d, errorMigrationPlanningFailed as f, errorTargetMismatch as g, errorTargetMigrationNotSupported as h, errorContractConfigMissing$1 as i, errorFileNotFound as l, errorRuntime$1 as m, ERROR_CODE_DESTRUCTIVE_CHANGES as n, errorDatabaseConnectionRequired as o, errorRunnerFailed as p, errorConfigValidation$1 as r, errorDestructiveChanges as s, CliStructuredError as t, errorHashMismatch as u };

package/dist/commands/migration-verify.d.mts

@@ -1,16 +0,0 @@
-import { Command } from "commander";
-
-//#region src/commands/migration-verify.d.ts
-interface MigrationVerifyResult {
-  readonly ok: boolean;
-  readonly status: 'verified' | 'attested';
-  readonly dir: string;
-  readonly migrationId?: string;
-  readonly storedMigrationId?: string;
-  readonly computedMigrationId?: string;
-  readonly summary: string;
-}
-declare function createMigrationVerifyCommand(): Command;
-//#endregion
-export { MigrationVerifyResult, createMigrationVerifyCommand };
-//# sourceMappingURL=migration-verify.d.mts.map

package/dist/commands/migration-verify.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"migration-verify.d.mts","names":[],"sources":["../../src/commands/migration-verify.ts"],"sourcesContent":[],"mappings":";;;UAkCiB,qBAAA;;EAAA,SAAA,MAAA,EAAA,UAAqB,GAAA,UAAA;EAkHtB,SAAA,GAAA,EAAA,MAAA;;;;;;iBAAA,4BAAA,CAAA,GAAgC"}

package/dist/commands/migration-verify.mjs

@@ -1,110 +0,0 @@
-import { t as loadConfig } from "../config-loader-C4VXKl8f.mjs";
-import { _ as errorUnexpected, h as errorTargetMigrationNotSupported, m as errorRuntime, t as CliStructuredError } from "../cli-errors-BDCYR5ap.mjs";
-import { t as assertFrameworkComponentsCompatible } from "../framework-components-BAsliT4V.mjs";
-import { _ as formatStyledHeader, d as setCommandExamples, m as parseGlobalFlags, n as addGlobalOptions, r as getTargetMigrations, t as handleResult, u as setCommandDescriptions } from "../result-handler-oK_vA-Fn.mjs";
-import { t as TerminalUI } from "../terminal-ui-C5k88MmW.mjs";
-import { o as formatMigrationVerifyCommandOutput } from "../migrations-DTZBYXm1.mjs";
-import { Command } from "commander";
-import { notOk, ok } from "@prisma-next/utils/result";
-import { ifDefined } from "@prisma-next/utils/defined";
-import { readMigrationPackage, writeMigrationOps } from "@prisma-next/migration-tools/io";
-import { MigrationToolsError } from "@prisma-next/migration-tools/types";
-import { evaluateMigrationTs, hasMigrationTs } from "@prisma-next/migration-tools/migration-ts";
-import { attestMigration, verifyMigration } from "@prisma-next/migration-tools/attestation";
-
-//#region src/commands/migration-verify.ts
-async function executeMigrationVerifyCommand(options, flags, ui) {
-	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 (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 ?? []
-			]);
-			await writeMigrationOps(dir, migrations.resolveDescriptors(descriptors, {
-				fromContract: pkg.manifest.fromContract,
-				toContract: pkg.manifest.toContract,
-				frameworkComponents
-			}));
-		}
-		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$1 = await attestMigration(dir);
-			return ok({
-				ok: true,
-				status: "attested",
-				dir,
-				migrationId: migrationId$1,
-				summary: `Draft migration attested with migrationId: ${migrationId$1}`
-			});
-		}
-		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)}` }));
-	}
-}
-function createMigrationVerifyCommand() {
-	const command = new Command("verify");
-	setCommandDescriptions(command, "Verify a migration package migrationId", "Recomputes the content-addressed migrationId for a migration package and compares\nit against the stored value. Draft migrations (migrationId: null) are automatically\nattested. 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) => {
-		const flags = parseGlobalFlags(options);
-		const ui = new TerminalUI({
-			color: flags.color,
-			interactive: flags.interactive
-		});
-		const exitCode = handleResult(await executeMigrationVerifyCommand(options, flags, ui), 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;
-}
-
-//#endregion
-export { createMigrationVerifyCommand };
-//# sourceMappingURL=migration-verify.mjs.map

package/dist/commands/migration-verify.mjs.map

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

package/dist/contract-emit-CGpb33vs.mjs

@@ -1,4 +0,0 @@
-import "./config-loader-C4VXKl8f.mjs";
-import { t as executeContractEmit } from "./contract-emit-CRoS1nx5.mjs";
-
-export { executeContractEmit };