@prisma-next/cli 0.12.0-dev.51 → 0.12.0-dev.53

package/src/control-api/operations/db-run.ts

@@ -17,9 +17,11 @@ import type {
 import { hasOperationPreview } from '@prisma-next/framework-components/control';
 import {
   type ContractSpaceAggregate,
+  collectAggregateNamespaces,
   type PlannerError,
   planMigration,
 } from '@prisma-next/migration-tools/aggregate';
+import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok } from '@prisma-next/utils/result';
 import { CliStructuredError } from '../../utils/cli-errors';
@@ -157,7 +159,10 @@ export async function executeRun<TFamilyId extends string, TTargetId extends str
     spanId: SPAN_IDS.introspect,
     label: 'Introspecting database schema',
   });
-  const schemaIR = await familyInstance.introspect({ driver });
+  const schemaIR = await familyInstance.introspect({
+    driver,
+    contract: collectAggregateNamespaces(aggregate),
+  });
   onProgress?.({ action, kind: 'spanEnd', spanId: SPAN_IDS.introspect, outcome: 'ok' });
 
   // 3. Plan via aggregate planner. App is forced through synth (today's
@@ -328,7 +333,10 @@ function mapPlannerError(error: PlannerError): DbInitResult | DbUpdateResult {
       why: undefined,
       meta: undefined,
     };
