@prisma-next/cli 0.5.0-dev.7 → 0.5.0-dev.71

package/src/utils/contract-space-migrate-pass.ts

@@ -0,0 +1,156 @@
+import {
+  detectSpaceContractDrift,
+  emitContractSpaceArtefacts,
+  readContractSpaceHeadRef,
+  type SpaceContractDriftResult,
+} from '@prisma-next/migration-tools/spaces';
+
+/**
+ * Minimal descriptor view consumed by the migrate-time per-space pass.
+ *
+ * The CLI receives descriptors typed against the SQL family (or any other
+ * family in the future); this helper only needs the structural shape of
+ * `contractSpace`, so it accepts an `unknown`-typed `contractJson` and
+ * a structurally-typed `headRef`. SQL-family callers pass the same
+ * `Contract<SqlStorage>` value through unchanged — `emitContractSpaceArtefacts`
+ * already serialises through `canonicalizeJson` and is framework-neutral.
+ *
+ * @see specs/framework-mechanism.spec.md § 3 — Per-space helper location.
+ */
+export interface MigrateExtensionInput {
+  readonly id: string;
+  readonly contractSpace?: {
+    readonly contractJson: unknown;
+    readonly headRef: { readonly hash: string; readonly invariants: readonly string[] };
+  };
+}
+
+/**
+ * Inputs needed to compose the migrate-time per-space pass at the CLI
+ * surface — typically called once after the app-space migration package
+ * has been written, regardless of whether the app-space had structural
+ * changes (an extension bump alone should still re-pin its artefacts).
+ */
+export interface ContractSpaceMigratePassInputs {
+  readonly migrationsDir: string;
+  readonly extensionPacks: ReadonlyArray<MigrateExtensionInput>;
+}
+
+export interface ContractSpaceMigratePassResult {
+  readonly drifts: readonly SpaceContractDriftResult[];
+  readonly emittedSpaceIds: readonly string[];
+}
+
+/**
+ * Run drift detection + on-disk artefact emission for every loaded
+ * extension space at `migrate` time.
+ *
+ * Per sub-spec § 3:
+ *
+ * - For each declared extension that exposes a `contractSpace`:
+ *   - Read the on-disk head hash from `migrations/<spaceId>/refs/head.json`
+ *     (returns `null` on first emit).
+ *   - Compare against the descriptor's `headRef.hash` via
+ *     `detectSpaceContractDrift`. The `kind` discriminant decides whether
+ *     the user sees a warning (`drift`), a no-op silent emit (`firstEmit`,
+ *     `noDrift`), or nothing at all.
+ *   - Always re-emit the on-disk artefacts (`contract.json`, `contract.d.ts`,
+ *     `refs/head.json`). The framework owns these files and the helper is
+ *     idempotent.
+ *
+ * Drift warnings are returned to the caller for formatting (TerminalUI,
+ * structured-output envelope, etc.) — the helper does not print directly,
+ * keeping it framework-neutral and unit-testable.
+ *
+ * Extension migration packages (the descriptor's pre-canned `migrations`
+ * array → `migrations/<spaceId>/<dirName>/`) are intentionally not
+ * materialised here — that interaction will be wired in a follow-on round
+ * once the runner-side single-tx slice (sub-spec § 6) is in place.
+ * On-disk artefacts are sufficient to lock the drift-warning behaviour
+ * and the always-on re-emit AC for R2.
+ *
+ * @see specs/framework-mechanism.spec.md § 3 — Drift detection (T1.9).
+ */
+export async function runContractSpaceMigratePass(
+  inputs: ContractSpaceMigratePassInputs,
+): Promise<ContractSpaceMigratePassResult> {
+  const drifts: SpaceContractDriftResult[] = [];
+  const emittedSpaceIds: string[] = [];
+
+  for (const pack of inputs.extensionPacks) {
+    if (pack.contractSpace === undefined) continue;
+    const { contractJson, headRef } = pack.contractSpace;
+
+    const onDiskHeadRef = await readContractSpaceHeadRef(inputs.migrationsDir, pack.id);
+    const drift = detectSpaceContractDrift(pack.id, {
+      descriptorHash: headRef.hash,
+      priorHeadHash: onDiskHeadRef?.hash ?? null,
+    });
+    drifts.push(drift);
+
+    await emitContractSpaceArtefacts(inputs.migrationsDir, pack.id, {
+      contract: contractJson,
+      contractDts: buildPlaceholderContractDts(pack.id),
+      headRef: { hash: headRef.hash, invariants: headRef.invariants },
+    });
+    emittedSpaceIds.push(pack.id);
+  }
+
+  return { drifts, emittedSpaceIds };
+}
+
+/**
+ * Format the user-facing drift warning for a single space. Callers
+ * funnel this through their preferred output channel (TerminalUI line,
+ * structured-output envelope `warnings[]`, etc.).
+ *
+ * Locks AM7 — drift warning surfaces the extension name and the diff
+ * direction (descriptor → on-disk head).
+ */
+export function formatContractSpaceDriftWarning(drift: SpaceContractDriftResult): string {
+  if (drift.kind !== 'drift') {
+    throw new Error(`formatContractSpaceDriftWarning called with non-drift result: ${drift.kind}`);
+  }
+  return (
+    `Contract-space drift detected for "${drift.spaceId}": descriptor hash ` +
+    `${drift.descriptorHash} differs from on-disk head hash ${drift.priorHeadHash ?? '<none>'}. ` +
+    `The on-disk artefacts under migrations/${drift.spaceId}/ will be refreshed to match the descriptor.`
+  );
+}
+
+/**
+ * Placeholder `.d.ts` content for an extension space's on-disk mirror.
+ *
+ * Rendering a fully-typed `.d.ts` for an extension contract requires the
+ * SQL-family renderer with the codec / typemap registry threaded
+ * through; that integration is tracked under sub-spec Open Question 3
+ * (see `projects/extension-contract-spaces/specs/framework-mechanism.spec.md`).
+ *
+ * Until that ships, the on-disk `.d.ts` is a `@ts-nocheck` stub. The
+ * spec gap closing alongside the typed renderer is **AC2 / AC14**
+ * (byte-equivalence of per-space artefacts under `migrate`):
+ * a placeholder cannot be byte-equal to a fully-rendered `.d.ts` from
+ * the same descriptor, so AC2 / AC14 are PARTIAL today and become
+ * fully-PASS once OQ3 closes.
+ *
+ * Scheduled to close in **M3** (cipherstash editor tooling) — that's
+ * the milestone where the typed renderer gets its first real
+ * extension-space consumer and the byte-equivalence guarantee is
+ * practically required.
+ */
+function buildPlaceholderContractDts(spaceId: string): string {
+  return [
+    '// @ts-nocheck',
+    '/**',
+    ` * Placeholder \`.d.ts\` for extension space "${spaceId}".`,
+    ' *',
+    ' * The framework re-emits this file on every `migrate` run alongside',
+    ' * `contract.json` and `refs/head.json`. A typed `.d.ts` rendering',
+    " * pass for extension contracts is tracked under the project's open",
+    ' * questions; until that ships, consumers should import',
+    ' * `contract.json` directly with `validateContract<…>(…)`.',
+    ' */',
+    'export {};',
+    '',
+  ].join('\n');
+}

