@prisma-next/target-mongo 0.4.1 → 0.4.3

package/src/core/mongo-runner.ts

@@ -8,7 +8,9 @@ import type {
   MigrationRunnerExecutionChecks,
   MigrationRunnerFailure,
   MigrationRunnerResult,
+  OperationContext,
 } from '@prisma-next/framework-components/control';
+import type { MongoContract } from '@prisma-next/mongo-contract';
 import type { MongoAdapter, MongoDriver } from '@prisma-next/mongo-lowering';
 import type {
   AnyMongoMigrationOperation,
@@ -19,31 +21,28 @@ import type {
   MongoMigrationCheck,
   MongoMigrationPlanOperation,
 } from '@prisma-next/mongo-query-ast/control';
+import type { MongoSchemaIR } from '@prisma-next/mongo-schema-ir';
 import { notOk, ok } from '@prisma-next/utils/result';
-
-const READ_ONLY_CHECK_COMMAND_KINDS: ReadonlySet<string> = new Set(['aggregate', 'rawAggregate']);
-
-function hasProfileHash(value: unknown): value is { readonly profileHash: string } {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    Object.hasOwn(value, 'profileHash') &&
-    typeof (value as { profileHash: unknown }).profileHash === 'string'
-  );
-}
-
 import { FilterEvaluator } from './filter-evaluator';
 import { deserializeMongoOps } from './mongo-ops-serializer';
