@prisma-next/cli 0.12.0-dev.9 → 0.13.0-dev.1

package/src/commands/migration-log.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 type { LedgerEntryRecord } from '@prisma-next/contract/types';
 import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
-import { findPath } from '@prisma-next/migration-tools/migration-graph';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
-import { cyan, dim } from 'colorette';
 import { Command } from 'commander';
 import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
 import {
   CliStructuredError,
-  errorDatabaseConnectionRequired,
-  errorDriverRequired,
   errorUnexpected,
   mapMigrationToolsError,
+  requireLiveDatabase,
 } from '../utils/cli-errors';
 import {
   addGlobalOptions,
@@ -23,56 +20,45 @@ import {
   setCommandSeeAlso,
   targetSupportsMigrations,
 } from '../utils/command-helpers';
-import { buildReadAggregate } from '../utils/contract-space-aggregate-loader';
+import { createAnsiMigrationListStyler } from '../utils/formatters/migration-list-styler';
+import {
+  MIGRATION_LOG_EMPTY_MESSAGE,
+  renderMigrationLogTable,
+  serializeLedgerEntriesForJson,
+} from '../utils/formatters/migration-log-table';
 import { formatStyledHeader } from '../utils/formatters/styled';
 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;
   readonly config?: string;
-}
-
-export interface MigrationLogEntry {
-  readonly dirName: string;
-  readonly from: string;
-  readonly to: string;
-  readonly migrationHash: string;
-  readonly operationCount: number;
-  readonly createdAt: string;
-}
-
-export interface MigrationLogResult {
-  readonly ok: true;
-  readonly markerHash: string | null;
-  readonly applied: readonly MigrationLogEntry[];
-  readonly summary: string;
+  readonly utc?: boolean;
+  readonly ascii?: boolean;
 }
 
 export async function executeMigrationLogCommand(
   options: MigrationLogOptions,
   flags: GlobalFlags,
   ui: TerminalUI,
-): Promise<Result<MigrationLogResult, CliStructuredError>> {
+): Promise<Result<readonly LedgerEntryRecord[], CliStructuredError>> {
   const config = await loadConfig(options.config);
-  const { configPath, appMigrationsRelative, migrationsDir } = resolveMigrationPaths(
-    options.config,
-    config,
-  );
+  const { configPath } = resolveMigrationPaths(options.config, config);
 
   const dbConnection = options.db ?? config.db?.connection;
-  if (!dbConnection) {
-    return notOk(
-      errorDatabaseConnectionRequired({
-        why: `Database connection is required for migration log (set db.connection in ${configPath}, or pass --db <url>)`,
-        commandName: 'migration log',
-      }),
-    );
-  }
-  if (!config.driver) {
-    return notOk(errorDriverRequired({ why: 'Config.driver is required for migration log' }));
+  const missingDb = requireLiveDatabase({
+    dbConnection,
+    hasDriver: !!config.driver,
+    why: `migration log needs a database connection and driver to read the ledger (set db.connection in ${configPath}, or pass --db <url>)`,
+    commandName: 'migration log',
+  });
+  if (missingDb) {
+    return notOk(missingDb);
   }
   if (!targetSupportsMigrations(config.target)) {
     return notOk(errorUnexpected('Target does not support migrations'));
@@ -81,10 +67,9 @@ export async function executeMigrationLogCommand(
   if (!flags.json && !flags.quiet) {
     const header = formatStyledHeader({
       command: 'migration log',
-      description: 'Show executed migration history',
+      description: 'Show executed migration history from the database ledger',
       details: [
         { label: 'config', value: configPath },
-        { label: 'migrations', value: appMigrationsRelative },
         ...(typeof dbConnection === 'string'
           ? [{ label: 'database', value: maskConnectionUrl(dbConnection) }]
           : []),
@@ -94,64 +79,18 @@ export async function executeMigrationLogCommand(
     ui.stderr(header);
   }
 
-  const loaded = await buildReadAggregate(config, { migrationsDir });
-  if (!loaded.ok) {
-    return loaded;
-  }
-  const graph = loaded.value.aggregate.app.graph();
-  const bundles = loaded.value.aggregate.app.packages;
-
   const client = createControlClient({
     family: config.family,
     target: config.target,
     adapter: config.adapter,
-    driver: config.driver,
+    ...ifDefined('driver', config.driver),
     extensionPacks: config.extensionPacks ?? [],
   });
 
   try {
     await client.connect(dbConnection);
-    const marker = await client.readMarker();
-    const markerHash = marker?.storageHash ?? null;
-
-    if (!markerHash) {
-      return ok({
-        ok: true,
-        markerHash: null,
-        applied: [],
-        summary: 'No migrations applied (database has no marker)',
-      });
-    }
-
-    const appliedPath = findPath(graph, EMPTY_CONTRACT_HASH, markerHash);
-    if (appliedPath === null) {
-      return notOk(
-        errorUnexpected('Database marker is not reachable from migration history', {
-          why: `Marker hash ${markerHash} is not reachable from the root of the on-disk migration graph.`,
-          fix: 'The database may have been migrated outside this project. Use `migration status` to inspect the current state.',
-        }),
-      );
-    }
-    const pkgByDirName = new Map(bundles.map((p) => [p.dirName, p]));
-    const entries: MigrationLogEntry[] = appliedPath.map((edge) => {
-      const pkg = pkgByDirName.get(edge.dirName);
-      const ops = (pkg?.ops ?? []) as readonly MigrationPlanOperation[];
-      return {
-        dirName: edge.dirName,
-        from: edge.from,
-        to: edge.to,
-        migrationHash: edge.migrationHash,
-        operationCount: ops.length,
-        createdAt: edge.createdAt,
-      };
-    });
-
-    return ok({
-      ok: true,
-      markerHash,
-      applied: entries,
-      summary: `${entries.length} migration(s) applied`,
-    });
+    const ledger = await client.readLedger();
+    return ok(ledger);
   } catch (error) {
     if (CliStructuredError.is(error)) return notOk(error);
     if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
@@ -170,11 +109,13 @@ export function createMigrationLogCommand(): Command {
   setCommandDescriptions(
     command,
     'Show executed migration history',
-    'Reads the database marker and displays the applied migration chain\n' +
-      'from the initial state to the current marker position.',
+    'Reads the database ledger and displays every applied migration edge\n' +
+      'in chronological order, including rollbacks and re-applies, merged\n' +
+      'across all contract spaces. Requires a database connection.',
   );
   setCommandExamples(command, [
     'prisma-next migration log --db $DATABASE_URL',
+    'prisma-next migration log --utc --db $DATABASE_URL',
     'prisma-next migration log --json --db $DATABASE_URL',
   ]);
   setCommandSeeAlso(command, [
@@ -186,24 +127,33 @@ export function createMigrationLogCommand(): Command {
   addGlobalOptions(command)
     .option('--db <url>', 'Database connection string')
     .option('--config <path>', 'Path to prisma-next.config.ts')
+    .option('--utc', 'Render human timestamps in UTC instead of local time')
+    .option('--ascii', 'Use ASCII glyphs (pipe-friendly)')
     .action(async (options: MigrationLogOptions) => {
       const flags = parseGlobalFlagsOrExit(options);
       const ui = createTerminalUI(flags);
       const result = await executeMigrationLogCommand(options, flags, ui);
-      const exitCode = handleResult(result, flags, ui, (logResult) => {
+      const exitCode = handleResult(result, flags, ui, (entries) => {
         if (flags.json) {
-          ui.output(JSON.stringify(logResult, null, 2));
+          const records = serializeLedgerEntriesForJson(entries);
+          const result: MigrationLogResult = {
+            ok: true,
+            records,
+            summary: `${records.length} migration(s) applied`,
+          };
+          ui.output(JSON.stringify(result, null, 2));
         } else if (!flags.quiet) {
-          const c = (fn: (s: string) => string, s: string) => (flags.color !== false ? fn(s) : s);
-          if (logResult.applied.length === 0) {
-            ui.log(logResult.summary);
+          if (entries.length === 0) {
+            ui.output(MIGRATION_LOG_EMPTY_MESSAGE);
           } else {
-            for (const entry of logResult.applied) {
-              ui.log(
-                `${c(cyan, '✓')} ${entry.dirName}  ${c(dim, entry.migrationHash.slice(0, 16) + '…')}  ${entry.operationCount} op(s)`,
-              );
-            }
-            ui.log(`\n${logResult.summary}`);
+            const styler = createAnsiMigrationListStyler({ useColor: ui.useColor });
+            ui.output(
+              renderMigrationLogTable(entries, {
+                utc: options.utc === true,
+                styler,
+                glyphMode: ui.resolveGlyphMode(options.ascii === true),
+              }),
+            );
           }
         }
       });

package/src/commands/migration-new.ts

@@ -77,6 +77,7 @@ async function executeMigrationNewCommand(
   // at the read site, not somewhere downstream. See TML-2536.
   const stack = createControlStack(config);
   const familyInstance = config.family.create(stack);
+  const controlAdapter = config.adapter.create(stack);
 
   const contractPathAbsolute = resolveContractPath(config);
 
@@ -234,7 +235,7 @@ async function executeMigrationNewCommand(
       }
     }
 
-    const planner = migrations.createPlanner(familyInstance);
+    const planner = migrations.createPlanner(controlAdapter);
     const emptyPlan = planner.emptyMigration(
       {
         packageDir,

package/src/commands/migration-plan.ts

@@ -276,6 +276,7 @@ async function executeMigrationPlanCommand(
   // started dispatching on raw shapes. See TML-2536.
   const stack = createControlStack(config);
   const familyInstance = config.family.create(stack);
+  const controlAdapter = config.adapter.create(stack);
 
   let toContract: Contract;
   try {
@@ -475,7 +476,7 @@ async function executeMigrationPlanCommand(
   }
 
   try {
-    const planner = migrations.createPlanner(familyInstance);
+    const planner = migrations.createPlanner(controlAdapter);
 
     if (
       isAutoBaseline &&

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';
@@ -13,7 +12,7 @@ import { castAs } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
-import { isAbsolute, relative, resolve } from 'pathe';
+import { relative } from 'pathe';
 import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
 import {
@@ -36,61 +35,33 @@ import { formatMigrationShowOutput } from '../utils/formatters/migrations';
 import { formatStyledHeader } from '../utils/formatters/styled';
 import type { CommonCommandOptions } from '../utils/global-flags';
 import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
+import {
+  findPackageByDirPath,
+  looksLikePath,
+  resolveAppTargetPath,
+} 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;
-}
-
-export interface MigrationShowResult {
-  readonly ok: true;
-  readonly migration: MigrationShowPresent;
-}
-
-function looksLikePath(target: string): boolean {
-  return target.includes('/') || target.includes('\\');
+  readonly operations: { id: string; label: string; operationClass: string }[];
+  readonly preview: {
+    statements: { text: string; language: string }[];
+  };
 }
 
-export function resolveAppTargetPath(
-  target: string,
-  appMigrationsDir: string,
-  appMigrationsRelative: string,
-): Result<string, CliStructuredError> {
-  const targetPath = resolve(target);
-  const relativeToApp = relative(appMigrationsDir, targetPath);
-  const isOutsideAppDir =
-    relativeToApp === '' ||
-    relativeToApp === '.' ||
-    relativeToApp.startsWith('..') ||
-    isAbsolute(relativeToApp);
-  if (isOutsideAppDir) {
-    return notOk(
-      errorRuntime('Target must point to an app-space migration', {
-        why: `Expected a path under ${appMigrationsRelative}, got ${target}`,
-        fix: 'Pass an app-space migration directory or use a hash prefix.',
-      }),
-    );
-  }
-  return ok(targetPath);
-}
+export type { MigrationShowResult };
 
 function pkgToPresent(
   spaceId: string,
@@ -98,33 +69,23 @@ 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] },
   };
 }
 
-function findPackageByDirPath(
-  packages: readonly OnDiskMigrationPackage[],
-  resolvedDirPath: string,
-): OnDiskMigrationPackage | undefined {
-  const normalized = resolve(resolvedDirPath);
-  return packages.find((p) => resolve(p.dirPath) === normalized);
-}
-
 async function executeMigrationShowCommand(
   target: string,
   options: MigrationShowOptions,
@@ -248,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,
   });
 }
 
@@ -260,11 +223,13 @@ export function createMigrationShowCommand(): Command {
     command,
     'Display migration package contents',
     'Shows the operations, statement preview, and metadata for one app-space migration.\n' +
-      'Accepts a directory path, directory name, or hash prefix.',
+      'Accepts a directory path, directory name, or hash prefix.\n' +
+      'Offline — does not consult the database.',
   );
   setCommandExamples(command, [
     'prisma-next migration show 20260101_100000_add_user',
     'prisma-next migration show sha256:a1b2c3',
+    'prisma-next migration show 20260101_100000_add_user --json',
   ]);
   setCommandSeeAlso(command, [
     { verb: 'migration status', oneLiner: 'Show migration path and pending status' },
@@ -273,7 +238,7 @@ export function createMigrationShowCommand(): Command {
     { verb: 'migration graph', oneLiner: 'Show the migration graph topology' },
   ]);
   addGlobalOptions(command)
-    .argument('<target>', 'Migration reference: directory name, hash/prefix, or path')
+    .argument('<target>', 'Migration reference: directory name, hash/prefix, ref, or path')
     .option('--config <path>', 'Path to prisma-next.config.ts')
     .action(async (target: string, options: MigrationShowOptions) => {
       const flags = parseGlobalFlagsOrExit(options);

package/src/commands/migration-status-overlay.ts

@@ -0,0 +1,61 @@
+import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
+import { findPath } from '@prisma-next/migration-tools/migration-graph';
+import type { MigrationEdgeAnnotation } from '../utils/formatters/migration-graph-labels';
+
+export interface DeriveStatusEdgeAnnotationsInput {
+  readonly graph: MigrationGraph;
+  readonly targetHash: string;
+  readonly originHash: string;
+  readonly appliedMigrationHashes: ReadonlySet<string>;
+  readonly showAppliedOverlay: boolean;
+}
+
+export function deriveStatusEdgeAnnotations(
+  input: DeriveStatusEdgeAnnotationsInput,
+): ReadonlyMap<string, MigrationEdgeAnnotation> {
+  const annotations = new Map<string, MigrationEdgeAnnotation>();
+
+  if (input.showAppliedOverlay) {
+    for (const edge of input.graph.migrationByHash.values()) {
+      if (input.appliedMigrationHashes.has(edge.migrationHash)) {
+        annotations.set(edge.migrationHash, { status: 'applied' });
+      }
+    }
+  }
+
+  if (!input.graph.nodes.has(input.originHash)) {
+    return annotations;
+  }
+
+  const pendingPath = findPath(input.graph, input.originHash, input.targetHash);
+  if (!pendingPath) {
+    return annotations;
+  }
+
+  for (const edge of pendingPath) {
+    if (input.appliedMigrationHashes.has(edge.migrationHash)) {
+      continue;
+    }
+    const existing = annotations.get(edge.migrationHash);
+    if (existing?.status === 'applied') {
+      continue;
+    }
+    annotations.set(edge.migrationHash, { status: 'pending' });
+  }
+
+  return annotations;
+}
+
+export function appliedHashesFromLedger(
+  ledgerEntries: ReadonlyArray<{ readonly migrationHash: string }>,
+): ReadonlySet<string> {
+  return new Set(ledgerEntries.map((entry) => entry.migrationHash));
+}
+
+export function statusForMigrationHash(
+  migrationHash: string,
+  annotations: ReadonlyMap<string, MigrationEdgeAnnotation>,
+): 'applied' | 'pending' | null {
+  const status = annotations.get(migrationHash)?.status;
+  return status ?? null;
+}