-    return notOk(failure) as DbInitResult | DbUpdateResult;
+    return blindCast<
+      DbInitResult | DbUpdateResult,
+      'notOk(failure) is shape-compatible with both DbInitResult and DbUpdateResult; the union is the return type of the surrounding function'
+    >(notOk(failure));
   }
   if (error.kind === 'extensionPathUnreachable') {
     return buildRunnerFailure({
@@ -423,5 +431,8 @@ function buildRunnerFailure(args: {
     conflicts: undefined,
     ...ifDefined('warnings', args.warnings),
   };
-  return notOk(failure) as DbInitResult | DbUpdateResult;
+  return blindCast<
+    DbInitResult | DbUpdateResult,
+    'notOk(failure) is shape-compatible with both DbInitResult and DbUpdateResult; the union is the return type of the surrounding function'
+  >(notOk(failure));
 }

package/src/control-api/operations/db-verify.ts

@@ -8,11 +8,12 @@ import type {
 } from '@prisma-next/framework-components/control';
 import {
   type ContractSpaceMember,
+  collectAggregateNamespaces,
   requireHeadRef,
   type VerifierOutput,
   verifyMigration,
 } from '@prisma-next/migration-tools/aggregate';
-import { castAs } from '@prisma-next/utils/casts';
+import { blindCast, castAs } from '@prisma-next/utils/casts';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { CliStructuredError } from '../../utils/cli-errors';
 import {
@@ -101,7 +102,12 @@ export async function executeDbVerify<TFamilyId extends string, TTargetId extend
   const markersBySpaceId = await familyInstance.readAllMarkers({ driver });
   const schemaIntrospection = skipSchema
     ? null
-    : await runIntrospection({ driver, familyInstance, onProgress });
+    : await runIntrospection({
+        driver,
+        familyInstance,
+        onProgress,
+        contract: collectAggregateNamespaces(aggregate),
+      });
 
   emitVerifySpan(onProgress, 'spanStart');
   const verifyResult = verifyMigration({
@@ -130,8 +136,9 @@ async function runIntrospection<TFamilyId extends string, TTargetId extends stri
   driver: ControlDriverInstance<TFamilyId, TTargetId>;
   familyInstance: ControlFamilyInstance<TFamilyId, unknown>;
   onProgress: OnControlProgress | undefined;
+  contract: unknown;
 }): Promise<unknown> {
-  const { driver, familyInstance, onProgress } = args;
+  const { driver, familyInstance, onProgress, contract } = args;
   onProgress?.({
     action: 'dbVerify',
     kind: 'spanStart',
@@ -139,7 +146,7 @@ async function runIntrospection<TFamilyId extends string, TTargetId extends stri
     label: 'Introspecting database schema',
   });
   try {
-    const result = await familyInstance.introspect({ driver });
+    const result = await familyInstance.introspect({ driver, contract });
     onProgress?.({
       action: 'dbVerify',
       kind: 'spanEnd',
@@ -179,7 +186,10 @@ export function createPerMemberVerifier<TFamilyId extends string, TTargetId exte
       // The family's `TSchemaIR` is opaque to migration-tools; the
       // aggregate verifier passes through whatever we hand it. The
       // family expects its own IR shape on the way back.
-      schema: projectedSchema as never,
+      schema: blindCast<
+        never,
+        'family TSchemaIR is opaque to migration-tools; projectedSchema is passed straight through'
+      >(projectedSchema),
       strict: verifyMode === 'strict',
       frameworkComponents,
     });

package/src/control-api/operations/migrate.ts

@@ -156,58 +156,36 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
     // The aggregate passed the integrity gate, so every member's head ref
     // is resolved (the app's is synthesised from the live contract).
     const headRef = requireHeadRef(member);
-    const targetHash = isAppMember && refHash !== undefined ? refHash : headRef.hash;
+    const memberTargetHash = isAppMember && refHash !== undefined ? refHash : headRef.hash;
+    const memberRefInvariants = isAppMember && refHash !== undefined ? refInvariants : undefined;
     const liveMarker = markerRows.get(member.spaceId) ?? null;
 
-    // Empty-graph members fail loudly: replay needs an on-disk path
-    // and an empty graph means the user has never planned this space.
-    if (member.graph().nodes.size === 0) {
-      // Edge case: target == EMPTY (greenfield, nothing to do) or
-      // the live marker already matches the target. Loader integrity
-      // allows this for extensions whose head ref is the empty
-      // sentinel. Record a zero-op resolution so the aggregate result
-      // still surfaces the member in `perSpace[]` as already-at-head;
-      // the runner is not invoked for these members because they have
-      // no authored ops and (for greenfield extensions) no marker to
-      // advance.
-      const liveHash = liveMarker?.storageHash;
-      if (
-        targetHash === liveHash ||
-        (liveHash === undefined && targetHash === EMPTY_CONTRACT_HASH)
-      ) {
-        atHeadResolutions.set(
-          member.spaceId,
-          buildAtHeadResolution({
-            aggregateTargetId: aggregate.targetId,
-            member,
-            targetHash,
-            liveMarker,
-          }),
-        );
-        continue;
-      }
-      return notOk(buildNeverPlannedFailure(member.spaceId, targetHash));
-    }
-
-    const targetInvariants =
-      isAppMember && refHash !== undefined && refInvariants !== undefined
-        ? refInvariants
-        : headRef.invariants;
-    const targetMember: ContractSpaceMember =
-      targetHash === headRef.hash && targetInvariants === headRef.invariants
-        ? member
-        : { ...member, headRef: { hash: targetHash, invariants: targetInvariants } };
-
-    const walked = graphWalkStrategy({
-      aggregateTargetId: aggregate.targetId,
-      member: targetMember,
-      currentMarker: liveMarker,
-      ...(isAppMember && refName !== undefined ? { refName } : {}),
+    const outcome = planMemberPath({
+      member,
+      aggregate,
+      targetHash: memberTargetHash,
+      refInvariants: memberRefInvariants,
+      liveMarker,
+      ...(isAppMember ? { refName } : {}),
     });
-    if (walked.kind === 'unreachable') {
-      return notOk(buildPathNotFoundFailure(member.spaceId, liveMarker, targetHash));
+
+    if (outcome.kind === 'at-head') {
+      // Empty-graph member whose live marker already matches the target.
+      // Kept out of the runner schedule so we don't write spurious markers
+      // for greenfield extensions, but merged back into the success envelope
+      // so every loaded member is represented.
+      atHeadResolutions.set(member.spaceId, outcome.plan);
+      continue;
+    }
+    if (outcome.kind === 'never-planned') {
+      return notOk(buildNeverPlannedFailure(outcome.spaceId, outcome.targetHash));
+    }
+    if (outcome.kind === 'unreachable') {
+      return notOk(
+        buildPathNotFoundFailure(outcome.spaceId, outcome.liveMarker, outcome.targetHash),
+      );
     }
-    if (walked.kind === 'unsatisfiable') {
+    if (outcome.kind === 'unsatisfiable') {
       // Surface the canonical MIGRATION.NO_INVARIANT_PATH envelope
       // (the error rendering pipeline maps it to meta.code +
       // meta.required + meta.missing + meta.structuralPath that the
@@ -218,10 +196,12 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
       // string here would leave the structural lookup with a hash that
       // is never a graph node, producing an empty `structuralPath` and
       // a less actionable diagnostic.
-      const fromHash = liveMarker?.storageHash ?? EMPTY_CONTRACT_HASH;
-      const structural = findPathWithDecision(targetMember.graph(), fromHash, targetHash, {
-        required: new Set<string>(),
-      });
+      const structural = findPathWithDecision(
+        outcome.targetMember.graph(),
+        outcome.liveHash,
+        memberTargetHash,
+        { required: new Set<string>() },
+      );
       const structuralPath =
         structural.kind === 'ok'
           ? structural.decision.selectedPath.map((edge) => ({
@@ -233,14 +213,14 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
             }))
           : [];
       throw errorNoInvariantPath({
-        ...(isAppMember && refName !== undefined ? { refName } : {}),
-        required: targetInvariants,
-        missing: walked.missing,
+        ...(outcome.refName !== undefined ? { refName: outcome.refName } : {}),
+        required: outcome.targetInvariants,
+        missing: outcome.missing,
         structuralPath,
       });
     }
 
-    perSpacePlans.set(member.spaceId, walked.result);
+    perSpacePlans.set(member.spaceId, outcome.plan);
   }
 
   const canonicalOrder = [...aggregate.extensions.map((m) => m.spaceId), aggregate.app.spaceId];
@@ -340,6 +320,119 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
   );
 }
 
+/**
+ * Outcome variants for one member's path computation.
+ *
+ * Callers switch on `kind` and map to their own error representation:
+ * `executeMigrate` throws / returns `notOk`; `executeMigrateShowCommand`
+ * returns a CLI structured error. The shared discriminant guarantees both
+ * paths feed `graphWalkStrategy` the same inputs.
+ *
+ * @internal Exported for `executeMigrateShowCommand` to call.
+ */
+export type MemberPathOutcome =
+  | { readonly kind: 'ok'; readonly plan: PerSpacePlan }
+  | { readonly kind: 'at-head'; readonly plan: PerSpacePlan }
+  | { readonly kind: 'never-planned'; readonly spaceId: string; readonly targetHash: string }
+  | {
+      readonly kind: 'unreachable';
+      readonly spaceId: string;
+      readonly liveMarker: ContractMarkerRecordLike | null;
+      readonly targetHash: string;
+    }
+  | {
+      readonly kind: 'unsatisfiable';
+      readonly spaceId: string;
+      readonly isAppMember: boolean;
+      readonly missing: readonly string[];
+      readonly targetInvariants: readonly string[];
+      readonly targetMember: ContractSpaceMember;
+      readonly liveHash: string;
+      readonly refName: string | undefined;
+    };
+
+/**
+ * Compute the graph-walk path for one contract-space member.
+ *
+ * Encapsulates the invariant-correct input assembly that both
+ * `executeMigrate` and `executeMigrateShowCommand` must use:
+ * - `currentMarker` carries the full live marker including `invariants`
+ *   (not a stripped `{ storageHash, invariants: [] }` shell).
+ * - `targetInvariants` uses the caller-supplied `refInvariants` when a
+ *   `--to` ref was resolved (not always the file head ref's invariants).
+ *
+ * Both callers map the returned `MemberPathOutcome` to their own error
+ * representation; the path-compute logic is shared and identical.
+ *
+ * @internal Exported for `executeMigrateShowCommand`.
+ */
+export function planMemberPath({
+  member,
+  aggregate,
+  targetHash,
+  refInvariants,
+  liveMarker,
+  refName,
+}: {
+  readonly member: ContractSpaceMember;
+  readonly aggregate: Pick<ContractSpaceAggregate, 'targetId' | 'app'>;
+  readonly targetHash: string;
+  readonly refInvariants: readonly string[] | undefined;
+  readonly liveMarker: ContractMarkerRecordLike | null;
+  readonly refName?: string;
+}): MemberPathOutcome {
+  const isAppMember = member.spaceId === aggregate.app.spaceId;
+  const headRef = requireHeadRef(member);
+
+  if (member.graph().nodes.size === 0) {
+    const liveHash = liveMarker?.storageHash;
+    if (targetHash === liveHash || (liveHash === undefined && targetHash === EMPTY_CONTRACT_HASH)) {
+      return {
+        kind: 'at-head',
+        plan: buildAtHeadResolution({
+          aggregateTargetId: aggregate.targetId,
+          member,
+          targetHash,
+          liveMarker,
+        }),
+      };
+    }
+    return { kind: 'never-planned', spaceId: member.spaceId, targetHash };
+  }
+
+  const targetInvariants =
+    isAppMember && refInvariants !== undefined ? refInvariants : headRef.invariants;
+  const targetMember: ContractSpaceMember =
+    targetHash === headRef.hash && targetInvariants === headRef.invariants
+      ? member
+      : { ...member, headRef: { hash: targetHash, invariants: targetInvariants } };
+
+  const walked = graphWalkStrategy({
+    aggregateTargetId: aggregate.targetId,
+    member: targetMember,
+    currentMarker: liveMarker,
+    ...(isAppMember && refName !== undefined ? { refName } : {}),
+  });
+
+  if (walked.kind === 'unreachable') {
+    return { kind: 'unreachable', spaceId: member.spaceId, liveMarker, targetHash };
+  }
+  if (walked.kind === 'unsatisfiable') {
+    const liveHash = liveMarker?.storageHash ?? EMPTY_CONTRACT_HASH;
+    return {
+      kind: 'unsatisfiable',
+      spaceId: member.spaceId,
+      isAppMember,
+      missing: walked.missing,
+      targetInvariants,
+      targetMember,
+      liveHash,
+      refName,
+    };
+  }
+  return { kind: 'ok', plan: walked.result };
+}
+
 /**
  * Build a zero-op {@link PerSpacePlan} for an empty-graph
  * member whose live marker already matches the target. Lets the apply