+import { verifyMongoSchema } from './schema-verify/verify-mongo-schema';
+
+const READ_ONLY_CHECK_COMMAND_KINDS: ReadonlySet<string> = new Set(['aggregate', 'rawAggregate']);
 
 export interface MarkerOperations {
   readMarker(): Promise<ContractMarkerRecord | null>;
   initMarker(destination: {
     readonly storageHash: string;
     readonly profileHash: string;
+    readonly invariants?: readonly string[];
   }): Promise<void>;
   updateMarker(
     expectedFrom: string,
-    destination: { readonly storageHash: string; readonly profileHash: string },
+    destination: {
+      readonly storageHash: string;
+      readonly profileHash: string;
+      readonly invariants?: readonly string[];
+    },
   ): Promise<boolean>;
   writeLedgerEntry(entry: {
     readonly edgeId: string;
@@ -58,6 +57,21 @@ export interface MongoRunnerDependencies {
   readonly adapter: MongoAdapter;
   readonly driver: MongoDriver;
   readonly markerOps: MarkerOperations;
+  readonly introspectSchema: () => Promise<MongoSchemaIR>;
+}
+
+export interface MongoMigrationRunnerExecuteOptions {
+  readonly plan: MigrationPlan;
+  readonly destinationContract: MongoContract;
+  readonly policy: MigrationOperationPolicy;
+  readonly callbacks?: {
+    onOperationStart?(op: MigrationPlanOperation): void;
+    onOperationComplete?(op: MigrationPlanOperation): void;
+  };
+  readonly executionChecks?: MigrationRunnerExecutionChecks;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', 'mongo'>>;
+  readonly strictVerification?: boolean;
+  readonly context?: OperationContext;
 }
 
 function runnerFailure(
@@ -75,17 +89,7 @@ function runnerFailure(
 export class MongoMigrationRunner {
   constructor(private readonly deps: MongoRunnerDependencies) {}
 
-  async execute(options: {
-    readonly plan: MigrationPlan;
-    readonly destinationContract: unknown;
-    readonly policy: MigrationOperationPolicy;
-    readonly callbacks?: {
-      onOperationStart?(op: MigrationPlanOperation): void;
-      onOperationComplete?(op: MigrationPlanOperation): void;
-    };
-    readonly executionChecks?: MigrationRunnerExecutionChecks;
-    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', 'mongo'>>;
-  }): Promise<MigrationRunnerResult> {
+  async execute(options: MongoMigrationRunnerExecuteOptions): Promise<MigrationRunnerResult> {
     const { commandExecutor, inspectionExecutor, adapter, driver, markerOps } = this.deps;
     const operations = deserializeMongoOps(options.plan.operations as readonly unknown[]);
 
@@ -176,49 +180,84 @@ export class MongoMigrationRunner {
     }
 
     const destination = options.plan.destination;
-    const profileHash = hasProfileHash(options.destinationContract)
-      ? options.destinationContract.profileHash
-      : destination.storageHash;
-
-    if (
-      operationsExecuted === 0 &&
-      existingMarker?.storageHash === destination.storageHash &&
-      existingMarker.profileHash === profileHash
-    ) {
-      return ok({ operationsPlanned: operations.length, operationsExecuted });
-    }
-
-    if (existingMarker) {
-      const updated = await markerOps.updateMarker(existingMarker.storageHash, {
-        storageHash: destination.storageHash,
-        profileHash,
+    const profileHash = options.destinationContract.profileHash ?? destination.storageHash;
+
+    const incomingInvariants = options.plan.providedInvariants ?? [];
+    const existingInvariantSet = new Set(existingMarker?.invariants ?? []);
+    const incomingIsSubsetOfExisting = incomingInvariants.every((id) =>
+      existingInvariantSet.has(id),
+    );
+    const markerAlreadyAtDestination =
+      existingMarker !== null &&
+      existingMarker.storageHash === destination.storageHash &&
+      existingMarker.profileHash === profileHash;
+
+    // Skip marker/ledger writes (and schema verification) only when the apply
+    // is a true no-op: no operations executed, marker already at destination,
+    // and every incoming invariant is already in the stored set.
+    //
+    // Divergence from the SQL runners (postgres/sqlite): those runners gate
+    // the no-op skip on `isSelfEdge` (origin === destination) only, so a
+    // non-self-edge `db update` that introspects-as-no-op still writes a
+    // ledger entry. Mongo skips even those because the runner has no
+    // structural distinction between self-edge and re-apply — invariant-
+    // aware routing here does not yet differentiate between the two
+    // ledger semantics. If the SQL audit-trail behavior should hold for
+    // Mongo too, gate this `isNoOp` on a self-edge check (or, conversely,
+    // align the SQL runners to skip non-self-edge no-ops uniformly).
+    const isNoOp =
+      operationsExecuted === 0 && markerAlreadyAtDestination && incomingIsSubsetOfExisting;
+
+    if (!isNoOp) {
+      const liveSchema = await this.deps.introspectSchema();
+      const verifyResult = verifyMongoSchema({
+        contract: options.destinationContract,
+        schema: liveSchema,
+        strict: options.strictVerification ?? true,
+        frameworkComponents: options.frameworkComponents,
+        ...(options.context ? { context: options.context } : {}),
       });
-      if (!updated) {
-        return runnerFailure(
-          'MARKER_CAS_FAILURE',
-          'Marker was modified by another process during migration execution.',
-          {
-            meta: {
-              expectedStorageHash: existingMarker.storageHash,
-              destinationStorageHash: destination.storageHash,
+      if (!verifyResult.ok) {
+        return runnerFailure('SCHEMA_VERIFY_FAILED', verifyResult.summary, {
+          why: 'The resulting database schema does not satisfy the destination contract.',
+          meta: { issues: verifyResult.schema.issues },
+        });
+      }
+
+      if (existingMarker) {
+        const updated = await markerOps.updateMarker(existingMarker.storageHash, {
+          storageHash: destination.storageHash,
+          profileHash,
+          invariants: incomingInvariants,
+        });
+        if (!updated) {
+          return runnerFailure(
+            'MARKER_CAS_FAILURE',
+            'Marker was modified by another process during migration execution.',
+            {
+              meta: {
+                expectedStorageHash: existingMarker.storageHash,
+                destinationStorageHash: destination.storageHash,
+              },
             },
-          },
-        );
+          );
+        }
+      } else {
+        await markerOps.initMarker({
+          storageHash: destination.storageHash,
+          profileHash,
+          invariants: incomingInvariants,
+        });
       }
-    } else {
-      await markerOps.initMarker({
-        storageHash: destination.storageHash,
-        profileHash,
+
+      const originHash = existingMarker?.storageHash ?? '';
+      await markerOps.writeLedgerEntry({
+        edgeId: `${originHash}->${destination.storageHash}`,
+        from: originHash,
+        to: destination.storageHash,
       });
     }
 
-    const originHash = existingMarker?.storageHash ?? '';
-    await markerOps.writeLedgerEntry({
-      edgeId: `${originHash}->${destination.storageHash}`,
-      from: originHash,
-      to: destination.storageHash,
-    });
-
     return ok({ operationsPlanned: operations.length, operationsExecuted });
   }
 
@@ -259,7 +298,7 @@ export class MongoMigrationRunner {
     }
 
     for (const plan of op.run) {
-      const wireCommand = adapter.lower(plan);
+      const wireCommand = await adapter.lower(plan, {});
       for await (const _ of driver.execute(wireCommand)) {
         /* consume */
       }
@@ -307,7 +346,7 @@ export class MongoMigrationRunner {
           },
         );
       }
-      const wireCommand = adapter.lower(check.source);
+      const wireCommand = await adapter.lower(check.source, {});
       let matchFound = false;
       for await (const row of driver.execute<Record<string, unknown>>(wireCommand)) {
         if (filterEvaluator.evaluate(check.filter, row)) {
@@ -375,13 +414,9 @@ export class MongoMigrationRunner {
   ): MigrationRunnerResult | undefined {
     const origin = plan.origin ?? null;
     if (!origin) {
-      if (marker) {
-        return runnerFailure(
-          'MARKER_ORIGIN_MISMATCH',
-          'Database already has a contract marker but the plan has no origin. This would silently overwrite the existing marker.',
-          { meta: { markerStorageHash: marker.storageHash } },
-        );
-      }
+      // No origin assertion on the plan — the caller has done its own
+      // correctness check (typically `db update` via live-schema
+      // introspection) and does not rely on marker continuity.
       return undefined;
     }
 

package/src/core/planner-produced-migration.ts

@@ -47,7 +47,6 @@ export class PlannerProducedMongoMigration
     return renderCallsToTypeScript(this.calls, {
       from: this.meta.from,
       to: this.meta.to,
-      ...ifDefined('kind', this.meta.kind),
       ...ifDefined('labels', this.meta.labels),
     });
   }

package/src/core/render-typescript.ts

@@ -3,16 +3,31 @@ import { type ImportRequirement, jsonToTsSource, renderImports } from '@prisma-n
 import type { OpFactoryCall } from './op-factory-call';
 
 export interface RenderMigrationMeta {
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
-  readonly kind?: string;
   readonly labels?: readonly string[];
 }
 
-const BASE_IMPORT: ImportRequirement = {
-  moduleSpecifier: '@prisma-next/family-mongo/migration',
-  symbol: 'Migration',
-};
+/**
+ * Always-present base imports for the rendered scaffold:
+ *
+ * - `Migration` from `@prisma-next/family-mongo/migration` — the
+ *   user-facing Mongo `Migration` base; subclasses don't need to
+ *   redeclare `targetId` or thread family/target generics.
+ * - `MigrationCLI` from `@prisma-next/cli/migration-cli` — the
+ *   migration-file CLI entrypoint that loads `prisma-next.config.ts`,
+ *   assembles a `ControlStack`, and instantiates the migration class.
+ *   The migration file owns this dependency directly: pulling CLI
+ *   machinery in at script run time is acceptable because the script's
+ *   whole purpose is to be invoked from the project that owns the
+ *   config. (Mirrors the postgres facade pattern; pulling `MigrationCLI`
+ *   into `@prisma-next/family-mongo/migration` so a Mongo migration only
+ *   needs one import is tracked separately as a follow-up.)
+ */
+const BASE_IMPORTS: readonly ImportRequirement[] = [
+  { moduleSpecifier: '@prisma-next/family-mongo/migration', symbol: 'Migration' },
+  { moduleSpecifier: '@prisma-next/cli/migration-cli', symbol: 'MigrationCLI' },
+];
 
 /**
  * Render a list of Mongo `OpFactoryCall`s as a `migration.ts`
@@ -20,16 +35,16 @@ const BASE_IMPORT: ImportRequirement = {
  * `Migration` (i.e. `MongoMigration`) from `@prisma-next/family-mongo`, and
  * implements the abstract `operations` and `describe` members. `meta` is
  * always rendered — `describe()` is part of the `Migration` contract, so
- * even an empty stub must satisfy it; callers pass empty strings for a
- * migration-new scaffold.
+ * even an empty stub must satisfy it; callers pass `from: null` for a
+ * baseline `migration-new` scaffold (and a real `to` hash either way).
  *
  * The walk is polymorphic: each call node contributes its own
  * `renderTypeScript()` expression and declares its own
  * `importRequirements()`. The top-level renderer aggregates imports
  * across all nodes and emits one `import { … } from "…"` line per module.
- * The `Migration` import from `@prisma-next/family-mongo/migration` is
- * always emitted — it's driven by `meta` (the rendered scaffold always
- * extends `Migration`), not by any node.
+ * The `Migration` and `MigrationCLI` imports are always emitted — they're
+ * structural to the rendered scaffold (extends `Migration`, calls
+ * `MigrationCLI.run`), not driven by any node.
  */
 export function renderCallsToTypeScript(
   calls: ReadonlyArray<OpFactoryCall>,
@@ -52,13 +67,13 @@ export function renderCallsToTypeScript(
     '}',
     '',
     'export default M;',
-    'Migration.run(import.meta.url, M);',
+    'MigrationCLI.run(import.meta.url, M);',
     '',
   ].join('\n');
 }
 
 function buildImports(calls: ReadonlyArray<OpFactoryCall>): string {
-  const requirements: ImportRequirement[] = [BASE_IMPORT];
+  const requirements: ImportRequirement[] = [...BASE_IMPORTS];
   for (const call of calls) {
     for (const req of call.importRequirements()) {
       requirements.push(req);
@@ -73,9 +88,6 @@ function buildDescribeMethod(meta: RenderMigrationMeta): string {
   lines.push('    return {');
   lines.push(`      from: ${JSON.stringify(meta.from)},`);
   lines.push(`      to: ${JSON.stringify(meta.to)},`);
-  if (meta.kind) {
-    lines.push(`      kind: ${JSON.stringify(meta.kind)},`);
-  }
   if (meta.labels && meta.labels.length > 0) {
     lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
   }