@prisma-next/cli 0.12.0-dev.21 → 0.12.0-dev.23

package/src/utils/formatters/migration-list-render.ts

@@ -1,16 +1,12 @@
+import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
+import type { MigrationEdge, MigrationGraph } from '@prisma-next/migration-tools/graph';
 import type { GlyphMode } from '../glyph-mode';
+import { buildMigrationGraphLayout } from './migration-graph-layout';
+import { buildMigrationGraphRows } from './migration-graph-rows';
 import {
-  computeMigrationDirNameWidth,
-  formatMigrationDataColumn,
-  migrationListEmptySource,
-  migrationListForwardArrow,
-  migrationListKindGlyph,
-} from './migration-list-data-column';
-import {
-  classifyMigrationListGraphTopology,
-  type MigrationEdgeKind,
-  type MigrationListGraphTopology,
-} from './migration-list-graph-topology';
+  type MigrationEdgeAnnotation,
+  renderMigrationGraphTree,
+} from './migration-graph-tree-render';
 import type { MigrationListEntry, MigrationListResult } from './migration-list-types';
 
 export type { GlyphMode } from '../glyph-mode';
@@ -62,42 +58,88 @@ export const IDENTITY_MIGRATION_LIST_STYLER: MigrationListStyler = {
   emptyState: (text) => text,
 };
 