package/src/utils/emit-queue.ts

@@ -0,0 +1,26 @@
+/**
+ * Per-output FIFO queue for `executeContractEmit`.
+ *
+ * Ensures that at most one emit (load → resolve source → emit bytes → publish)
+ * runs per output JSON path at a time. Concurrent calls for the same path
+ * line up behind the in-flight one and run in submission order; the user-visible
+ * outcome is "last submission wins on disk" without any supersession bookkeeping.
+ *
+ * Long-lived hosts (Vite dev server, watch CLIs) must call `disposeEmitQueue`
+ * when they stop publishing to a path, otherwise the module-global `Map`
+ * accumulates one entry per unique output path for the lifetime of the process.
+ */
+const emitQueues = new Map<string, Promise<unknown>>();
+
+export function queueEmitByOutput<T>(outputJsonPath: string, action: () => Promise<T>): Promise<T> {
+  const previous = emitQueues.get(outputJsonPath) ?? Promise.resolve();
+  // Continue regardless of the previous task's outcome — a failed emit must not
+  // block subsequent ones. The current task's outcome propagates via `next`.
+  const next = previous.then(action, action);
+  emitQueues.set(outputJsonPath, next);
+  return next;
+}
+
+export function disposeEmitQueue(outputJsonPath: string): void {
+  emitQueues.delete(outputJsonPath);
+}

