@prisma-next/cli 0.5.0-dev.9 → 0.5.1

package/src/utils/formatters/migrations.ts

@@ -1,8 +1,43 @@
-import { green, yellow } from 'colorette';
+import type { OperationPreview } from '@prisma-next/framework-components/control';
+import { cyan, green, yellow } from 'colorette';
 
+import type { AggregatePerSpaceExecutionEntry } from '../../control-api/types';
 import type { GlobalFlags } from '../global-flags';
 import { createColorFormatter, formatDim, isVerbose } from './helpers';
 
+/**
+ * Render a single statement of an `OperationPreview` for the human-readable
+ * preview block. SQL statements get a trailing `;` if missing so the rendered
+ * preview is byte-identical to the legacy `string[]`-based renderer for SQL
+ * targets. Other languages (`'mongodb-shell'`) render verbatim.
+ */
+function renderPreviewStatement(text: string, language: string): string | undefined {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  if (language === 'sql') {
+    return trimmed.endsWith(';') ? trimmed : `${trimmed};`;
+  }
+  return trimmed;
+}
+
+/**
+ * Choose the header label for a preview block. SQL-only previews keep the
+ * legacy `DDL preview` label so the rendered output is byte-identical to the
+ * pre-aggregate SQL CLI; previews from any other family — or a mix that
+ * includes any non-SQL language — use the family-agnostic `Operation preview`
+ * label.
+ *
+ * An empty `statements` array deliberately renders as `Operation preview`
+ * rather than `DDL preview`: `Array.prototype.every` is vacuously true for
+ * empty arrays, but we have no evidence the preview is SQL-only when no
+ * statements are present, so the family-agnostic label is the safer default.
+ */
+export function previewBlockHeader(preview: OperationPreview): string {
+  const allSql =
+    preview.statements.length > 0 && preview.statements.every((s) => s.language === 'sql');
+  return allSql ? 'DDL preview' : 'Operation preview';
+}
+
 // ============================================================================
 // Migration Command Output Formatters (shared by db init and db update)
 // ============================================================================
@@ -24,7 +59,12 @@ export interface MigrationCommandResult {
       readonly label: string;
       readonly operationClass: string;
     }[];
-    readonly sql?: readonly string[];
+    /**
+     * Family-agnostic textual preview of the planned operations. Replaces the
+     * previous `sql?: readonly string[]`. Consumers should read
+     * `plan.preview?.statements`.
+     */
+    readonly preview?: OperationPreview;
   };
   readonly execution?: {
     readonly operationsPlanned: number;
@@ -34,12 +74,67 @@ export interface MigrationCommandResult {
     readonly storageHash: string;
     readonly profileHash?: string;
   };
+  /**
+   * Per-space execution breakdown in canonical schedule order
+   * (extensions alphabetically, then app). Surfaces per-space markers
+   * and the ops grouped by space, so the CLI summary can name which
+   * space each op and marker belongs to instead of flattening them
+   * into a single ambiguous list. See {@link AggregatePerSpaceExecutionEntry}.
+   */
+  readonly perSpace?: ReadonlyArray<AggregatePerSpaceExecutionEntry>;
   readonly summary: string;
   readonly timings: {
     readonly total: number;
   };
 }
 