-function resolveEdgeKind(
-  migrationHash: string,
-  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
-): MigrationEdgeKind {
-  return kindByMigrationHash.get(migrationHash) ?? 'forward';
+function canonicalFrom(from: string | null): string {
+  return from ?? EMPTY_CONTRACT_HASH;
 }
 
-function formatMigrationRow(
-  migration: MigrationListEntry,
-  dirNameWidth: number,
-  edgeKind: MigrationEdgeKind,
-  glyphMode: GlyphMode,
-  style: MigrationListStyler,
-): string {
-  const kindColumn = `${style.kind(migrationListKindGlyph(glyphMode, edgeKind))} `;
-  const data = formatMigrationDataColumn(migration, {
-    dirNameWidth,
-    edgeKind,
-    style,
-    forwardArrow: migrationListForwardArrow(glyphMode),
-    emptySource: migrationListEmptySource(glyphMode),
-  });
-  return `${kindColumn}${data}`;
+export function migrationGraphFromListEntries(
+  entries: readonly MigrationListEntry[],
+): MigrationGraph {
+  const nodes = new Set<string>();
+  const forwardChain = new Map<string, MigrationEdge[]>();
+  const reverseChain = new Map<string, MigrationEdge[]>();
+  const migrationByHash = new Map<string, MigrationEdge>();
+
+  for (const entry of entries) {
+    const from = canonicalFrom(entry.from);
+    const edge: MigrationEdge = {
+      from,
+      to: entry.to,
+      migrationHash: entry.migrationHash,
+      dirName: entry.dirName,
+      createdAt: entry.createdAt,
+      invariants: entry.providedInvariants,
+    };
+    nodes.add(from);
+    nodes.add(entry.to);
+    const forward = forwardChain.get(from);
+    if (forward) forward.push(edge);
+    else forwardChain.set(from, [edge]);
+    const reverse = reverseChain.get(entry.to);
+    if (reverse) reverse.push(edge);
+    else reverseChain.set(entry.to, [edge]);
+    migrationByHash.set(entry.migrationHash, edge);
+  }
+
+  return { nodes, forwardChain, reverseChain, migrationByHash };
+}
+
+export function buildEdgeAnnotationsByHashFromListEntries(
+  entries: readonly MigrationListEntry[],
+): ReadonlyMap<string, MigrationEdgeAnnotation> {
+  const annotations = new Map<string, MigrationEdgeAnnotation>();
+  for (const entry of entries) {
+    annotations.set(entry.migrationHash, {
+      operationCount: entry.operationCount,
+      invariants: entry.providedInvariants,
+    });
+  }
+  return annotations;
+}
+
+export function buildRefsByHashFromListEntries(
+  entries: readonly MigrationListEntry[],
+): ReadonlyMap<string, readonly string[]> {
+  const refsByHash = new Map<string, readonly string[]>();
+  for (const entry of entries) {
+    if (entry.refs.length > 0) {
+      refsByHash.set(entry.to, entry.refs);
+    }
+  }
+  return refsByHash;
 }
 
 function formatEmptyStateLine(spaceId: string, style: MigrationListStyler): string {
   return style.emptyState(`There are no migrations in migrations/${spaceId}/ yet`);
 }
 
-function renderSpaceBlock(
+function indentTreeBlock(treeOutput: string, indent: string): string {
+  if (treeOutput.length === 0) {
+    return treeOutput;
+  }
+  return treeOutput
+    .split('\n')
+    .map((line) => (line.length === 0 ? line : `${indent}${line}`))
+    .join('\n');
+}
+
+function renderSpaceTreeBlock(
   spaceId: string,
   migrations: readonly MigrationListEntry[],
   multiSpace: boolean,
   glyphMode: GlyphMode,
-  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
   style: MigrationListStyler,
+  colorize: boolean,
 ): readonly string[] {
   if (migrations.length === 0) {
     const emptyLine = formatEmptyStateLine(spaceId, style);
@@ -107,50 +149,44 @@ function renderSpaceBlock(
     return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
   }
 
-  const dirNameWidth = computeMigrationDirNameWidth(migrations);
-  const rows = migrations.map((entry) =>
-    formatMigrationRow(
-      entry,
-      dirNameWidth,
-      resolveEdgeKind(entry.migrationHash, kindByMigrationHash),
-      glyphMode,
-      style,
-    ),
-  );
+  const graph = migrationGraphFromListEntries(migrations);
+  const rowModel = buildMigrationGraphRows(graph);
+  const layout = buildMigrationGraphLayout(rowModel);
+  const treeOutput = renderMigrationGraphTree(layout, {
+    refsByHash: buildRefsByHashFromListEntries(migrations),
+    edgeAnnotationsByHash: buildEdgeAnnotationsByHashFromListEntries(migrations),
+    colorize,
+    glyphMode,
+  });
+
   if (!multiSpace) {
-    return rows;
+    return treeOutput.length === 0 ? [] : [treeOutput];
   }
-  return [style.spaceHeading(`${spaceId}:`), ...rows.map((row) => `  ${row}`)];
+
+  const indented = indentTreeBlock(treeOutput, '  ');
+  return [style.spaceHeading(`${spaceId}:`), indented];
 }
 
-export function buildMigrationListTopologyBySpace(
-  result: MigrationListResult,
-): ReadonlyMap<string, MigrationListGraphTopology> {
-  const topologyBySpaceId = new Map<string, MigrationListGraphTopology>();
-  for (const space of result.spaces) {
-    topologyBySpaceId.set(space.spaceId, classifyMigrationListGraphTopology(space.migrations));
-  }
-  return topologyBySpaceId;
+export interface RenderMigrationListWithStyleOptions {
+  readonly colorize?: boolean;
 }
 
 /**
- * Compose the styled `migration list` output. The renderer is
- * presentation-neutral — every token passes through `style` before
- * landing in the output, so the same composition serves the pure-text
- * path ({@link renderMigrationList} via
- * {@link IDENTITY_MIGRATION_LIST_STYLER}) and the ANSI-styled CLI path
- * (via the ANSI styler the CLI shell wires up).
+ * Compose the styled `migration list` human output via the shared tree
+ * renderer. Each on-disk migration is one edge row with package-fact
+ * annotations; refs decorate destination contract nodes.
+ *
+ * `options.colorize` must match whether `style` emits ANSI (e.g. both true for
+ * `createAnsiMigrationListStyler({ useColor: true })`).
  */
 export function renderMigrationListWithStyle(
   result: MigrationListResult,
   style: MigrationListStyler,
   glyphMode: GlyphMode = 'unicode',
-  topologyBySpaceId: ReadonlyMap<
-    string,
-    MigrationListGraphTopology
-  > = buildMigrationListTopologyBySpace(result),
+  options: RenderMigrationListWithStyleOptions = {},
 ): string {
   const multiSpace = result.spaces.length > 1;
+  const colorize = options.colorize ?? false;
   const lines: string[] = [];
 
   for (let index = 0; index < result.spaces.length; index++) {
@@ -158,18 +194,14 @@ export function renderMigrationListWithStyle(
     if (index > 0) {
       lines.push('');
     }
-    const topology = topologyBySpaceId.get(space.spaceId);
-    const kindByMigrationHash =
-      topology?.kindByMigrationHash ??
-      classifyMigrationListGraphTopology(space.migrations).kindByMigrationHash;
     lines.push(
-      ...renderSpaceBlock(
+      ...renderSpaceTreeBlock(
         space.spaceId,
         space.migrations,
         multiSpace,
         glyphMode,
-        kindByMigrationHash,
         style,
+        colorize,
       ),
     );
   }

package/src/utils/formatters/migration-log-table.ts

@@ -0,0 +1,190 @@
+import type { LedgerEntryRecord } from '@prisma-next/contract/types';
+import stringWidth from 'string-width';
+import {
+  abbreviateContractHash,
+  MIGRATION_LIST_EMPTY_SOURCE,
+  MIGRATION_LIST_FORWARD_EDGE_GLYPH,
+} from './migration-list-data-column';
+import { IDENTITY_MIGRATION_LIST_STYLER, type MigrationListStyler } from './migration-list-render';
+
+export type LedgerTimestampMode = 'local' | 'utc' | 'iso';
+
+export interface RenderMigrationLogTableOptions {
+  readonly utc?: boolean;
+  readonly styler?: MigrationListStyler;
+}
+
+export interface SerializedLedgerEntryRecord {
+  readonly space: string;
+  readonly migrationName: string;
+  readonly migrationHash: string;
+  readonly from: string | null;
+  readonly to: string;
+  readonly appliedAt: string;
+  readonly operationCount: number;
+}
+
+const HEADING_APPLIED_AT = 'Applied at';
+const HEADING_SPACE = 'Space';
+const HEADING_MIGRATION = 'Migration';
+const HEADING_CHANGE = 'Change';
+const HEADING_OPS = 'Ops';
+const COLUMN_SEPARATOR = ' ';
+const DIVIDER_CHAR = '─';
+
+export function sortLedgerEntries(entries: readonly LedgerEntryRecord[]): LedgerEntryRecord[] {
+  return [...entries].sort((left, right) => {
+    const timeDiff = left.appliedAt.getTime() - right.appliedAt.getTime();
+    if (timeDiff !== 0) {
+      return timeDiff;
+    }
+    const spaceDiff = left.space.localeCompare(right.space);
+    if (spaceDiff !== 0) {
+      return spaceDiff;
+    }
+    return left.migrationName.localeCompare(right.migrationName);
+  });
+}
+
+function pad2(value: number): string {
+  return String(value).padStart(2, '0');
+}
+
+export function formatLedgerAppliedAt(date: Date, mode: LedgerTimestampMode): string {
+  if (mode === 'iso') {
+    return date.toISOString();
+  }
+  if (mode === 'utc') {
+    return `${date.getUTCFullYear()}-${pad2(date.getUTCMonth() + 1)}-${pad2(date.getUTCDate())} ${pad2(date.getUTCHours())}:${pad2(date.getUTCMinutes())}:${pad2(date.getUTCSeconds())}Z`;
+  }
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? '+' : '-';
+  const absoluteOffset = Math.abs(offsetMinutes);
+  const offsetHours = pad2(Math.floor(absoluteOffset / 60));
+  const offsetMins = pad2(absoluteOffset % 60);
+  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())} ${sign}${offsetHours}:${offsetMins}`;
+}
+
+export function formatHashEndpoint(hash: string | null): string {
+  if (hash === null) {
+    return MIGRATION_LIST_EMPTY_SOURCE;
+  }
+  return abbreviateContractHash(hash);
+}
+
+export function formatHashTransition(from: string | null, to: string): string {
+  return `${formatHashEndpoint(from)} ${MIGRATION_LIST_FORWARD_EDGE_GLYPH} ${abbreviateContractHash(to)}`;
+}
+
+export function styleHashTransition(
+  from: string | null,
+  to: string,
+  styler: MigrationListStyler,
+): string {
+  const fromPart =
+    from === null
+      ? styler.glyph(MIGRATION_LIST_EMPTY_SOURCE)
+      : styler.sourceHash(abbreviateContractHash(from));
+  const arrow = styler.glyph(MIGRATION_LIST_FORWARD_EDGE_GLYPH);
+  const dest = styler.destHash(abbreviateContractHash(to));
+  return `${fromPart} ${arrow} ${dest}`;
+}
+
+function padVisible(text: string, targetWidth: number): string {
+  const padding = Math.max(0, targetWidth - stringWidth(text));
+  return text + ' '.repeat(padding);
+}
+
+function columnWidth(values: readonly string[]): number {
+  return values.reduce((max, value) => Math.max(max, stringWidth(value)), 0);
+}
+
+function padDividerCell(valueWidth: number): string {
+  return DIVIDER_CHAR.repeat(valueWidth + 2);
+}
+
+function padTextCell(value: string, valueWidth: number): string {
+  return ` ${padVisible(value, valueWidth)} `;
+}
+
+function padOpsCell(value: string, valueWidth: number): string {
+  const padding = Math.max(0, valueWidth - stringWidth(value));
+  return ` ${' '.repeat(padding)}${value} `;
+}
+
+export function renderMigrationLogTable(
+  entries: readonly LedgerEntryRecord[],
+  options: RenderMigrationLogTableOptions = {},
+): string {
+  const sorted = sortLedgerEntries(entries);
+  if (sorted.length === 0) {
+    return '';
+  }
+
+  const styler = options.styler ?? IDENTITY_MIGRATION_LIST_STYLER;
+  const showSpace = new Set(sorted.map((entry) => entry.space)).size > 1;
+  const timestampMode: LedgerTimestampMode = options.utc ? 'utc' : 'local';
+  const rows = sorted.map((entry) => ({
+    appliedAt: formatLedgerAppliedAt(entry.appliedAt, timestampMode),
+    space: entry.space,
+    migrationName: entry.migrationName,
+    transition: formatHashTransition(entry.from, entry.to),
+    ops: `${entry.operationCount} ops`,
+    from: entry.from,
+    to: entry.to,
+  }));
+
+  const appliedAtWidth = columnWidth([HEADING_APPLIED_AT, ...rows.map((row) => row.appliedAt)]);
+  const spaceWidth = showSpace ? columnWidth([HEADING_SPACE, ...rows.map((row) => row.space)]) : 0;
+  const nameWidth = columnWidth([HEADING_MIGRATION, ...rows.map((row) => row.migrationName)]);
+  const transitionWidth = columnWidth([HEADING_CHANGE, ...rows.map((row) => row.transition)]);
+  const opsWidth = columnWidth([HEADING_OPS, ...rows.map((row) => row.ops)]);
+
+  const headingParts = [padTextCell(HEADING_APPLIED_AT, appliedAtWidth)];
+  if (showSpace) {
+    headingParts.push(padTextCell(HEADING_SPACE, spaceWidth));
+  }
+  headingParts.push(
+    padTextCell(HEADING_MIGRATION, nameWidth),
+    padTextCell(HEADING_CHANGE, transitionWidth),
+    padOpsCell(HEADING_OPS, opsWidth),
+  );
+  const heading = headingParts.join(COLUMN_SEPARATOR);
+
+  const dividerParts = [padDividerCell(appliedAtWidth)];
+  if (showSpace) {
+    dividerParts.push(padDividerCell(spaceWidth));
+  }
+  dividerParts.push(
+    padDividerCell(nameWidth),
+    padDividerCell(transitionWidth),
+    padDividerCell(opsWidth),
+  );
+  const divider = dividerParts.map((cell) => styler.summary(cell)).join(COLUMN_SEPARATOR);
+
+  const dataRows = rows.map((row) => {
+    const parts = [padTextCell(row.appliedAt, appliedAtWidth)];
+    if (showSpace) {
+      parts.push(padTextCell(row.space, spaceWidth));
+    }
+    parts.push(
+      padTextCell(styler.dirName(row.migrationName), nameWidth),
+      padTextCell(styleHashTransition(row.from, row.to, styler), transitionWidth),
+      padOpsCell(row.ops, opsWidth),
+    );
+    return parts.join(COLUMN_SEPARATOR);
+  });
+
+  return [heading, divider, ...dataRows].join('\n');
+}
+
+export function serializeLedgerEntriesForJson(
+  entries: readonly LedgerEntryRecord[],
+): SerializedLedgerEntryRecord[] {
+  return sortLedgerEntries(entries).map(({ appliedAt, ...rest }) => ({
+    ...rest,
+    appliedAt: formatLedgerAppliedAt(appliedAt, 'iso'),
+  }));
+}
+
+export const MIGRATION_LOG_EMPTY_MESSAGE = 'No migrations have been applied to this database.';

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

@@ -1 +0,0 @@
-{"version":3,"file":"migration-log.mjs","names":[],"sources":["../../src/commands/migration-log.ts"],"sourcesContent":["import type { MigrationPlanOperation } from '@prisma-next/framework-components/control';\nimport { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';\nimport { MigrationToolsError } from '@prisma-next/migration-tools/errors';\nimport { findPath } from '@prisma-next/migration-tools/migration-graph';\nimport { notOk, ok, type Result } from '@prisma-next/utils/result';\nimport { cyan, dim } from 'colorette';\nimport { Command } from 'commander';\nimport { loadConfig } from '../config-loader';\nimport { createControlClient } from '../control-api/client';\nimport {\n  CliStructuredError,\n  errorDatabaseConnectionRequired,\n  errorDriverRequired,\n  errorUnexpected,\n  mapMigrationToolsError,\n} from '../utils/cli-errors';\nimport {\n  addGlobalOptions,\n  maskConnectionUrl,\n  resolveMigrationPaths,\n  setCommandDescriptions,\n  setCommandExamples,\n  setCommandSeeAlso,\n  targetSupportsMigrations,\n} from '../utils/command-helpers';\nimport { buildReadAggregate } from '../utils/contract-space-aggregate-loader';\nimport { formatStyledHeader } from '../utils/formatters/styled';\nimport type { CommonCommandOptions } from '../utils/global-flags';\nimport { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';\nimport { handleResult } from '../utils/result-handler';\nimport { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';\n\ninterface MigrationLogOptions extends CommonCommandOptions {\n  readonly db?: string;\n  readonly config?: string;\n}\n\nexport interface MigrationLogEntry {\n  readonly dirName: string;\n  readonly from: string;\n  readonly to: string;\n  readonly migrationHash: string;\n  readonly operationCount: number;\n  readonly createdAt: string;\n}\n\nexport interface MigrationLogResult {\n  readonly ok: true;\n  readonly markerHash: string | null;\n  readonly applied: readonly MigrationLogEntry[];\n  readonly summary: string;\n}\n\nexport async function executeMigrationLogCommand(\n  options: MigrationLogOptions,\n  flags: GlobalFlags,\n  ui: TerminalUI,\n): Promise<Result<MigrationLogResult, CliStructuredError>> {\n  const config = await loadConfig(options.config);\n  const { configPath, appMigrationsRelative, migrationsDir } = resolveMigrationPaths(\n    options.config,\n    config,\n  );\n\n  const dbConnection = options.db ?? config.db?.connection;\n  if (!dbConnection) {\n    return notOk(\n      errorDatabaseConnectionRequired({\n        why: `Database connection is required for migration log (set db.connection in ${configPath}, or pass --db <url>)`,\n        commandName: 'migration log',\n      }),\n    );\n  }\n  if (!config.driver) {\n    return notOk(errorDriverRequired({ why: 'Config.driver is required for migration log' }));\n  }\n  if (!targetSupportsMigrations(config.target)) {\n    return notOk(errorUnexpected('Target does not support migrations'));\n  }\n\n  if (!flags.json && !flags.quiet) {\n    const header = formatStyledHeader({\n      command: 'migration log',\n      description: 'Show executed migration history',\n      details: [\n        { label: 'config', value: configPath },\n        { label: 'migrations', value: appMigrationsRelative },\n        ...(typeof dbConnection === 'string'\n          ? [{ label: 'database', value: maskConnectionUrl(dbConnection) }]\n          : []),\n      ],\n      flags,\n    });\n    ui.stderr(header);\n  }\n\n  const loaded = await buildReadAggregate(config, { migrationsDir });\n  if (!loaded.ok) {\n    return loaded;\n  }\n  const graph = loaded.value.aggregate.app.graph();\n  const bundles = loaded.value.aggregate.app.packages;\n\n  const client = createControlClient({\n    family: config.family,\n    target: config.target,\n    adapter: config.adapter,\n    driver: config.driver,\n    extensionPacks: config.extensionPacks ?? [],\n  });\n\n  try {\n    await client.connect(dbConnection);\n    const marker = await client.readMarker();\n    const markerHash = marker?.storageHash ?? null;\n\n    if (!markerHash) {\n      return ok({\n        ok: true,\n        markerHash: null,\n        applied: [],\n        summary: 'No migrations applied (database has no marker)',\n      });\n    }\n\n    const appliedPath = findPath(graph, EMPTY_CONTRACT_HASH, markerHash);\n    if (appliedPath === null) {\n      return notOk(\n        errorUnexpected('Database marker is not reachable from migration history', {\n          why: `Marker hash ${markerHash} is not reachable from the root of the on-disk migration graph.`,\n          fix: 'The database may have been migrated outside this project. Use `migration status` to inspect the current state.',\n        }),\n      );\n    }\n    const pkgByDirName = new Map(bundles.map((p) => [p.dirName, p]));\n    const entries: MigrationLogEntry[] = appliedPath.map((edge) => {\n      const pkg = pkgByDirName.get(edge.dirName);\n      const ops = (pkg?.ops ?? []) as readonly MigrationPlanOperation[];\n      return {\n        dirName: edge.dirName,\n        from: edge.from,\n        to: edge.to,\n        migrationHash: edge.migrationHash,\n        operationCount: ops.length,\n        createdAt: edge.createdAt,\n      };\n    });\n\n    return ok({\n      ok: true,\n      markerHash,\n      applied: entries,\n      summary: `${entries.length} migration(s) applied`,\n    });\n  } catch (error) {\n    if (CliStructuredError.is(error)) return notOk(error);\n    if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));\n    return notOk(\n      errorUnexpected(error instanceof Error ? error.message : String(error), {\n        why: `Failed to read migration log: ${error instanceof Error ? error.message : String(error)}`,\n      }),\n    );\n  } finally {\n    await client.close();\n  }\n}\n\nexport function createMigrationLogCommand(): Command {\n  const command = new Command('log');\n  setCommandDescriptions(\n    command,\n    'Show executed migration history',\n    'Reads the database marker and displays the applied migration chain\\n' +\n      'from the initial state to the current marker position.',\n  );\n  setCommandExamples(command, [\n    'prisma-next migration log --db $DATABASE_URL',\n    'prisma-next migration log --json --db $DATABASE_URL',\n  ]);\n  setCommandSeeAlso(command, [\n    { verb: 'migration status', oneLiner: 'Show migration path and pending status' },\n    { verb: 'migration list', oneLiner: 'List on-disk migrations' },\n    { verb: 'migration graph', oneLiner: 'Show the migration graph topology' },\n    { verb: 'migration show', oneLiner: 'Display migration package contents' },\n  ]);\n  addGlobalOptions(command)\n    .option('--db <url>', 'Database connection string')\n    .option('--config <path>', 'Path to prisma-next.config.ts')\n    .action(async (options: MigrationLogOptions) => {\n      const flags = parseGlobalFlagsOrExit(options);\n      const ui = createTerminalUI(flags);\n      const result = await executeMigrationLogCommand(options, flags, ui);\n      const exitCode = handleResult(result, flags, ui, (logResult) => {\n        if (flags.json) {\n          ui.output(JSON.stringify(logResult, null, 2));\n        } else if (!flags.quiet) {\n          const c = (fn: (s: string) => string, s: string) => (flags.color !== false ? fn(s) : s);\n          if (logResult.applied.length === 0) {\n            ui.log(logResult.summary);\n          } else {\n            for (const entry of logResult.applied) {\n              ui.log(\n                `${c(cyan, '✓')} ${entry.dirName}  ${c(dim, entry.migrationHash.slice(0, 16) + '…')}  ${entry.operationCount} op(s)`,\n              );\n            }\n            ui.log(`\\n${logResult.summary}`);\n          }\n        }\n      });\n      process.exit(exitCode);\n    });\n  return command;\n}\n"],"mappings":"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"}