@prisma-next/cli 0.14.0-dev.4 → 0.14.0-dev.41

package/src/utils/combine-verify-results.ts

@@ -0,0 +1,113 @@
+import type { VerifyDatabaseSchemaResult } from '@prisma-next/framework-components/control';
+
+/**
+ * The combined per-space contract-satisfaction result plus the standalone
+ * unclaimed-elements list, reported once. The CLI renders
+ * both; `unclaimed` is never folded into the combined tree or its issues.
+ */
+export interface CombinedVerifyResult {
+  readonly result: VerifyDatabaseSchemaResult;
+  readonly unclaimed: readonly string[];
+}
+
+/**
+ * Collapse the aggregate verifier's per-space contract-satisfaction results
+ * into a single {@link VerifyDatabaseSchemaResult} for the existing CLI
+ * display surface, and carry the deduplicated unclaimed-elements list
+ * alongside it. Concatenates issues across spaces; sums counts; uses the app
+ * space's result as the structural envelope (storage hash, target). Extras are
+ * already stripped from each per-space result, so nothing here duplicates an
+ * unclaimed element per space.
+ *
+ * **Unclaimed disposition.** In strict mode a non-empty `unclaimed` list fails
+ * the combined verdict (`ok: false`); in lenient mode it is carried for
+ * informational rendering only. The list itself is returned unchanged for the
+ * renderer.
+ *
+ * **Summary policy.** Preserve the per-family phrasing whenever the
+ * combined `ok` flag agrees with the app space's `ok` flag — this is
+ * the common case (single-family deployments, single-app deployments)
+ * and the family's "satisfies / does not satisfy contract" phrasing
+ * stays user-visible. When the app passes but an extension fails (or
+ * vice versa) the app's summary contradicts the envelope, so fall back
+ * to the first failing space's summary. This keeps family phrasing
+ * intact and the envelope internally consistent (`ok: false` ↔ failure
+ * summary).
+ */
+export function combineVerifyResults(
+  perSpace: ReadonlyMap<string, VerifyDatabaseSchemaResult>,
+  appSpaceId: string,
+  strict: boolean,
+  unclaimed: readonly string[],
+): CombinedVerifyResult {
+  const appResult = perSpace.get(appSpaceId) ?? perSpace.values().next().value;
+  if (appResult === undefined) {
+    throw new Error(
+      'Aggregate verifier returned no per-space verify results — this is a wiring bug.',
+    );
+  }
+
+  let okAll = true;
+  let firstFailure: VerifyDatabaseSchemaResult | undefined;
+  let issues: VerifyDatabaseSchemaResult['schema']['issues'] = [];
+  let schemaDiffIssues: VerifyDatabaseSchemaResult['schema']['schemaDiffIssues'] = [];
+  const counts = { pass: 0, warn: 0, fail: 0, totalNodes: 0 };
+  const childRoots: Array<VerifyDatabaseSchemaResult['schema']['root']> = [];
+  for (const [, result] of perSpace) {
+    if (!result.ok) {
+      okAll = false;
+      if (firstFailure === undefined) firstFailure = result;
+    }
+    issues = [...issues, ...result.schema.issues];
+    schemaDiffIssues = [...schemaDiffIssues, ...result.schema.schemaDiffIssues];
+    counts.pass += result.schema.counts.pass;
+    counts.warn += result.schema.counts.warn;
+    counts.fail += result.schema.counts.fail;
+    counts.totalNodes += result.schema.counts.totalNodes;
+    childRoots.push(result.schema.root);
+  }
+
+  const unclaimedFails = strict && unclaimed.length > 0;
+  const ok = okAll && !unclaimedFails;
+
+  // Prefer a failing space's family phrasing; else, when only the unclaimed list
+  // fails the verdict, say so; else keep the app space's phrasing. When `okAll`
+  // is false the loop assigned `firstFailure`, so the `?? appResult.summary`
+  // fallback is unreachable — it exists only to keep the read cast-free.
+  const summary = okAll
+    ? unclaimedFails
+      ? `Database schema has ${unclaimed.length} unclaimed element${unclaimed.length === 1 ? '' : 's'} (not in any contract)`
+      : appResult.summary
+    : appResult.ok
+      ? (firstFailure?.summary ?? appResult.summary)
+      : appResult.summary;
+
+  return {
+    result: {
+      ok,
+      ...(ok ? {} : { code: appResult.code ?? 'PN-RUN-3010' }),
+      summary,
+      contract: appResult.contract,
+      target: appResult.target,
+      schema: {
+        issues,
+        schemaDiffIssues,
+        root: {
+          status: ok ? 'pass' : 'fail',
+          kind: 'aggregate',
+          name: 'aggregate',
+          contractPath: '',
+          code: 'AGGREGATE',
+          message: ok ? 'Aggregate schema matches' : 'Aggregate schema mismatch',
+          expected: undefined,
+          actual: undefined,
+          children: childRoots,
+        },
+        counts,
+      },
+      meta: { strict },
+      timings: { total: 0 },
+    },
+    unclaimed,
+  };
+}

