@prisma-next/cli 0.5.0-dev.2 → 0.5.0-dev.21

package/src/commands/migration-ref.ts

@@ -1,17 +1,27 @@
+import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
+import type { RefEntry } from '@prisma-next/migration-tools/refs';
 import {
+  deleteRef,
+  readRef,
   readRefs,
-  resolveRef,
   validateRefName,
   validateRefValue,
-  writeRefs,
+  writeRef,
 } from '@prisma-next/migration-tools/refs';
-import { MigrationToolsError } from '@prisma-next/migration-tools/types';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
-import { resolve } from 'pathe';
 import { loadConfig } from '../config-loader';
-import { CliStructuredError, errorRuntime, errorUnexpected } from '../utils/cli-errors';
-import { addGlobalOptions, setCommandDescriptions } from '../utils/command-helpers';
+import {
+  CliStructuredError,
+  errorRuntime,
+  errorUnexpected,
+  mapMigrationToolsError,
+} from '../utils/cli-errors';
+import {
+  addGlobalOptions,
+  resolveMigrationPaths,
+  setCommandDescriptions,
+} from '../utils/command-helpers';
 import { formatCommandHelp } from '../utils/formatters/help';
 import { parseGlobalFlags } from '../utils/global-flags';
 import { handleResult } from '../utils/result-handler';
@@ -21,12 +31,14 @@ interface RefSetResult {
   readonly ok: true;
   readonly ref: string;
   readonly hash: string;
+  readonly invariants: readonly string[];
 }
 
 interface RefGetResult {
   readonly ok: true;
   readonly ref: string;
   readonly hash: string;
+  readonly invariants: readonly string[];
 }
 
 interface RefDeleteResult {
@@ -37,21 +49,12 @@ interface RefDeleteResult {
 
 interface RefListResult {
   readonly ok: true;
-  readonly refs: Record<string, string>;
-}
-
-function resolveRefsPath(configPath?: string, config?: { migrations?: { dir?: string } }): string {
-  const base = configPath ? resolve(configPath, '..') : process.cwd();
-  return resolve(base, config?.migrations?.dir ?? 'migrations', 'refs.json');
+  readonly refs: Record<string, RefEntry>;
 }
 
 function mapError(error: unknown): CliStructuredError {
   if (MigrationToolsError.is(error)) {
-    return errorRuntime(error.message, {
-      why: error.why,
-      fix: error.fix,
-      meta: { code: error.code },
-    });
+    return mapMigrationToolsError(error);
   }
   return errorUnexpected(error instanceof Error ? error.message : String(error));
 }
@@ -70,13 +73,6 @@ function cliErrorInvalidRefValue(hash: string): CliStructuredError {
   });
 }
 
