@prisma-next/cli 0.12.0-dev.3 → 0.12.0-dev.31

package/src/commands/migration-log.ts

@@ -1,9 +1,6 @@
-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 { 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';
@@ -23,7 +20,12 @@ 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';
@@ -33,34 +35,16 @@ import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
 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;
 }
 
 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) {
@@ -81,10 +65,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,13 +77,6 @@ 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,
@@ -111,47 +87,8 @@ export async function executeMigrationLogCommand(
 
   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 +107,12 @@ 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.',
   );
   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 +124,20 @@ 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')
     .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));
+          ui.output(JSON.stringify(serializeLedgerEntriesForJson(entries), 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 }));
           }
         }
       });

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-tree-render';
+
+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;
+}