@prisma-next/cli 0.12.0-dev.48 → 0.12.0-dev.49

package/src/commands/migration-check.ts

@@ -47,10 +47,7 @@ import { formatErrorJson, formatErrorOutput } from '../utils/formatters/errors';
 import { formatStyledHeader } from '../utils/formatters/styled';
 import type { CommonCommandOptions } from '../utils/global-flags';
 import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
-import {
-  type CheckFailure,
-  integrityViolationToCheckFailure,
-} from '../utils/integrity-violation-to-check-failure';
+import { integrityViolationToCheckFailure } from '../utils/integrity-violation-to-check-failure';
 import {
   findPackageByDirPath,
   looksLikePath,
@@ -58,6 +55,7 @@ import {
   resolveTargetPathAcrossSpaces,
 } from '../utils/migration-path-target';
 import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
+import type { CheckFailure, MigrationCheckResult } from './json/schemas';
 import { INTEGRITY_FAILED, OK, PRECONDITION } from './migration-check/exit-codes';
 
 interface MigrationCheckOptions extends CommonCommandOptions {
@@ -65,13 +63,8 @@ interface MigrationCheckOptions extends CommonCommandOptions {
   readonly space?: string;
 }
 
-export type { CheckFailure } from '../utils/integrity-violation-to-check-failure';
-
-export interface MigrationCheckResult {
-  readonly ok: boolean;
-  readonly failures: readonly CheckFailure[];
-  readonly summary: string;
-}
+export type { CheckFailure, MigrationCheckResult } from './json/schemas';
+export { migrationCheckResultSchema } from './json/schemas';
 
 function migrationPathRelative(dirPath: string): string {
   return relative(process.cwd(), dirPath);
@@ -81,10 +74,16 @@ function migrationFileRelative(dirPath: string, fileName: string): string {
   return join(migrationPathRelative(dirPath), fileName);
 }
 
-function checkFileExists(dirPath: string, dirName: string, fileName: string): CheckFailure | null {
+function checkFileExists(
+  spaceId: string,
+  dirPath: string,
+  dirName: string,
+  fileName: string,
+): CheckFailure | null {
   if (!existsSync(join(dirPath, fileName))) {
     return {
-      pnCode: 'PN-MIG-CHECK-002',
+      space: spaceId,
+      code: 'PN-MIG-CHECK-002',
       where: migrationFileRelative(dirPath, fileName),
       why: `${fileName} is missing from ${dirName}`,
       fix: 'Re-emit the migration package or restore from version control.',
@@ -93,7 +92,10 @@ function checkFileExists(dirPath: string, dirName: string, fileName: string): Ch
   return null;
 }
 
-function checkSnapshotConsistency(pkg: OnDiskMigrationPackage): CheckFailure | null {
+function checkSnapshotConsistency(
+  spaceId: string,
+  pkg: OnDiskMigrationPackage,
+): CheckFailure | null {
   const endContractPath = join(pkg.dirPath, 'end-contract.json');
   if (!existsSync(endContractPath)) return null;
   try {
@@ -102,7 +104,8 @@ function checkSnapshotConsistency(pkg: OnDiskMigrationPackage): CheckFailure | n
     const snapshotHash = storage?.['storageHash'];
     if (typeof snapshotHash === 'string' && snapshotHash !== pkg.metadata.to) {
       return {
-        pnCode: 'PN-MIG-CHECK-005',
+        space: spaceId,
+        code: 'PN-MIG-CHECK-005',
         where: migrationPathRelative(pkg.dirPath),
         why: `Migration "${pkg.dirName}" declares to=${pkg.metadata.to} but end-contract.json has storageHash=${snapshotHash}`,
         fix: 'Re-emit the migration package so migration.json and end-contract.json agree.',
@@ -110,7 +113,8 @@ function checkSnapshotConsistency(pkg: OnDiskMigrationPackage): CheckFailure | n
     }
   } catch {
     return {
-      pnCode: 'PN-MIG-CHECK-006',
+      space: spaceId,
+      code: 'PN-MIG-CHECK-006',
       where: migrationPathRelative(pkg.dirPath),
       why: `Migration "${pkg.dirName}" has an unparseable end-contract.json.`,
       fix: 'Re-emit the migration package to repair the snapshot file.',
@@ -189,7 +193,7 @@ function checkManifestFilesPresent(space: CheckSpace): readonly CheckFailure[] {
     }
     if (!loadedDirNames.has(entry)) {
       for (const f of ['migration.json', 'ops.json']) {
-        const fail = checkFileExists(entryPath, entry, f);
+        const fail = checkFileExists(space.spaceId, entryPath, entry, f);
         if (fail) failures.push(fail);
       }
     }
@@ -207,7 +211,8 @@ function checkReachability(space: CheckSpace): readonly CheckFailure[] {
       pkg.metadata.from === 'sha256:empty';
     if (!isReachable) {
       failures.push({
-        pnCode: 'PN-MIG-CHECK-003',
+        space: space.spaceId,
+        code: 'PN-MIG-CHECK-003',
         where: migrationPathRelative(pkg.dirPath),
         why: `Migration "${pkg.dirName}" starts from ${pkg.metadata.from} which no other migration produces`,
         fix: 'This migration is unreachable in the graph. Delete it or re-emit a connecting migration.',
@@ -222,7 +227,8 @@ function checkDanglingRefs(space: CheckSpace): readonly CheckFailure[] {
   for (const [name, entry] of Object.entries(space.refs)) {
     if (!space.graph.nodes.has(entry.hash)) {
       failures.push({
-        pnCode: 'PN-MIG-CHECK-004',
+        space: space.spaceId,
+        code: 'PN-MIG-CHECK-004',
         where: relative(process.cwd(), join(space.refsDir, `${name}.json`)),
         why: `Ref "${name}" points at ${entry.hash} which does not exist in the migration graph`,
         fix: `Update the ref with \`prisma-next ref set ${name} <valid-hash>\` or delete it.`,
@@ -235,7 +241,9 @@ function checkDanglingRefs(space: CheckSpace): readonly CheckFailure[] {
 function checkSpace(space: CheckSpace): readonly CheckFailure[] {
   return [
     ...checkManifestFilesPresent(space),
-    ...space.packages.map(checkSnapshotConsistency).filter((f): f is CheckFailure => f !== null),
+    ...space.packages
+      .map((pkg) => checkSnapshotConsistency(space.spaceId, pkg))
+      .filter((f): f is CheckFailure => f !== null),
     ...checkReachability(space),
     ...checkDanglingRefs(space),
   ];
@@ -535,21 +543,22 @@ async function checkSingleTarget(
   const failures: CheckFailure[] = [...checkManifestFilesPresent(matchedSpace)];
 
   for (const f of ['migration.json', 'ops.json']) {
-    const fail = checkFileExists(matchedPkg.dirPath, matchedPkg.dirName, f);
+    const fail = checkFileExists(matchedSpace.spaceId, matchedPkg.dirPath, matchedPkg.dirName, f);
     if (fail) failures.push(fail);
   }
 
   const verification = verifyMigrationHash(matchedPkg);
   if (!verification.ok) {
     failures.push({
-      pnCode: 'PN-MIG-CHECK-001',
+      space: matchedSpace.spaceId,
+      code: 'PN-MIG-CHECK-001',
       where: migrationFileRelative(matchedPkg.dirPath, 'migration.json'),
       why: `Stored hash ${verification.storedHash} does not match recomputed hash ${verification.computedHash}`,
       fix: 'Re-emit the migration package or restore from version control.',
     });
   }
 
-  const snapshotFailure = checkSnapshotConsistency(matchedPkg);
+  const snapshotFailure = checkSnapshotConsistency(matchedSpace.spaceId, matchedPkg);
   if (snapshotFailure) failures.push(snapshotFailure);
 
   const resolvedSpaceId = matchedSpace.spaceId !== 'app' ? matchedSpace.spaceId : undefined;
@@ -641,7 +650,7 @@ export function createMigrationCheckCommand(): Command {
           ui.log(`✔ ${result.summary}${spaceSuffix}`);
         } else {
           for (const f of result.failures) {
-            ui.log(`✗ [${f.pnCode}] ${f.where}: ${f.why}`);
+            ui.log(`✗ [${f.code}] ${f.where}: ${f.why}`);
             ui.log(`  fix: ${f.fix}`);
           }
           ui.log(`\n${result.summary}`);

package/src/commands/migration-graph.ts

@@ -1,3 +1,4 @@
+import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
 import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { ok, type Result } from '@prisma-next/utils/result';
@@ -25,6 +26,7 @@ import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags'
 import { shouldShowLegend, validateLegendOptions } from '../utils/legend';
 import { handleResult } from '../utils/result-handler';
 import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
+import type { MigrationGraphJsonResult, MigrationSpaceGraphEntry } from './json/schemas';
 import {
   listRefsByContractHash,
   migrationSpaceListEntriesFromAggregate,
@@ -40,42 +42,32 @@ interface MigrationGraphOptions extends CommonCommandOptions {
 }
 
 export interface MigrationGraphTreeSection {
-  readonly spaceId: string;
+  readonly space: string;
   readonly tree: string;
   readonly showHeading: boolean;
 }
 
 export interface MigrationGraphResult {
   readonly ok: true;
-  /** App-space graph for `--json` / `--dot` (unchanged machine output). */
+  /** App-space graph for the `--dot` Graphviz output. */
   readonly graph: MigrationGraph;
+  /** Nested per-space contracts + migrations for `--json`. */
+  readonly spaces: readonly MigrationSpaceGraphEntry[];
   readonly treeSections: readonly MigrationGraphTreeSection[];
   readonly summary: string;
 }
 
-export interface MigrationGraphJsonEdge {
-  readonly dirName: string;
-  readonly from: string;
-  readonly to: string;
-  readonly migrationHash: string;
-}
-
-export interface MigrationGraphJsonResult {
-  readonly ok: true;
-  readonly nodes: readonly string[];
-  readonly edges: readonly MigrationGraphJsonEdge[];
-  readonly summary: string;
-}
-
-function computeGraphSummary(graph: MigrationGraph): string {
-  return `${graph.nodes.size} node(s), ${graph.migrationByHash.size} edge(s)`;
+function computeGraphSummary(spaces: readonly MigrationSpaceGraphEntry[]): string {
+  const contractCount = spaces.reduce((count, space) => count + space.contracts.length, 0);
+  const migrationCount = spaces.reduce((count, space) => count + space.migrations.length, 0);
+  return `${spaces.length} space(s), ${contractCount} contract(s), ${migrationCount} migration(s)`;
 }
 
 export function formatMigrationGraphHumanOutput(result: MigrationGraphResult): string {
   const sections: string[] = [];
   for (const section of result.treeSections) {
     if (section.showHeading) {
-      sections.push(`${section.spaceId}:`);
+      sections.push(`${section.space}:`);
     }
     if (section.tree.length > 0) {
       sections.push(section.tree);
@@ -148,7 +140,7 @@ export async function executeMigrationGraphCommand(
     ? scopedSpaces
         .filter((spaceEntry) => spaceEntry.migrations.length > 0)
         .map((spaceEntry) => ({
-          graph: aggregate.space(spaceEntry.spaceId)!.graph(),
+          graph: aggregate.space(spaceEntry.space)!.graph(),
           liveContractHash,
         }))
     : [];
@@ -160,12 +152,14 @@ export async function executeMigrationGraphCommand(
     globalLayoutInputs.length > 0 ? computeGlobalMaxDirNameWidth(globalLayoutInputs) : undefined;
 
   const treeSections: MigrationGraphTreeSection[] = [];
+  const spaces: MigrationSpaceGraphEntry[] = [];
   for (const spaceEntry of scopedSpaces) {
-    const member = aggregate.space(spaceEntry.spaceId);
+    const member = aggregate.space(spaceEntry.space);
     if (member === undefined) {
       continue;
     }
     const graph = member.graph();
+    const refsByHash = listRefsByContractHash(member);
     const tree =
       spaceEntry.migrations.length === 0
         ? ''
@@ -175,24 +169,38 @@ export async function executeMigrationGraphCommand(
             liveContractHash,
             glyphMode,
             colorize,
-            refsByHash: listRefsByContractHash(member),
+            refsByHash,
             ...(globalMaxEdgeTreePrefixWidth !== undefined ? { globalMaxEdgeTreePrefixWidth } : {}),
             ...(globalMaxDirNameWidth !== undefined ? { globalMaxDirNameWidth } : {}),
           });
     const displayTree =
       showSpaceHeadings && tree.length > 0 ? indentMigrationGraphTreeBlock(tree, '  ') : tree;
     treeSections.push({
-      spaceId: spaceEntry.spaceId,
+      space: spaceEntry.space,
       tree: displayTree,
       showHeading: showSpaceHeadings,
     });
+    spaces.push({
+      space: spaceEntry.space,
+      contracts: [...graph.nodes].map((hash) => ({
+        hash,
+        refs: [...(refsByHash.get(hash) ?? [])],
+      })),
+      migrations: [...graph.migrationByHash.values()].map((edge) => ({
+        name: edge.dirName,
+        hash: edge.migrationHash,
+        fromContract: edge.from === EMPTY_CONTRACT_HASH ? null : edge.from,
+        toContract: edge.to,
+      })),
+    });
   }
 
   return ok({
     ok: true,
     graph: appGraph,
+    spaces,
     treeSections,
-    summary: computeGraphSummary(appGraph),
+    summary: computeGraphSummary(spaces),
   });
 }
 
@@ -246,20 +254,10 @@ export function createMigrationGraphCommand(): Command {
           lines.push('}');
           ui.output(lines.join('\n'));
         } else if (flags.json) {
-          const nodes = [...graphResult.graph.nodes];
-          const edges = [...graphResult.graph.migrationByHash.values()].map(
-            (e): MigrationGraphJsonEdge => ({
-              dirName: e.dirName,
-              from: e.from,
-              to: e.to,
-              migrationHash: e.migrationHash,
-            }),
-          );
           const jsonResult: MigrationGraphJsonResult = {
             ok: true,
-            nodes,
-            edges,
-            summary: `${graphResult.graph.nodes.size} node(s), ${graphResult.graph.migrationByHash.size} edge(s)`,
+            spaces: [...graphResult.spaces],
+            summary: graphResult.summary,
           };
           ui.output(JSON.stringify(jsonResult, null, 2));
         } else if (!flags.quiet) {

package/src/commands/migration-list.ts

@@ -52,8 +52,8 @@ function compareSpaceIds(a: string, b: string): number {
 }
 
 function compareDirNamesDescending(a: MigrationListEntry, b: MigrationListEntry): number {
-  if (a.dirName < b.dirName) return 1;
-  if (a.dirName > b.dirName) return -1;
+  if (a.name < b.name) return 1;
+  if (a.name > b.name) return -1;
   return 0;
 }
 
@@ -110,18 +110,18 @@ export async function migrationSpaceListEntriesFromAggregate(
     const refsByHash = listRefsByContractHash(member);
     const migrations: MigrationListEntry[] = member.packages
       .map((pkg) => ({
-        dirName: pkg.dirName,
-        from: pkg.metadata.from,
-        to: pkg.metadata.to,
-        migrationHash: pkg.metadata.migrationHash,
+        name: pkg.dirName,
+        hash: pkg.metadata.migrationHash,
+        fromContract: pkg.metadata.from,
+        toContract: pkg.metadata.to,
         operationCount: pkg.ops.length,
         createdAt: pkg.metadata.createdAt,
-        refs: refsByHash.get(pkg.metadata.to) ?? [],
-        providedInvariants: pkg.metadata.providedInvariants,
+        refs: [...(refsByHash.get(pkg.metadata.to) ?? [])],
+        providedInvariants: [...pkg.metadata.providedInvariants],
       }))
       .sort(compareDirNamesDescending);
 
-    spaces.push({ spaceId, migrations });
+    spaces.push({ space: spaceId, migrations });
   }
 
   return spaces;
@@ -198,19 +198,19 @@ export function runMigrationList(
     return notOk(errorInvalidSpaceId(spaceFilter));
   }
 
-  if (spaceFilter !== undefined && !spaces.some((s) => s.spaceId === spaceFilter)) {
-    return notOk(errorSpaceNotFound(spaceFilter, spaces.map((s) => s.spaceId).sort()));
+  if (spaceFilter !== undefined && !spaces.some((s) => s.space === spaceFilter)) {
+    return notOk(errorSpaceNotFound(spaceFilter, spaces.map((s) => s.space).sort()));
   }
 
   const scopedSpaces =
-    spaceFilter !== undefined ? spaces.filter((s) => s.spaceId === spaceFilter) : spaces;
+    spaceFilter !== undefined ? spaces.filter((s) => s.space === spaceFilter) : spaces;
 
   const resultSpaces: readonly MigrationSpaceListEntry[] =
-    scopedSpaces.length === 0 ? [{ spaceId: APP_SPACE_ID, migrations: [] }] : scopedSpaces;
+    scopedSpaces.length === 0 ? [{ space: APP_SPACE_ID, migrations: [] }] : scopedSpaces;
 
   return ok({
     ok: true,
-    spaces: resultSpaces,
+    spaces: [...resultSpaces],
     summary: computeSummary(resultSpaces),
   });
 }

package/src/commands/migration-log.ts

@@ -24,7 +24,6 @@ import { createAnsiMigrationListStyler } from '../utils/formatters/migration-lis
 import {
   MIGRATION_LOG_EMPTY_MESSAGE,
   renderMigrationLogTable,
-  type SerializedLedgerEntryRecord,
   serializeLedgerEntriesForJson,
 } from '../utils/formatters/migration-log-table';
 import { formatStyledHeader } from '../utils/formatters/styled';
@@ -32,6 +31,9 @@ import type { CommonCommandOptions } from '../utils/global-flags';
 import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
 import { handleResult } from '../utils/result-handler';
 import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
+import type { MigrationLogResult } from './json/schemas';
+
+export type { MigrationLogResult };
 
 interface MigrationLogOptions extends CommonCommandOptions {
   readonly db?: string;
@@ -40,11 +42,6 @@ interface MigrationLogOptions extends CommonCommandOptions {
   readonly ascii?: boolean;
 }
 
-export interface MigrationLogResult {
-  readonly ok: true;
-  readonly entries: readonly SerializedLedgerEntryRecord[];
-}
-
 export async function executeMigrationLogCommand(
   options: MigrationLogOptions,
   flags: GlobalFlags,
@@ -138,9 +135,11 @@ export function createMigrationLogCommand(): Command {
       const result = await executeMigrationLogCommand(options, flags, ui);
       const exitCode = handleResult(result, flags, ui, (entries) => {
         if (flags.json) {
+          const records = serializeLedgerEntriesForJson(entries);
           const result: MigrationLogResult = {
             ok: true,
-            entries: serializeLedgerEntriesForJson(entries),
+            records,
+            summary: `${records.length} migration(s) applied`,
           };
           ui.output(JSON.stringify(result, null, 2));
         } else if (!flags.quiet) {

package/src/commands/migration-show.ts

@@ -4,7 +4,6 @@ import {
   APP_SPACE_ID,
   createControlStack,
   type MigrationPlanOperation,
-  type OperationPreview,
 } from '@prisma-next/framework-components/control';
 import { loadContractSpaceAggregate } from '@prisma-next/migration-tools/aggregate';
 import type { OnDiskMigrationPackage } from '@prisma-next/migration-tools/package';
@@ -43,32 +42,26 @@ import {
 } from '../utils/migration-path-target';
 import { handleResult } from '../utils/result-handler';
 import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
+import type { MigrationShowResult } from './json/schemas';
 
 interface MigrationShowOptions extends CommonCommandOptions {
   readonly config?: string;
 }
 
 export interface MigrationShowPresent {
-  readonly spaceId: string;
-  readonly dirName: string;
-  readonly dirPath: string;
-  readonly from: string | null;
-  readonly to: string;
-  readonly migrationHash: string;
+  readonly space: string;
+  readonly name: string;
+  readonly fromContract: string | null;
+  readonly toContract: string;
+  readonly hash: string;
   readonly createdAt: string;
-  readonly operations: readonly {
-    readonly id: string;
-    readonly label: string;
-    readonly operationClass: string;
-  }[];
-  readonly preview: OperationPreview;
-  readonly summary: string;
+  readonly operations: { id: string; label: string; operationClass: string }[];
+  readonly preview: {
+    statements: { text: string; language: string }[];
+  };
 }
 
-export interface MigrationShowResult {
-  readonly ok: true;
-  readonly migration: MigrationShowPresent;
-}
+export type { MigrationShowResult };
 
 function pkgToPresent(
   spaceId: string,
@@ -76,22 +69,20 @@ function pkgToPresent(
   client: ReturnType<typeof createControlClient>,
 ): MigrationShowPresent {
   const ops = castAs<readonly MigrationPlanOperation[]>(pkg.ops);
-  const preview: OperationPreview = client.toOperationPreview(ops) ?? { statements: [] };
+  const rawPreview = client.toOperationPreview(ops) ?? { statements: [] };
   return {
-    spaceId,
-    dirName: pkg.dirName,
-    dirPath: relative(process.cwd(), pkg.dirPath),
-    from: pkg.metadata.from,
-    to: pkg.metadata.to,
-    migrationHash: pkg.metadata.migrationHash,
+    space: spaceId,
+    name: pkg.dirName,
+    fromContract: pkg.metadata.from,
+    toContract: pkg.metadata.to,
+    hash: pkg.metadata.migrationHash,
     createdAt: pkg.metadata.createdAt,
     operations: ops.map((op) => ({
       id: op.id,
       label: op.label,
       operationClass: op.operationClass,
     })),
-    preview,
-    summary: `${ops.length} operation(s)`,
+    preview: { statements: [...rawPreview.statements] },
   };
 }
 
@@ -218,9 +209,11 @@ async function executeMigrationShowCommand(
     appPkg = matchedPkg;
   }
 
+  const migration = pkgToPresent(APP_SPACE_ID, appPkg, client);
   return ok({
     ok: true,
-    migration: pkgToPresent(APP_SPACE_ID, appPkg, client),
+    summary: `Migration ${migration.name} in ${migration.space}: ${migration.operations.length} operation(s)`,
+    migration,
   });
 }