package/src/utils/formatters/graph-migration-mapper.ts

@@ -2,8 +2,8 @@
  * Maps MigrationGraph + status info to the generic graph renderer types.
  */
 import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
-import { findPath } from '@prisma-next/migration-tools/dag';
-import type { MigrationGraph } from '@prisma-next/migration-tools/types';
+import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
+import { findPath } from '@prisma-next/migration-tools/migration-graph';
 import { ifDefined } from '@prisma-next/utils/defined';
 
 import type { StatusRef } from '../migration-types';
@@ -106,7 +106,11 @@ export function migrationGraphToRenderInput(input: MigrationGraphInput): Migrati
     for (const entry of entries) {
       const status = statusByDirName.get(entry.dirName);
       const icon = status ? STATUS_ICON[status] : '';
-      const label = `${entry.dirName}${icon}`;
+      const invariantsSuffix =
+        entry.invariants.length > 0
+          ? `  provides [${entry.invariants.map((id) => JSON.stringify(id)).join(', ')}]`
+          : '';
+      const label = `${entry.dirName}${icon}${invariantsSuffix}`;
 
       edgeList.push({
         from: toShortId(entry.from),

package/src/utils/formatters/migrations.ts

@@ -1,8 +1,41 @@
+import type { OperationPreview } from '@prisma-next/framework-components/control';
 import { green, yellow } from 'colorette';
 
 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 — matches the
+ * legacy `string[]`-based renderer byte-for-byte (per spec OQ-4). 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 (preserves CLI byte-identity for SQL targets per
+ * spec OQ-4); 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 +57,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;
@@ -92,20 +130,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);
+        }
       }
     }
   }
@@ -181,17 +219,16 @@ export function formatMigrationApplyCommandOutput(
 interface MigrationShowResult {
   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;
 }
 
@@ -208,10 +245,9 @@ export function formatMigrationShowOutput(result: MigrationShowResult, flags: Gl
   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(`  from: ${result.from ?? '(baseline)'}`)}`);
   lines.push(`${formatDimText(`  to:   ${result.to}`)}`);
-  lines.push(`${formatDimText(`  migrationId: ${result.migrationId}`)}`);
+  lines.push(`${formatDimText(`  migrationHash: ${result.migrationHash}`)}`);
   lines.push(`${formatDimText(`  created: ${result.createdAt}`)}`);
 
   lines.push('');
@@ -239,15 +275,15 @@ export function formatMigrationShowOutput(result: MigrationShowResult, flags: Gl
     }
   }
 
-  if (result.sql.length > 0) {
+  if (result.preview.statements.length > 0) {
     lines.push('');
-    lines.push(`${formatDimText('DDL preview')}`);
+    lines.push(`${formatDimText(previewBlockHeader(result.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 result.preview.statements) {
+      const rendered = renderPreviewStatement(statement.text, statement.language);
+      if (rendered) {
+        lines.push(rendered);
+      }
     }
   }
 

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 };