package/src/utils/extension-pack-inputs.ts

@@ -111,7 +111,7 @@ export function toExtensionInputs(
  * {@link import('./contract-space-aggregate-loader').buildContractSpaceAggregate}.
  *
  * Codec-only extensions (no `contractSpace` declaration) are filtered
- * out: they are not contract-space members, so the aggregate loader
+ * out: they contribute no contract space, so the aggregate loader
  * has nothing to do with them. Filtering happens at this descriptor-
  * import boundary so the loader stays oblivious to that distinction —
  * every entry it sees expects an on-disk `migrations/<id>/` directory.

package/src/utils/formatters/verify.ts

@@ -30,6 +30,12 @@ export interface DbVerifyCommandSuccessResult {
     readonly counts: VerifyDatabaseSchemaResult['schema']['counts'];
     readonly strict: boolean;
   };
+  /**
+   * Live element names no contract space declares. In full success this is
+   * only ever non-empty in lenient mode — strict mode fails on it — and is
+   * rendered informationally.
+   */
+  readonly unclaimed?: readonly string[];
   readonly warning?: string;
   readonly meta?:
     | (NonNullable<VerifyDatabaseResult['meta']> & {
@@ -76,6 +82,14 @@ export function formatVerifyOutput(
       `${formatDimText(`  schema: pass=${result.schema.counts.pass} warn=${result.schema.counts.warn} fail=${result.schema.counts.fail}`)}`,
     );
   }
+  if (result.unclaimed && result.unclaimed.length > 0) {
+    lines.push('');
+    lines.push(formatYellow('Unclaimed elements (declared by no contract):'));
+    for (const name of result.unclaimed) {
+      lines.push(`  ${formatYellow('⚠')} ${name}`);
+    }
+  }
+
   if (result.warning) {
     lines.push('');
     lines.push(`${formatYellow('⚠')} ${result.warning}`);
@@ -107,6 +121,7 @@ export function formatVerifyJson(result: DbVerifyCommandSuccessResult): string {
     ...ifDefined('missingCodecs', result.missingCodecs),
     ...ifDefined('codecCoverageSkipped', result.codecCoverageSkipped),
     ...ifDefined('schema', result.schema),
+    unclaimed: result.unclaimed ?? [],
     ...ifDefined('warning', result.warning),
     ...ifDefined('meta', result.meta),
     timings: result.timings,
@@ -517,6 +532,7 @@ function renderSchemaVerificationTree(
 export function formatSchemaVerifyOutput(
   result: VerifyDatabaseSchemaResult,
   flags: GlobalFlags,
+  unclaimed: readonly string[] = [],
 ): string {
   if (flags.quiet) {
     return '';
@@ -527,6 +543,7 @@ export function formatSchemaVerifyOutput(
   const useColor = flags.color !== false;
   const formatGreen = createColorFormatter(useColor, green);
   const formatRed = createColorFormatter(useColor, red);
+  const formatYellow = createColorFormatter(useColor, yellow);
   const formatDimText = (text: string) => formatDim(useColor, text);
 
   // Render verification tree first
@@ -539,6 +556,25 @@ export function formatSchemaVerifyOutput(
   });
   lines.push(...treeLines);
 
+  if (result.schema.schemaDiffIssues.length > 0) {
+    lines.push('');
+    lines.push(formatRed('Schema drift:'));
+    for (const issue of result.schema.schemaDiffIssues) {
+      lines.push(`  ${formatRed('✖')} ${issue.message}`);
+    }
+  }
+
+  if (unclaimed.length > 0) {
+    const strict = result.meta?.strict ?? false;
+    lines.push('');
+    lines.push(
+      (strict ? formatRed : formatYellow)('Unclaimed elements (declared by no contract):'),
+    );
+    for (const name of unclaimed) {
+      lines.push(`  ${(strict ? formatRed : formatYellow)(strict ? '✖' : '⚠')} ${name}`);
+    }
+  }
+
   // Add counts and timings in verbose mode
   if (isVerbose(flags, 1)) {
     lines.push(`${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
@@ -562,10 +598,15 @@ export function formatSchemaVerifyOutput(
 }
 
 /**
- * Formats JSON output for database schema verification.
+ * Formats JSON output for database schema verification. The unclaimed-elements
+ * list is a top-level field alongside the combined result, reported once for
+ * the whole database.
  */
-export function formatSchemaVerifyJson(result: VerifyDatabaseSchemaResult): string {
-  return JSON.stringify(result, null, 2);
+export function formatSchemaVerifyJson(
+  result: VerifyDatabaseSchemaResult,
+  unclaimed: readonly string[] = [],
+): string {
+  return JSON.stringify({ ...result, unclaimed }, null, 2);
 }
 
 // ============================================================================

package/src/utils/migration-command-scaffold.ts

@@ -1,9 +1,9 @@
 import { readFile } from 'node:fs/promises';
 import { relative, resolve } from 'node:path';
+import { loadConfig } from '@prisma-next/config-loader';
 import { hasMigrations } from '@prisma-next/framework-components/control';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import type { Command } from 'commander';
-import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
 import type { ControlClient } from '../control-api/types';
 import {

package/src/utils/plan-resolution.ts

@@ -1,5 +1,5 @@
 import type { Contract } from '@prisma-next/contract/types';
-import type { ContractSpaceMember } from '@prisma-next/migration-tools/aggregate';
+import type { AggregateContractSpace } from '@prisma-next/migration-tools/aggregate';
 import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
 import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
 import {
@@ -45,11 +45,11 @@ export type FromResolution =
 
 export interface ResolveFromForPlanInput {
   readonly optionsFrom?: string | undefined;
-  readonly member: ContractSpaceMember;
+  readonly space: AggregateContractSpace;
 }
 
-function graphIsEmpty(member: ContractSpaceMember): boolean {
-  return member.packages.length === 0;
+function graphIsEmpty(space: AggregateContractSpace): boolean {
+  return space.packages.length === 0;
 }
 
 function getReachableRefs(
@@ -98,14 +98,14 @@ type RefContractResolution =
 
 async function resolveContractRef(
   parsed: ContractRef,
-  member: ContractSpaceMember,
+  space: AggregateContractSpace,
   options?: { readonly explicitLabel?: string; readonly artifactRole?: 'from' | 'to' },
 ): Promise<Result<RefContractResolution, CliStructuredError>> {
   const { hash, provenance } = parsed;
   const refName = provenance.kind === 'ref' ? provenance.refName : undefined;
 
   try {
-    const at = await member.contractAt(hash, refName !== undefined ? { refName } : undefined);
+    const at = await space.contractAt(hash, refName !== undefined ? { refName } : undefined);
 
     if (at.provenance === 'snapshot') {
       return ok({
@@ -139,7 +139,7 @@ async function resolveFromPolicy(
   refs: Refs,
   explicitFromLabel?: string,
 ): Promise<Result<FromResolution, CliStructuredError>> {
-  const resolution = await resolveContractRef(parsed, input.member, {
+  const resolution = await resolveContractRef(parsed, input.space, {
     ...(explicitFromLabel !== undefined ? { explicitLabel: explicitFromLabel } : {}),
     artifactRole: 'from',
   });
@@ -157,7 +157,7 @@ async function resolveFromPolicy(
   }
 
   const { hash, contract, contractJson, contractDts } = resolution.value;
-  if (graphIsEmpty(input.member)) {
+  if (graphIsEmpty(input.space)) {
     return ok({
       kind: 'auto-baseline',
       fromHash: hash,
@@ -167,7 +167,7 @@ async function resolveFromPolicy(
     });
   }
 
-  const graph = input.member.graph();
+  const graph = input.space.graph();
   const graphTip = findLatestMigration(graph)?.to ?? null;
   try {
     assertFromIsGraphNode(hash, graph, refs, graphTip);
@@ -189,9 +189,9 @@ async function resolveFromPolicy(
 export async function resolveFromForPlan(
   input: ResolveFromForPlanInput,
 ): Promise<Result<FromResolution, CliStructuredError>> {
-  const { optionsFrom, member } = input;
-  const graph = member.graph();
-  const refs = member.refs;
+  const { optionsFrom, space } = input;
+  const graph = space.graph();
+  const refs = space.refs;
 
   if (optionsFrom === undefined) {
     const dbRef = refs['db'];
@@ -208,7 +208,7 @@ export async function resolveFromForPlan(
   const refResult = parseContractRef(optionsFrom, { graph, refs });
   if (!refResult.ok) {
     if (looksLikeFullHash(optionsFrom)) {
-      const empty = graphIsEmpty(member);
+      const empty = graphIsEmpty(space);
       const graphTip = findLatestMigration(graph)?.to ?? null;
       if (empty) {
         return notOk(errorSnapshotMissing(optionsFrom, { viaRef: false }));
@@ -222,7 +222,7 @@ export async function resolveFromForPlan(
 }
 
 export interface ResolveToForPlanInput {
-  readonly member: ContractSpaceMember;
+  readonly space: AggregateContractSpace;
 }
 
 export interface ResolvedContractRef {
@@ -236,16 +236,16 @@ export async function resolveToForPlan(
   optionsTo: string,
   input: ResolveToForPlanInput,
 ): Promise<Result<ResolvedContractRef, CliStructuredError>> {
-  const { member } = input;
-  const graph = member.graph();
-  const refs = member.refs;
+  const { space } = input;
+  const graph = space.graph();
+  const refs = space.refs;
 
   const refResult = parseContractRef(optionsTo, { graph, refs });
   if (!refResult.ok) {
     return notOk(mapRefResolutionError(refResult.failure));
   }
 
-  const resolution = await resolveContractRef(refResult.value, member, {
+  const resolution = await resolveContractRef(refResult.value, space, {
     explicitLabel: optionsTo,
     artifactRole: 'to',
   });