+/**
+ * Render the shared per-space execution block consumed by the `db init`
+ * / `db update` / `migration apply` summaries. Always shows: space
+ * label (`Extension space: <id>` or `App space`) → per-op lines under
+ * each space → per-space marker hash (when known).
+ *
+ * `mode` controls the marker label phrasing — `'apply'` shows
+ * `marker → <hash>` (post-apply), `'plan'` omits the marker line
+ * entirely (no marker has been written yet).
+ */
+export function formatPerSpaceBlock(
+  perSpace: ReadonlyArray<AggregatePerSpaceExecutionEntry>,
+  mode: 'plan' | 'apply',
+  useColor: boolean,
+): readonly string[] {
+  const formatYellow = createColorFormatter(useColor, yellow);
+  const formatCyan = createColorFormatter(useColor, cyan);
+  const formatDimText = (text: string) => formatDim(useColor, text);
+
+  const lines: string[] = [];
+  for (let s = 0; s < perSpace.length; s++) {
+    const space = perSpace[s]!;
+    if (s > 0) lines.push('');
+    const header =
+      space.kind === 'app'
+        ? formatCyan('App space')
+        : formatCyan(`Extension space: ${space.spaceId}`);
+    lines.push(header);
+    if (space.operations.length === 0) {
+      lines.push(`  ${formatDimText('(no operations)')}`);
+    } else {
+      for (let i = 0; i < space.operations.length; i++) {
+        const op = space.operations[i]!;
+        const isLast = i === space.operations.length - 1;
+        const treeChar = isLast ? '└' : '├';
+        const destructiveMarker =
+          op.operationClass === 'destructive' ? ` ${formatYellow('(destructive)')}` : '';
+        lines.push(`  ${formatDimText(treeChar)}─ ${op.label}${destructiveMarker}`);
+      }
+    }
+    if (mode === 'apply' && space.marker) {
+      lines.push(`  ${formatDimText(`marker: ${space.marker.storageHash}`)}`);
+    }
+  }
+  return lines;
+}
+
 /**
  * Formats human-readable output for migration commands (db init, db update) in plan mode.
  */