-function errorRefNotFound(name: string): CliStructuredError {
-  return errorRuntime(`Ref "${name}" does not exist`, {
-    why: `No ref named "${name}" found in refs.json`,
-    fix: `Run \`prisma-next migration ref list\` to see available refs, or \`prisma-next migration ref set ${name} <hash>\` to create it`,
-  });
-}
-
 async function executeRefSetCommand(
   name: string,
   hash: string,
@@ -91,11 +87,10 @@ async function executeRefSetCommand(
 
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
-    const updated = { ...refs, [name]: hash };
-    await writeRefs(refsPath, updated);
-    return ok({ ok: true as const, ref: name, hash });
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    const entry: RefEntry = { hash, invariants: [] };
+    await writeRef(refsDir, name, entry);
+    return ok({ ok: true as const, ref: name, hash, invariants: [] });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
     return notOk(mapError(error));
@@ -108,10 +103,9 @@ async function executeRefGetCommand(
 ): Promise<Result<RefGetResult, CliStructuredError>> {
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
-    const hash = resolveRef(refs, name);
-    return ok({ ok: true as const, ref: name, hash });
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    const entry = await readRef(refsDir, name);
+    return ok({ ok: true as const, ref: name, hash: entry.hash, invariants: entry.invariants });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
     return notOk(mapError(error));
@@ -124,13 +118,8 @@ async function executeRefDeleteCommand(
 ): Promise<Result<RefDeleteResult, CliStructuredError>> {
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
-    if (!Object.hasOwn(refs, name)) {
-      return notOk(errorRefNotFound(name));
-    }
-    const { [name]: _, ...remaining } = refs;
-    await writeRefs(refsPath, remaining);
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    await deleteRef(refsDir, name);
     return ok({ ok: true as const, ref: name, deleted: true as const });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
@@ -143,8 +132,8 @@ async function executeRefListCommand(options: {
 }): Promise<Result<RefListResult, CliStructuredError>> {
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    const refs = await readRefs(refsDir);
     return ok({ ok: true as const, refs });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
@@ -157,7 +146,7 @@ function createRefSetCommand(): Command {
   setCommandDescriptions(
     command,
     'Set a ref to a contract hash',
-    'Sets a named ref to point to a contract hash in migrations/refs.json.',
+    'Sets a named ref to point to a contract hash in migrations/refs/.',
   );
   addGlobalOptions(command)
     .argument('<name>', 'Ref name (e.g., staging, production)')
@@ -190,7 +179,7 @@ function createRefGetCommand(): Command {
   setCommandDescriptions(
     command,
     'Get the hash for a ref',
-    'Reads a named ref from migrations/refs.json and prints its contract hash.',
+    'Reads a named ref from migrations/refs/ and prints its contract hash.',
   );
   addGlobalOptions(command)
     .argument('<name>', 'Ref name to look up')
@@ -218,7 +207,7 @@ function createRefGetCommand(): Command {
 
 function createRefDeleteCommand(): Command {
   const command = new Command('delete');
-  setCommandDescriptions(command, 'Delete a ref', 'Removes a named ref from migrations/refs.json.');
+  setCommandDescriptions(command, 'Delete a ref', 'Removes a named ref from migrations/refs/.');
   addGlobalOptions(command)
     .argument('<name>', 'Ref name to delete')
     .option('--config <path>', 'Path to prisma-next.config.ts')
@@ -245,11 +234,7 @@ function createRefDeleteCommand(): Command {
 
 function createRefListCommand(): Command {
   const command = new Command('list');
-  setCommandDescriptions(
-    command,
-    'List all refs',
-    'Lists all named refs from migrations/refs.json.',
-  );
+  setCommandDescriptions(command, 'List all refs', 'Lists all named refs from migrations/refs/.');
   addGlobalOptions(command)
     .option('--config <path>', 'Path to prisma-next.config.ts')
     .action(async (options: { config?: string; json?: string | boolean; quiet?: boolean }) => {
@@ -264,8 +249,10 @@ function createRefListCommand(): Command {
           if (entries.length === 0) {
             ui.output('No refs defined');
           } else {
-            for (const [refName, hash] of entries) {
-              ui.output(`${refName} → ${hash}`);
+            for (const [refName, entry] of entries) {
+              const invariantsSuffix =
+                entry.invariants.length > 0 ? ` [invariants: ${entry.invariants.join(', ')}]` : '';
+              ui.output(`${refName} → ${entry.hash}${invariantsSuffix}`);
             }
           }
         }
@@ -282,7 +269,6 @@ export {
   executeRefListCommand,
   cliErrorInvalidRefName,
   cliErrorInvalidRefValue,
-  errorRefNotFound,
 };
 
 export function createMigrationRefCommand(): Command {
@@ -290,7 +276,7 @@ export function createMigrationRefCommand(): Command {
   setCommandDescriptions(
     command,
     'Manage migration refs',
-    'Manage named refs in migrations/refs.json. Refs map logical environment\n' +
+    'Manage named refs in migrations/refs/. Refs map logical environment\n' +
       'names (e.g., staging, production) to contract hashes.',
   );
   addGlobalOptions(command).configureHelp({

package/src/commands/migration-show.ts

@@ -1,14 +1,22 @@
 import type { MigrationPlanOperation } from '@prisma-next/framework-components/control';
-import { findLatestMigration, reconstructGraph } from '@prisma-next/migration-tools/dag';
+import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
 import { readMigrationPackage, readMigrationsDir } from '@prisma-next/migration-tools/io';
-import type { MigrationBundle } from '@prisma-next/migration-tools/types';
-import { MigrationToolsError } from '@prisma-next/migration-tools/types';
+import {
+  findLatestMigration,
+  reconstructGraph,
+} from '@prisma-next/migration-tools/migration-graph';
+import type { MigrationPackage } from '@prisma-next/migration-tools/package';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { relative, resolve } from 'pathe';
 import { loadConfig } from '../config-loader';
 import { extractOperationStatements } from '../control-api/operations/extract-operation-statements';
-import { type CliStructuredError, errorRuntime, errorUnexpected } from '../utils/cli-errors';
+import {
+  type CliStructuredError,
+  errorRuntime,
+  errorUnexpected,
+  mapMigrationToolsError,
+} from '../utils/cli-errors';
 import {
   addGlobalOptions,
   setCommandDescriptions,
@@ -31,7 +39,7 @@ export interface MigrationShowResult {
   readonly dirPath: string;
   readonly from: string;
   readonly to: string;
-  readonly migrationId: string;
+  readonly migrationHash: string;
   readonly kind: string;
   readonly createdAt: string;
   readonly operations: readonly {
@@ -48,11 +56,11 @@ function looksLikePath(target: string): boolean {
 }
 
 export function resolveByHashPrefix(
-  packages: readonly MigrationBundle[],
+  packages: readonly MigrationPackage[],
   prefix: string,
-): Result<MigrationBundle, CliStructuredError> {
+): Result<MigrationPackage, CliStructuredError> {
   const normalizedPrefix = prefix.startsWith('sha256:') ? prefix : `sha256:${prefix}`;
-  const matches = packages.filter((p) => p.manifest.migrationId.startsWith(normalizedPrefix));
+  const matches = packages.filter((p) => p.metadata.migrationHash.startsWith(normalizedPrefix));
 
   if (matches.length === 1) {
     return ok(matches[0]!);
@@ -61,13 +69,13 @@ export function resolveByHashPrefix(
   if (matches.length === 0) {
     return notOk(
       errorRuntime('No migration found matching prefix', {
-        why: `No migration has a migrationId starting with "${normalizedPrefix}"`,
+        why: `No migration has a migrationHash starting with "${normalizedPrefix}"`,
         fix: 'Run `prisma-next migration show` (no argument) to see the latest migration, or check the migrations directory for available packages.',
       }),
     );
   }
 
-  const candidates = matches.map((p) => `  ${p.dirName}  ${p.manifest.migrationId}`).join('\n');
+  const candidates = matches.map((p) => `  ${p.dirName}  ${p.metadata.migrationHash}`).join('\n');
   return notOk(
     errorRuntime('Ambiguous hash prefix', {
       why: `Multiple migrations match prefix "${normalizedPrefix}":\n${candidates}`,
@@ -110,7 +118,7 @@ async function executeMigrationShowCommand(
     ui.stderr(header);
   }
 
-  let pkg: MigrationBundle;
+  let pkg: MigrationPackage;
 
   try {
     if (target && looksLikePath(target)) {
@@ -142,7 +150,7 @@ async function executeMigrationShowCommand(
           );
         }
         const leafPkg = allPackages.find(
-          (p) => p.manifest.migrationId === latestMigration.migrationId,
+          (p) => p.metadata.migrationHash === latestMigration.migrationHash,
         );
         if (!leafPkg) {
           return notOk(
@@ -157,13 +165,7 @@ async function executeMigrationShowCommand(
     }
   } catch (error) {
     if (MigrationToolsError.is(error)) {
-      return notOk(
-        errorRuntime(error.message, {
-          why: error.why,
-          fix: error.fix,
-          meta: { code: error.code, ...(error.details ?? {}) },
-        }),
-      );
+      return notOk(mapMigrationToolsError(error));
     }
     return notOk(
       errorUnexpected(error instanceof Error ? error.message : String(error), {
@@ -179,11 +181,11 @@ async function executeMigrationShowCommand(
     ok: true,
     dirName: pkg.dirName,
     dirPath: relative(process.cwd(), pkg.dirPath),
-    from: pkg.manifest.from,
-    to: pkg.manifest.to,
-    migrationId: pkg.manifest.migrationId,
-    kind: pkg.manifest.kind,
-    createdAt: pkg.manifest.createdAt,
+    from: pkg.metadata.from,
+    to: pkg.metadata.to,
+    migrationHash: pkg.metadata.migrationHash,
+    kind: pkg.metadata.kind,
+    createdAt: pkg.metadata.createdAt,
     operations: ops.map((op) => ({
       id: op.id,
       label: op.label,
@@ -209,10 +211,7 @@ export function createMigrationShowCommand(): Command {
     'prisma-next migration show sha256:a1b2c3',
   ]);
   addGlobalOptions(command)
-    .argument(
-      '[target]',
-      'Migration directory path or migrationId hash prefix (defaults to latest)',
-    )
+    .argument('[target]', 'Migration directory path or migrationHash prefix (defaults to latest)')
     .option('--config <path>', 'Path to prisma-next.config.ts')
     .action(async (target: string | undefined, options: MigrationShowOptions) => {
       const flags = parseGlobalFlags(options);

package/src/commands/migration-status.ts

@@ -1,18 +1,15 @@
 import type { MigrationPlanOperation } from '@prisma-next/framework-components/control';
 import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
+import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
+import type { MigrationEdge, MigrationGraph } from '@prisma-next/migration-tools/graph';
 import {
   findPath,
   findPathWithDecision,
   findReachableLeaves,
-} from '@prisma-next/migration-tools/dag';
+} from '@prisma-next/migration-tools/migration-graph';
+import type { MigrationPackage } from '@prisma-next/migration-tools/package';
 import type { Refs } from '@prisma-next/migration-tools/refs';
 import { readRefs, resolveRef } from '@prisma-next/migration-tools/refs';
-import type {
-  MigrationBundle,
-  MigrationChainEntry,
-  MigrationGraph,
-} from '@prisma-next/migration-tools/types';
-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 { cyan, dim, magenta, yellow } from 'colorette';
@@ -20,10 +17,15 @@ import { Command } from 'commander';
 
 import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
-import { type CliStructuredError, errorRuntime, errorUnexpected } from '../utils/cli-errors';
+import {
+  type CliStructuredError,
+  errorRuntime,
+  errorUnexpected,
+  mapMigrationToolsError,
+} from '../utils/cli-errors';
 import {
   addGlobalOptions,
-  loadAllBundles,
+  loadMigrationPackages,
   maskConnectionUrl,
   readContractEnvelope,
   resolveMigrationPaths,
@@ -61,7 +63,7 @@ export interface MigrationStatusEntry {
   readonly dirName: string;
   readonly from: string;
   readonly to: string;
-  readonly migrationId: string;
+  readonly migrationHash: string;
   readonly operationCount: number;
   readonly operationSummary: string;
   readonly hasDestructive: boolean;
@@ -86,7 +88,7 @@ export interface MigrationStatusResult {
     readonly refName?: string;
     readonly selectedPath: readonly {
       readonly dirName: string;
-      readonly migrationId: string;
+      readonly migrationHash: string;
       readonly from: string;
       readonly to: string;
     }[];
@@ -94,7 +96,7 @@ export interface MigrationStatusResult {
   readonly summary: string;
   readonly diagnostics: readonly StatusDiagnostic[];
   readonly graph?: MigrationGraph;
-  readonly bundles?: readonly MigrationBundle[];
+  readonly bundles?: readonly MigrationPackage[];
   readonly edgeStatuses?: readonly EdgeStatus[];
   readonly activeRefHash?: string;
   readonly activeRefName?: string;
@@ -154,7 +156,7 @@ export function deriveEdgeStatuses(
 ): EdgeStatus[] {
   if (mode === 'offline') return [];
 
-  const edgeKey = (e: MigrationChainEntry) => `${e.from}\0${e.to}`;
+  const edgeKey = (e: MigrationEdge) => `${e.from}\0${e.to}`;
 
   // No marker = empty DB — treat root as the marker (nothing applied, everything pending)
   const effectiveMarker = markerHash ?? EMPTY_CONTRACT_HASH;
@@ -224,8 +226,8 @@ export function deriveEdgeStatuses(
  * @param markerHash — the marker hash from the database, or undefined if no marker row / offline
  */
 function buildMigrationEntries(
-  chain: readonly MigrationChainEntry[],
-  packages: readonly MigrationBundle[],
+  chain: readonly MigrationEdge[],
+  packages: readonly MigrationPackage[],
   mode: 'online' | 'offline',
   markerHash: string | undefined,
   edgeStatuses?: readonly EdgeStatus[],
@@ -261,7 +263,7 @@ function buildMigrationEntries(
       dirName: migration.dirName,
       from: migration.from,
       to: migration.to,
-      migrationId: migration.migrationId,
+      migrationHash: migration.migrationHash,
       operationCount: ops.length,
       operationSummary: summary,
       hasDestructive,
@@ -294,7 +296,7 @@ function resolveDisplayChain(
   graph: MigrationGraph,
   targetHash: string,
   markerHash: string | undefined,
-): readonly MigrationChainEntry[] | null {
+): readonly MigrationEdge[] | null {
   if (markerHash === undefined) {
     return findPath(graph, EMPTY_CONTRACT_HASH, targetHash);
   }
@@ -345,7 +347,7 @@ async function executeMigrationStatusCommand(
   ui: TerminalUI,
 ): Promise<Result<MigrationStatusResult, CliStructuredError>> {
   const config = await loadConfig(options.config);
-  const { configPath, migrationsDir, migrationsRelative, refsPath } = resolveMigrationPaths(
+  const { configPath, migrationsDir, migrationsRelative, refsDir } = resolveMigrationPaths(
     options.config,
     config,
   );
@@ -357,46 +359,29 @@ async function executeMigrationStatusCommand(
   let activeRefHash: string | undefined;
   let allRefs: Refs = {};
   try {
-    allRefs = await readRefs(refsPath);
+    allRefs = await readRefs(refsDir);
   } catch (error) {
     if (MigrationToolsError.is(error)) {
-      return notOk(
-        errorRuntime(error.message, {
-          why: error.why,
-          fix: error.fix,
-          meta: { code: error.code },
-        }),
-      );
+      return notOk(mapMigrationToolsError(error));
     }
     throw error;
   }
 
   if (options.ref) {
     activeRefName = options.ref;
-    const refHash = allRefs[activeRefName];
-    if (refHash) {
-      activeRefHash = refHash;
-    } else {
-      try {
-        activeRefHash = resolveRef(allRefs, activeRefName);
-      } catch (error) {
-        if (MigrationToolsError.is(error)) {
-          return notOk(
-            errorRuntime(error.message, {
-              why: error.why,
-              fix: error.fix,
-              meta: { code: error.code },
-            }),
-          );
-        }
-        throw error;
+    try {
+      activeRefHash = resolveRef(allRefs, activeRefName).hash;
+    } catch (error) {
+      if (MigrationToolsError.is(error)) {
+        return notOk(mapMigrationToolsError(error));
       }
+      throw error;
     }
   }
 
-  const statusRefs: StatusRef[] = Object.entries(allRefs).map(([name, hash]) => ({
+  const statusRefs: StatusRef[] = Object.entries(allRefs).map(([name, entry]) => ({
     name,
-    hash,
+    hash: entry.hash,
     active: name === activeRefName,
   }));
 
@@ -434,15 +419,13 @@ async function executeMigrationStatusCommand(
     });
   }
 
-  let bundles: readonly MigrationBundle[];
+  let bundles: readonly MigrationPackage[];
   let graph: MigrationGraph;
   try {
-    ({ bundles, graph } = await loadAllBundles(migrationsDir));
+    ({ bundles, graph } = await loadMigrationPackages(migrationsDir));
   } catch (error) {
     if (MigrationToolsError.is(error)) {
-      return notOk(
-        errorRuntime(error.message, { why: error.why, fix: error.fix, meta: { code: error.code } }),
-      );
+      return notOk(mapMigrationToolsError(error));
     }
     return notOk(
       errorUnexpected(error instanceof Error ? error.message : String(error), {

package/src/config-path-validation.ts

@@ -57,7 +57,6 @@ export function finalizeConfig(config: PrismaNextConfig, configDir: string): Pri
   if (!config.contract) {
     return config;
   }
-
   const contract = normalizeContractConfig(config.contract);
   const source = finalizeContractSource(contract.source, configDir);
   const output = resolve(configDir, contract.output);