@@ -59,22 +154,43 @@ export function formatMigrationPlanOutput(
 
   // Plan summary
   const operationCount = result.plan?.operations.length ?? 0;
-  lines.push(`${formatGreen('✔')} Planned ${operationCount} operation(s)`);
+  const spaceCount = result.perSpace?.length ?? 0;
+  if (spaceCount > 0) {
+    lines.push(
+      `${formatGreen('✔')} Planned ${operationCount} operation(s) across ${spaceCount} contract space${spaceCount === 1 ? '' : 's'}`,
+    );
+  } else {
+    lines.push(`${formatGreen('✔')} Planned ${operationCount} operation(s)`);
+  }
+
+  const formatYellow = createColorFormatter(useColor, yellow);
 
-  // Show operations tree
-  if (result.plan?.operations && result.plan.operations.length > 0) {
-    const formatYellow = createColorFormatter(useColor, yellow);
+  // Per-space breakdown takes precedence over the flat ops tree when
+  // the aggregate flow surfaced one.
+  if (result.perSpace && result.perSpace.length > 0) {
+    lines.push('');
+    lines.push(...formatPerSpaceBlock(result.perSpace, 'plan', useColor));
+    const hasDestructive = result.perSpace.some((s) =>
+      s.operations.some((op) => op.operationClass === 'destructive'),
+    );
+    if (hasDestructive) {
+      lines.push('');
+      lines.push(
+        `${formatYellow('⚠')} This migration contains destructive operations that may cause data loss.`,
+      );
+    }
+  } else if (result.plan?.operations && result.plan.operations.length > 0) {
+    // Single-space fallback (no aggregate breakdown). Same flat tree
+    // we've always rendered.
     lines.push(`${formatDimText('│')}`);
     for (let i = 0; i < result.plan.operations.length; i++) {
       const op = result.plan.operations[i];
       if (!op) continue;
       const isLast = i === result.plan.operations.length - 1;
       const treeChar = isLast ? '└' : '├';
-      const opClassLabel =
-        op.operationClass === 'destructive'
-          ? formatYellow(`[${op.operationClass}]`)
-          : formatDimText(`[${op.operationClass}]`);
-      lines.push(`${formatDimText(treeChar)}─ ${op.label} ${opClassLabel}`);
+      const destructiveMarker =
+        op.operationClass === 'destructive' ? ` ${formatYellow('(destructive)')}` : '';
+      lines.push(`${formatDimText(treeChar)}─ ${op.label}${destructiveMarker}`);
     }
 
     const hasDestructive = result.plan.operations.some((op) => op.operationClass === 'destructive');
@@ -92,20 +208,20 @@ export function formatMigrationPlanOutput(
     lines.push(`${formatDimText(`Destination hash: ${result.plan.destination.storageHash}`)}`);
   }
 
-  // SQL DDL preview (SQL family only)
-  const planSql = result.plan?.sql;
-  if (planSql) {
+  // Statement preview (any family that implements OperationPreviewCapable)
+  const preview = result.plan?.preview;
+  if (preview) {
     lines.push('');
-    lines.push(`${formatDimText('DDL preview')}`);
-    if (planSql.length === 0) {
-      lines.push(`${formatDimText('No DDL operations.')}`);
+    lines.push(`${formatDimText(previewBlockHeader(preview))}`);
+    if (preview.statements.length === 0) {
+      lines.push(`${formatDimText('No operations.')}`);
     } else {
       lines.push('');
-      for (const statement of planSql) {
-        const trimmed = statement.trim();
-        if (!trimmed) continue;
-        const line = trimmed.endsWith(';') ? trimmed : `${trimmed};`;
-        lines.push(`${line}`);
+      for (const statement of preview.statements) {
+        const rendered = renderPreviewStatement(statement.text, statement.language);
+        if (rendered) {
+          lines.push(rendered);
+        }
       }
     }
   }
@@ -127,10 +243,20 @@ export interface MigrationApplyCommandOutputResult {
   readonly migrationsApplied: number;
   readonly markerHash: string;
   readonly applied: readonly {
-    readonly dirName: string;
+    readonly spaceId: string;
+    readonly dirName?: string;
+    readonly migrationHash?: string;
+    readonly from?: string;
+    readonly to?: string;
     readonly operationsExecuted: number;
   }[];
   readonly summary: string;
+  /**
+   * Per-space breakdown in canonical schedule order (extensions
+   * alphabetically, then app). Always present for the aggregate-walking
+   * `migration apply` command.
+   */
+  readonly perSpace: readonly AggregatePerSpaceExecutionEntry[];
   readonly timings?: {
     readonly total: number;
   };
@@ -149,26 +275,17 @@ export function formatMigrationApplyCommandOutput(
   const formatGreen = createColorFormatter(useColor, green);
   const formatDimText = (text: string) => formatDim(useColor, text);
 
-  if (result.migrationsApplied === 0) {
-    lines.push(`${formatGreen('✔')} ${result.summary}`);
-    lines.push(formatDimText(`  marker: ${result.markerHash}`));
-    return lines.join('\n');
-  }
-
   lines.push(`${formatGreen('✔')} ${result.summary}`);
-  lines.push('');
 
-  for (let i = 0; i < result.applied.length; i++) {
-    const migration = result.applied[i]!;
-    const isLast = i === result.applied.length - 1;
-    const treeChar = isLast ? '└' : '├';
-    lines.push(
-      `${formatDimText(treeChar)}─ ${migration.dirName} ${formatDimText(`[${migration.operationsExecuted} op(s)]`)}`,
-    );
+  if (result.perSpace.length > 0) {
+    lines.push('');
+    for (const line of formatPerSpaceBlock(result.perSpace, 'apply', useColor)) {
+      lines.push(line);
+    }
   }
 
   lines.push('');
-  lines.push(formatDimText(`marker: ${result.markerHash}`));
+  lines.push(formatDimText('Next: prisma-next migration status'));
 
   if (isVerbose(flags, 1) && result.timings) {
     lines.push('');
@@ -178,59 +295,66 @@ export function formatMigrationApplyCommandOutput(
   return lines.join('\n');
 }
 
-interface MigrationShowResult {
+interface MigrationShowSpacePresent {
+  readonly kind: 'present';
+  readonly spaceId: string;
   readonly dirName: string;
   readonly dirPath: string;
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
-  readonly migrationId: string;
-  readonly kind: string;
+  readonly migrationHash: string;
   readonly createdAt: string;
   readonly operations: readonly {
     readonly id: string;
     readonly label: string;
     readonly operationClass: string;
   }[];
-  readonly sql: readonly string[];
+  readonly preview: OperationPreview;
   readonly summary: string;
 }
 
-export function formatMigrationShowOutput(result: MigrationShowResult, flags: GlobalFlags): string {
-  if (flags.quiet) {
-    return '';
-  }
+interface MigrationShowSpaceMissing {
+  readonly kind: 'missing';
+  readonly spaceId: string;
+  readonly summary: string;
+}
 
-  const lines: string[] = [];
+type MigrationShowSpaceResult = MigrationShowSpacePresent | MigrationShowSpaceMissing;
 
-  const useColor = flags.color !== false;
+interface MigrationShowResult {
+  readonly spaces: readonly MigrationShowSpaceResult[];
+}
+
+function formatSpaceShowBlock(
+  space: MigrationShowSpacePresent,
+  useColor: boolean,
+): readonly string[] {
   const formatGreen = createColorFormatter(useColor, green);
   const formatYellow = createColorFormatter(useColor, yellow);
   const formatDimText = (text: string) => formatDim(useColor, text);
 
-  lines.push(`${formatGreen('✔')} ${result.dirName}`);
-  lines.push(`${formatDimText(`  kind: ${result.kind}`)}`);
-  lines.push(`${formatDimText(`  from: ${result.from}`)}`);
-  lines.push(`${formatDimText(`  to:   ${result.to}`)}`);
-  lines.push(`${formatDimText(`  migrationId: ${result.migrationId}`)}`);
-  lines.push(`${formatDimText(`  created: ${result.createdAt}`)}`);
+  const lines: string[] = [];
+  lines.push(`${formatGreen('✔')} ${space.dirName}`);
+  lines.push(`${formatDimText(`  from: ${space.from ?? '(baseline)'}`)}`);
+  lines.push(`${formatDimText(`  to:   ${space.to}`)}`);
+  lines.push(`${formatDimText(`  migrationHash: ${space.migrationHash}`)}`);
+  lines.push(`${formatDimText(`  created: ${space.createdAt}`)}`);
 
   lines.push('');
-  lines.push(`${result.operations.length} operation(s)`);
+  lines.push(`${space.operations.length} operation(s)`);
 
-  if (result.operations.length > 0) {
+  if (space.operations.length > 0) {
     lines.push(`${formatDimText('│')}`);
-    for (let i = 0; i < result.operations.length; i++) {
-      const op = result.operations[i]!;
-      const isLast = i === result.operations.length - 1;
+    for (let i = 0; i < space.operations.length; i++) {
+      const op = space.operations[i]!;
+      const isLast = i === space.operations.length - 1;
       const treeChar = isLast ? '└' : '├';
-      const opClassLabel =
-        op.operationClass === 'destructive'
-          ? formatYellow(`[${op.operationClass}]`)
-          : formatDimText(`[${op.operationClass}]`);
-      lines.push(`${formatDimText(treeChar)}─ ${op.label} ${opClassLabel}`);
+      const destructiveMarker =
+        op.operationClass === 'destructive' ? ` ${formatYellow('(destructive)')}` : '';
+      lines.push(`${formatDimText(treeChar)}─ ${op.label}${destructiveMarker}`);
     }
 
-    const hasDestructive = result.operations.some((op) => op.operationClass === 'destructive');
+    const hasDestructive = space.operations.some((op) => op.operationClass === 'destructive');
     if (hasDestructive) {
       lines.push('');
       lines.push(
@@ -239,15 +363,45 @@ export function formatMigrationShowOutput(result: MigrationShowResult, flags: Gl
     }
   }
 
-  if (result.sql.length > 0) {
+  if (space.preview.statements.length > 0) {
     lines.push('');
-    lines.push(`${formatDimText('DDL preview')}`);
+    lines.push(`${formatDimText(previewBlockHeader(space.preview))}`);
     lines.push('');
-    for (const statement of result.sql) {
-      const trimmed = statement.trim();
-      if (!trimmed) continue;
-      const line = trimmed.endsWith(';') ? trimmed : `${trimmed};`;
-      lines.push(`${line}`);
+    for (const statement of space.preview.statements) {
+      const rendered = renderPreviewStatement(statement.text, statement.language);
+      if (rendered) {
+        lines.push(rendered);
+      }
+    }
+  }
+
+  return lines;
+}
+
+export function formatMigrationShowOutput(result: MigrationShowResult, flags: GlobalFlags): string {
+  if (flags.quiet) {
+    return '';
+  }
+
+  const useColor = flags.color !== false;
+  const formatDimText = (text: string) => formatDim(useColor, text);
+  const multipleSpaces = result.spaces.length > 1;
+  const lines: string[] = [];
+
+  for (let i = 0; i < result.spaces.length; i++) {
+    const space = result.spaces[i]!;
+    if (multipleSpaces) {
+      lines.push(formatDimText(`── ${space.spaceId} ──`));
+    }
+    if (space.kind === 'missing') {
+      lines.push(formatDimText(`  ${space.summary}`));
+    } else {
+      for (const line of formatSpaceShowBlock(space, useColor)) {
+        lines.push(line);
+      }
+    }
+    if (i < result.spaces.length - 1) {
+      lines.push('');
     }
   }
 
@@ -274,15 +428,39 @@ export function formatMigrationApplyOutput(
   if (result.ok) {
     // Success summary
     const executed = result.execution?.operationsExecuted ?? 0;
+    const spaceCount = result.perSpace?.length ?? 0;
+
     if (executed === 0) {
-      lines.push(`${formatGreen('✔')} Database already matches contract`);
+      const acrossClause =
+        spaceCount > 0 ? ` across ${spaceCount} contract space${spaceCount === 1 ? '' : 's'}` : '';
+      lines.push(`${formatGreen('✔')} Database already matches contract${acrossClause}`);
+    } else if (spaceCount > 0) {
+      lines.push(
+        `${formatGreen('✔')} Applied ${executed} operation(s) across ${spaceCount} contract space${spaceCount === 1 ? '' : 's'}`,
+      );
     } else {
       lines.push(`${formatGreen('✔')} Applied ${executed} operation(s)`);
     }
 
-    // Marker info
-    if (result.marker) {
-      lines.push(`${formatDimText(`  Signature: ${result.marker.storageHash}`)}`);
+    // Per-space breakdown — replaces the single ambiguous `Signature:`
+    // line with a per-space marker + ops listing.
+    if (result.perSpace && result.perSpace.length > 0) {
+      lines.push('');
+      lines.push(...formatPerSpaceBlock(result.perSpace, 'apply', useColor));
+      lines.push('');
+      lines.push(
+        formatDimText(
+          `Run 'prisma-next migration status' to confirm ${
+            spaceCount === 1 ? 'the space is' : 'all spaces are'
+          } up to date.`,
+        ),
+      );
+    } else if (result.marker) {
+      // Single-space fallback (no aggregate breakdown surfaced — e.g.
+      // older callers / non-aggregate code paths). The label is
+      // `App-space marker` (not `Signature`) so that when only one
+      // marker is observable we still name what it covers explicitly.
+      lines.push(`${formatDimText(`  App-space marker: ${result.marker.storageHash}`)}`);
       if (result.marker.profileHash) {
         lines.push(`${formatDimText(`  Profile hash: ${result.marker.profileHash}`)}`);
       }

package/src/utils/publish-contract-artifact-pair.ts

@@ -0,0 +1,134 @@
+import { readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'pathe';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function createTempArtifactPath(path: string, publicationToken: string, phase: string): string {
+  return join(dirname(path), `.${basename(path)}.${process.pid}.${publicationToken}.${phase}.tmp`);
+}
+
+type PreviousArtifact = { readonly content: string } | 'remove';
+
+async function readExistingArtifact(path: string): Promise<PreviousArtifact> {
+  try {
+    return { content: await readFile(path, 'utf-8') };
+  } catch (error) {
+    if (isRecord(error) && error['code'] === 'ENOENT') {
+      return 'remove';
+    }
+    throw error;
+  }
+}
+
+async function restoreArtifact(
+  path: string,
+  previous: PreviousArtifact,
+  publicationToken: string,
+): Promise<void> {
+  if (previous === 'remove') {
+    await rm(path, { force: true });
+    return;
+  }
+
+  const restorePath = createTempArtifactPath(path, publicationToken, 'rollback');
+  await writeFile(restorePath, previous.content, 'utf-8');
+  try {
+    await rename(restorePath, path);
+  } finally {
+    await rm(restorePath, { force: true });
+  }
+}
+
+interface PublishEntry {
+  readonly tempPath: string;
+  readonly outputPath: string;
+  readonly previous: PreviousArtifact;
+}
+
+function withRollbackFailureCause(error: unknown, rollbackFailures: readonly unknown[]): Error {
+  const rollbackCause = new AggregateError(
+    rollbackFailures,
+    'Failed to restore published artifacts',
+  );
+
+  if (error instanceof Error) {
+    Object.defineProperty(error, 'cause', {
+      value: rollbackCause,
+      configurable: true,
+      writable: true,
+    });
+    return error;
+  }
+
+  return new Error(String(error), { cause: rollbackCause });
+}
+
+async function publishPairWithRollback(
+  entries: readonly PublishEntry[],
+  publicationToken: string,
+): Promise<void> {
+  const replaced: PublishEntry[] = [];
+  try {
+    for (const entry of entries) {
+      await rename(entry.tempPath, entry.outputPath);
+      replaced.push(entry);
+    }
+  } catch (error) {
+    const rollbackResults = await Promise.allSettled(
+      replaced.map((entry) => restoreArtifact(entry.outputPath, entry.previous, publicationToken)),
+    );
+    const rollbackFailures = rollbackResults.flatMap((result) =>
+      result.status === 'rejected' ? [result.reason] : [],
+    );
+
+    if (rollbackFailures.length > 0) {
+      throw withRollbackFailureCause(error, rollbackFailures);
+    }
+
+    throw error;
+  }
+}
+
+export async function publishContractArtifactPair({
+  outputJsonPath,
+  outputDtsPath,
+  contractJson,
+  contractDts,
+  publicationToken,
+  beforePublish,
+}: {
+  readonly outputJsonPath: string;
+  readonly outputDtsPath: string;
+  readonly contractJson: string;
+  readonly contractDts: string;
+  readonly publicationToken: string;
+  readonly beforePublish?: () => Promise<boolean> | boolean;
+}): Promise<boolean> {
+  const tempJsonPath = createTempArtifactPath(outputJsonPath, publicationToken, 'next');
+  const tempDtsPath = createTempArtifactPath(outputDtsPath, publicationToken, 'next');
+
+  try {
+    await writeFile(tempJsonPath, contractJson, 'utf-8');
+    await writeFile(tempDtsPath, contractDts, 'utf-8');
+
+    if ((await beforePublish?.()) === false) {
+      return false;
+    }
+
+    const previousJson = await readExistingArtifact(outputJsonPath);
+    const previousDts = await readExistingArtifact(outputDtsPath);
+
+    await publishPairWithRollback(
+      [
+        { tempPath: tempDtsPath, outputPath: outputDtsPath, previous: previousDts },
+        { tempPath: tempJsonPath, outputPath: outputJsonPath, previous: previousJson },
+      ],
+      publicationToken,
+    );
+    return true;
+  } finally {
+    await Promise.allSettled([rm(tempJsonPath, { force: true }), rm(tempDtsPath, { force: true })]);
+  }
+}

package/dist/cli-errors-BFYgBH3L.d.mts

@@ -1,4 +0,0 @@
-import { CliStructuredError as CliStructuredError$1 } from "@prisma-next/errors/control";
-import "@prisma-next/errors/execution";
-import "@prisma-next/errors/migration";
-export { CliStructuredError$1 as t };

package/dist/cli-errors-Cd79vmTH.mjs

@@ -1,5 +0,0 @@
-import { CliStructuredError as CliStructuredError$1, errorConfigValidation as errorConfigValidation$1, errorContractConfigMissing as errorContractConfigMissing$1, errorContractValidationFailed, errorDatabaseConnectionRequired, errorDriverRequired, errorFileNotFound, errorMigrationPlanningFailed, errorTargetMigrationNotSupported, errorUnexpected as errorUnexpected$1 } from "@prisma-next/errors/control";
-import { ERROR_CODE_DESTRUCTIVE_CHANGES, errorDestructiveChanges, errorHashMismatch, errorMarkerMissing, errorRunnerFailed, errorRuntime as errorRuntime$1, errorTargetMismatch } from "@prisma-next/errors/execution";
-import "@prisma-next/errors/migration";
-
-export { errorUnexpected$1 as _, errorContractValidationFailed as a, errorDriverRequired as c, errorMarkerMissing as d, errorMigrationPlanningFailed as f, errorTargetMismatch as g, errorTargetMigrationNotSupported as h, errorContractConfigMissing$1 as i, errorFileNotFound as l, errorRuntime$1 as m, ERROR_CODE_DESTRUCTIVE_CHANGES as n, errorDatabaseConnectionRequired as o, errorRunnerFailed as p, errorConfigValidation$1 as r, errorDestructiveChanges as s, CliStructuredError$1 as t, errorHashMismatch as u };