@prisma-next/target-mongo 0.4.0-dev.9 → 0.4.2

package/README.md

@@ -14,6 +14,8 @@ MongoDB target pack for Prisma Next.
 - `./pack`: pure target pack ref used by `@prisma-next/family-mongo` and `@prisma-next/mongo-contract-ts`
 - `./codec-types`: base Mongo codec type map
 - `./migration`: factory functions (the `Migration` base class is in `@prisma-next/family-mongo/migration`)
+- `./control`: `MongoMigrationRunner` and `createMongoRunnerDeps` for runtime migration execution
+- `./schema-verify`: pure `verifyMongoSchema(...)` (no DB I/O); composes `contractToMongoSchemaIR` and `diffMongoSchemas` so the runner's post-apply verify step and `MongoFamilyInstance.schemaVerify` agree on "matches the contract" by construction
 
 ## Usage
 
@@ -33,6 +35,7 @@ const contract = defineContract({
 ### Migration authoring
 
 ```typescript
+import { MigrationCLI } from '@prisma-next/cli/migration-cli';
 import { Migration } from '@prisma-next/family-mongo/migration';
 import { createIndex, createCollection } from '@prisma-next/target-mongo/migration';
 
@@ -49,7 +52,7 @@ class UsersMigration extends Migration {
 }
 
 export default UsersMigration;
-Migration.run(import.meta.url, UsersMigration)
+MigrationCLI.run(import.meta.url, UsersMigration);
 ```
 
 Run `tsx migration.ts` to produce `ops.json` and `migration.json` (when `describe()` is implemented). Use `--dry-run` to preview without writing.

package/dist/control.d.mts

@@ -1,10 +1,10 @@
-import { a as DropCollectionCall, c as OpFactoryCallVisitor, i as CreateIndexCall, l as schemaCollectionToCreateCollectionOptions, n as CollModMeta, o as DropIndexCall, r as CreateCollectionCall, s as OpFactoryCall, t as CollModCall, u as schemaIndexToCreateIndexOptions } from "./op-factory-call-CfPGebEH.mjs";
+import { a as DropCollectionCall, c as schemaCollectionToCreateCollectionOptions, i as CreateIndexCall, l as schemaIndexToCreateIndexOptions, n as CollModMeta, o as DropIndexCall, r as CreateCollectionCall, s as OpFactoryCall, t as CollModCall } from "./op-factory-call-CVgzmLJh.mjs";
 import { MongoSchemaIR } from "@prisma-next/mongo-schema-ir";
 import { MongoQueryPlan } from "@prisma-next/mongo-query-ast/execution";
 import { AnyMongoMigrationOperation, MongoAndExpr, MongoDdlCommandVisitor, MongoExistsExpr, MongoExprFilter, MongoFieldFilter, MongoFilterExpr, MongoFilterVisitor, MongoInspectionCommandVisitor, MongoMigrationPlanOperation, MongoNotExpr, MongoOrExpr } from "@prisma-next/mongo-query-ast/control";
 import { Migration, MigrationMeta } from "@prisma-next/migration-tools/migration";
+import { MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerResult, MigrationRunnerExecutionChecks, MigrationRunnerResult, MigrationScaffoldContext, OperationContext } from "@prisma-next/framework-components/control";
 import { MongoContract } from "@prisma-next/mongo-contract";
-import { MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerResult, MigrationRunnerExecutionChecks, MigrationRunnerResult, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
 import { ContractMarkerRecord } from "@prisma-next/contract/types";
 import { Db } from "mongodb";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
@@ -74,12 +74,11 @@ declare class MongoMigrationPlanner implements MigrationPlanner<'mongo', 'mongo'
   /**
    * Produce an empty `migration.ts` authoring surface for `migration new`.
    *
-   * Mongo is a class-flow target, so the "empty migration" is a
-   * `PlannerProducedMongoMigration` with no operations; `renderTypeScript()`
-   * emits a stub class with the correct `from`/`to` metadata that the user
-   * then fills in with operations. The contract path on the context is
-   * unused — Mongo's emitted source does not import from the generated
-   * contract `.d.ts`.
+   * The "empty migration" is a `PlannerProducedMongoMigration` with no
+   * operations; `renderTypeScript()` emits a stub class with the correct
+   * `from`/`to` metadata that the user then fills in with operations. The
+   * contract path on the context is unused — Mongo's emitted source does
+   * not import from the generated contract `.d.ts`.
    */
   emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface;
 }
@@ -107,21 +106,25 @@ interface MongoRunnerDependencies {
   readonly adapter: MongoAdapter;
   readonly driver: MongoDriver;
   readonly markerOps: MarkerOperations;
+  readonly introspectSchema: () => Promise<MongoSchemaIR>;
+}
+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;
 }
 declare class MongoMigrationRunner {
   private readonly deps;
   constructor(deps: MongoRunnerDependencies);
-  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>;
+  execute(options: MongoMigrationRunnerExecuteOptions): Promise<MigrationRunnerResult>;
   private executeDataTransform;
   private evaluateDataTransformChecks;
   private evaluateChecks;
@@ -168,15 +171,23 @@ interface RenderMigrationMeta {
   readonly labels?: readonly string[];
 }
 /**
- * Render a list of Mongo `OpFactoryCall`s as a class-flow `migration.ts`
+ * Render a list of Mongo `OpFactoryCall`s as a `migration.ts`
  * source string. The result is shebanged, extends the user-facing
  * `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.
+ *
+ * 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` and `MigrationCLI` imports are always emitted — they're
+ * structural to the rendered scaffold (extends `Migration`, calls
+ * `MigrationCLI.run`), not driven by any node.
  */
 declare function renderCallsToTypeScript(calls: ReadonlyArray<OpFactoryCall>, meta: RenderMigrationMeta): string;
 //#endregion
-export { CollModCall, type CollModMeta, CreateCollectionCall, CreateIndexCall, DropCollectionCall, DropIndexCall, FilterEvaluator, type MarkerOperations, MongoMigrationPlanner, MongoMigrationRunner, type MongoRunnerDependencies, type OpFactoryCall, type OpFactoryCallVisitor, type PlanCallsResult, PlannerProducedMongoMigration, type RenderMigrationMeta, contractToMongoSchemaIR, deserializeMongoOp, deserializeMongoOps, formatMongoOperations, initMarker, readMarker, renderCallsToTypeScript, renderOps, schemaCollectionToCreateCollectionOptions, schemaIndexToCreateIndexOptions, serializeMongoOps, updateMarker, writeLedgerEntry };
+export { CollModCall, type CollModMeta, CreateCollectionCall, CreateIndexCall, DropCollectionCall, DropIndexCall, FilterEvaluator, type MarkerOperations, MongoMigrationPlanner, MongoMigrationRunner, type MongoRunnerDependencies, type OpFactoryCall, type PlanCallsResult, PlannerProducedMongoMigration, type RenderMigrationMeta, contractToMongoSchemaIR, deserializeMongoOp, deserializeMongoOps, formatMongoOperations, initMarker, readMarker, renderCallsToTypeScript, renderOps, schemaCollectionToCreateCollectionOptions, schemaIndexToCreateIndexOptions, serializeMongoOps, updateMarker, writeLedgerEntry };
 //# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/contract-to-schema.ts","../src/core/ddl-formatter.ts","../src/core/filter-evaluator.ts","../src/core/marker-ledger.ts","../src/core/mongo-ops-serializer.ts","../src/core/mongo-planner.ts","../src/core/mongo-runner.ts","../src/core/planner-produced-migration.ts","../src/core/render-ops.ts","../src/core/render-typescript.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;iBAoDgB,uBAAA,WAAkC,uBAAuB;;;iBC6CzD,qBAAA,sBAA2C;;;cC/C9C,eAAA,YAA2B;;mBAGrB,sBAAsB;cAK3B;YAKF;WAID;YAIC;eAIG;cAKD;;;;iBCjDQ,UAAA,KAAe,KAAK,QAAQ;iBAgB5B,UAAA,KAChB;;;IAEH;iBAcmB,YAAA,KAChB;;;IAGH;iBAiBmB,gBAAA,KAChB;;EHlCU,SAAA,IAAA,EAAA,MAAA;;IGoCb;;;iBC8ea,kBAAA,iBAAmC;iBAOnC,mBAAA,4BAA+C;iBAI/C,iBAAA,eAAgC;;;KC7epC,eAAA;;kBACoC;;;sBACI;;cAEvC,qBAAA,YAAiC;;;ILpD9B,SAAA,MAAA,EAAA,OAAuB;qBKwDlB;kCACa,cAAc;MAC1C;EJbU,IAAA,CAAA,OAAA,EAAA;;;qBIiIK;IHhLR,SAAA,QAAgB,EAAA,MAAA;IAGV,SAAA,mBAAA,EG+Ke,aH/Kf,CG+K6B,8BH/K7B,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA;EAAsB,CAAA,CAAA,EGgLnC,sBHhLmC;EAK3B;;;;;;;;;;0BGkMY,2BAA2B;AF7NrD;;;UGMiB,gBAAA;gBACD,QAAQ;;;;MAIlB;;;INUU,SAAA,WAAA,EAAuB,MAAA;MMNlC;;;ILmDW,SAAA,IAAA,EAAA,MAAqB;;MK9C/B;;AJDO,UIII,uBAAA,CJJY;EAGV,SAAA,eAAA,EIES,sBJFT,CIEgC,OJFhC,CAAA,IAAA,CAAA,CAAA;EAAsB,SAAA,kBAAA,EIGV,6BJHU,CIGoB,OJHpB,CIG4B,MJH5B,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,CAAA,CAAA;EAK3B,SAAA,OAAA,EIDM,YJCN;EAKF,SAAA,MAAA,EILO,WJKP;EAID,SAAA,SAAA,EIRW,gBJQX;;AAQI,cIDF,oBAAA,CJCE;EAKD,iBAAA,IAAA;EA9B0B,WAAA,CAAA,IAAA,EIyBH,uBJzBG;EAAkB,OAAA,CAAA,OAAA,EAAA;mBI4BvC;;qBAEE;IHjDC,SAAU,SAAA,CAAA,EAAA;MAAK,gBAAA,EAAA,EAAA,EGmDT,sBHnDS,CAAA,EAAA,IAAA;MAAa,mBAAA,EAAA,EAAA,EGoDnB,sBHpDmB,CAAA,EAAA,IAAA;IAAR,CAAA;IAAO,SAAA,eAAA,CAAA,EGsDlB,8BHtDkB;IAgB3B,SAAU,mBAG7B,EGoC+B,aHpCxB,CGoCsC,8BHpCtC,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA;EAcY,CAAA,CAAA,EGuBhB,OHvBgB,CGuBR,qBHnBX,CAAA;EAiBmB,QAAA,oBAAgB;;;;ECiftB,QAAA,0BAAmC;EAOnC,QAAA,yBAAmB;AAInC;;;;;;;;;;;;AJ7hBA;;;;AC6CA;;;cMzEa,6BAAA,SACH,UAAU,uCACP;ELwBA,iBAAA,KAAgB;EAGV,iBAAA,IAAA;EAAsB,SAAA,QAAA,EAAA,OAAA;EAK3B,WAAA,CAAA,KAAA,EAAA,SK3BuB,aL2BvB,EAAA,EAAA,IAAA,EK1Ba,aL0Bb;EAKF,IAAA,UAAA,CAAA,CAAA,EAAA,SK1B0B,0BL0B1B,EAAA;EAID,QAAA,CAAA,CAAA,EK1BY,aL0BZ;EAIC,gBAAA,CAAA,CAAA,EAAA,MAAA;;;;iBMnCI,SAAA,QAAiB,cAAc,iBAAiB;;;UCzB/C,mBAAA;;;;;;;;;;;;ATyCjB;;;iBSzBgB,uBAAA,QACP,cAAc,sBACf"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/contract-to-schema.ts","../src/core/ddl-formatter.ts","../src/core/filter-evaluator.ts","../src/core/marker-ledger.ts","../src/core/mongo-ops-serializer.ts","../src/core/mongo-planner.ts","../src/core/mongo-runner.ts","../src/core/planner-produced-migration.ts","../src/core/render-ops.ts","../src/core/render-typescript.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/control.mjs

@@ -1,53 +1,16 @@
-import { a as dropCollection, n as createCollection, o as dropIndex, r as createIndex, t as collMod } from "./migration-factories-gwi81C8u.mjs";
-import { MongoSchemaCollection, MongoSchemaCollectionOptions, MongoSchemaIR, MongoSchemaIndex, MongoSchemaValidator, canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
+import { n as contractToMongoSchemaIR, t as verifyMongoSchema } from "./verify-mongo-schema-P0TRBJNs.mjs";
+import { a as dropCollection, n as createCollection, o as dropIndex, r as createIndex, t as collMod } from "./migration-factories-Dbk5afMU.mjs";
+import { canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
 import { AggregateCommand, MongoAddFieldsStage, MongoLimitStage, MongoLookupStage, MongoMatchStage, MongoMergeStage, MongoProjectStage, MongoSortStage, RawAggregateCommand, RawDeleteManyCommand, RawDeleteOneCommand, RawFindOneAndDeleteCommand, RawFindOneAndUpdateCommand, RawInsertManyCommand, RawInsertOneCommand, RawUpdateManyCommand, RawUpdateOneCommand } from "@prisma-next/mongo-query-ast/execution";
 import { CollModCommand, CreateCollectionCommand, CreateIndexCommand, DropCollectionCommand, DropIndexCommand, ListCollectionsCommand, ListIndexesCommand, MongoAndExpr, MongoExistsExpr, MongoFieldFilter, MongoNotExpr, MongoOrExpr } from "@prisma-next/mongo-query-ast/control";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { type } from "arktype";
+import { TsExpression, jsonToTsSource, renderImports } from "@prisma-next/ts-render";
 import { Migration } from "@prisma-next/migration-tools/migration";
 import { detectScaffoldRuntime, shebangLineFor } from "@prisma-next/migration-tools/migration-ts";
 import { errorRunnerFailed } from "@prisma-next/errors/execution";
 import { notOk, ok } from "@prisma-next/utils/result";
 
-//#region src/core/contract-to-schema.ts
-function convertIndex(index) {
-	return new MongoSchemaIndex({
-		keys: index.keys,
-		unique: index.unique,
-		sparse: index.sparse,
-		expireAfterSeconds: index.expireAfterSeconds,
-		partialFilterExpression: index.partialFilterExpression,
-		wildcardProjection: index.wildcardProjection,
-		collation: index.collation,
-		weights: index.weights,
-		default_language: index.default_language,
-		language_override: index.language_override
-	});
-}
-function convertValidator(v) {
-	return new MongoSchemaValidator({
-		jsonSchema: v.jsonSchema,
-		validationLevel: v.validationLevel,
-		validationAction: v.validationAction
-	});
-}
-function convertOptions(o) {
-	return new MongoSchemaCollectionOptions(o);
-}
-function convertCollection(name, def) {
-	return new MongoSchemaCollection({
-		name,
-		indexes: (def.indexes ?? []).map(convertIndex),
-		...def.validator != null && { validator: convertValidator(def.validator) },
-		...def.options != null && { options: convertOptions(def.options) }
-	});
-}
-function contractToMongoSchemaIR(contract) {
-	if (!contract) return new MongoSchemaIR([]);
-	return new MongoSchemaIR(Object.entries(contract.storage.collections).map(([name, def]) => convertCollection(name, def)));
-}
-
-//#endregion
 //#region src/core/ddl-formatter.ts
 function formatKeySpec(keys) {
 	return `{ ${keys.map((k) => `${JSON.stringify(k.field)}: ${JSON.stringify(k.direction)}`).join(", ")} }`;
@@ -665,7 +628,14 @@ function serializeMongoOps(ops) {
 
 //#endregion
 //#region src/core/op-factory-call.ts
-var OpFactoryCallNode = class {
+const TARGET_MIGRATION_MODULE = "@prisma-next/target-mongo/migration";
+var OpFactoryCallNode = class extends TsExpression {
+	importRequirements() {
+		return [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: this.factoryName
+		}];
+	}
 	freeze() {
 		Object.freeze(this);
 	}
@@ -674,7 +644,7 @@ function formatKeys(keys) {
 	return keys.map((k) => `${k.field}:${k.direction}`).join(", ");
 }
 var CreateIndexCall = class extends OpFactoryCallNode {
-	factory = "createIndex";
+	factoryName = "createIndex";
 	operationClass = "additive";
 	collection;
 	keys;
@@ -688,12 +658,15 @@ var CreateIndexCall = class extends OpFactoryCallNode {
 		this.label = `Create index on ${collection} (${formatKeys(keys)})`;
 		this.freeze();
 	}
-	accept(visitor) {
-		return visitor.createIndex(this);
+	toOp() {
+		return createIndex(this.collection, this.keys, this.options);
+	}
+	renderTypeScript() {
+		return this.options ? `createIndex(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.keys)}, ${jsonToTsSource(this.options)})` : `createIndex(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.keys)})`;
 	}
 };
 var DropIndexCall = class extends OpFactoryCallNode {
-	factory = "dropIndex";
+	factoryName = "dropIndex";
 	operationClass = "destructive";
 	collection;
 	keys;
@@ -705,12 +678,15 @@ var DropIndexCall = class extends OpFactoryCallNode {
 		this.label = `Drop index on ${collection} (${formatKeys(keys)})`;
 		this.freeze();
 	}
-	accept(visitor) {
-		return visitor.dropIndex(this);
+	toOp() {
+		return dropIndex(this.collection, this.keys);
+	}
+	renderTypeScript() {
+		return `dropIndex(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.keys)})`;
 	}
 };
 var CreateCollectionCall = class extends OpFactoryCallNode {
-	factory = "createCollection";
+	factoryName = "createCollection";
 	operationClass = "additive";
 	collection;
 	options;
@@ -722,12 +698,15 @@ var CreateCollectionCall = class extends OpFactoryCallNode {
 		this.label = `Create collection ${collection}`;
 		this.freeze();
 	}
-	accept(visitor) {
-		return visitor.createCollection(this);
+	toOp() {
+		return createCollection(this.collection, this.options);
+	}
+	renderTypeScript() {
+		return this.options ? `createCollection(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.options)})` : `createCollection(${jsonToTsSource(this.collection)})`;
 	}
 };
 var DropCollectionCall = class extends OpFactoryCallNode {
-	factory = "dropCollection";
+	factoryName = "dropCollection";
 	operationClass = "destructive";
 	collection;
 	label;
@@ -737,12 +716,15 @@ var DropCollectionCall = class extends OpFactoryCallNode {
 		this.label = `Drop collection ${collection}`;
 		this.freeze();
 	}
-	accept(visitor) {
-		return visitor.dropCollection(this);
+	toOp() {
+		return dropCollection(this.collection);
+	}
+	renderTypeScript() {
+		return `dropCollection(${jsonToTsSource(this.collection)})`;
 	}
 };
 var CollModCall = class extends OpFactoryCallNode {
-	factory = "collMod";
+	factoryName = "collMod";
 	collection;
 	options;
 	meta;
@@ -757,8 +739,11 @@ var CollModCall = class extends OpFactoryCallNode {
 		this.label = meta?.label ?? `Modify collection ${collection}`;
 		this.freeze();
 	}
-	accept(visitor) {
-		return visitor.collMod(this);
+	toOp() {
+		return collMod(this.collection, this.options, this.meta);
+	}
+	renderTypeScript() {
+		return this.meta ? `collMod(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.options)}, ${jsonToTsSource(this.meta)})` : `collMod(${jsonToTsSource(this.collection)}, ${jsonToTsSource(this.options)})`;
 	}
 };
 function schemaIndexToCreateIndexOptions(index) {
@@ -798,41 +783,55 @@ function schemaCollectionToCreateCollectionOptions(coll) {
 
 //#endregion
 //#region src/core/render-ops.ts
-const renderVisitor = {
-	createIndex(call) {
-		return createIndex(call.collection, call.keys, call.options);
-	},
-	dropIndex(call) {
-		return dropIndex(call.collection, call.keys);
-	},
-	createCollection(call) {
-		return createCollection(call.collection, call.options);
-	},
-	dropCollection(call) {
-		return dropCollection(call.collection);
-	},
-	collMod(call) {
-		return collMod(call.collection, call.options, call.meta);
-	}
-};
 function renderOps(calls) {
-	return calls.map((call) => call.accept(renderVisitor));
+	return calls.map((call) => call.toOp());
 }
 
 //#endregion
 //#region src/core/render-typescript.ts
 /**
-* Render a list of Mongo `OpFactoryCall`s as a class-flow `migration.ts`
+* 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 = [{
+	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`
 * source string. The result is shebanged, extends the user-facing
 * `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.
+*
+* 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` and `MigrationCLI` imports are always emitted — they're
+* structural to the rendered scaffold (extends `Migration`, calls
+* `MigrationCLI.run`), not driven by any node.
 */
 function renderCallsToTypeScript(calls, meta) {
-	const imports = buildImports(collectFactoryNames(calls));
-	const operationsBody = calls.map((c) => c.accept(renderCallVisitor)).join(",\n");
+	const imports = buildImports(calls);
+	const operationsBody = calls.map((c) => c.renderTypeScript()).join(",\n");
 	return [
 		shebangLineFor(detectScaffoldRuntime()),
 		imports,
@@ -847,19 +846,14 @@ function renderCallsToTypeScript(calls, meta) {
 		"}",
 		"",
 		"export default M;",
-		"Migration.run(import.meta.url, M);",
+		"MigrationCLI.run(import.meta.url, M);",
 		""
 	].join("\n");
 }
-function collectFactoryNames(calls) {
-	const names = /* @__PURE__ */ new Set();
-	for (const call of calls) names.add(call.factory);
-	return [...names].sort();
-}
-function buildImports(factoryNames) {
-	const lines = ["import { Migration } from '@prisma-next/family-mongo/migration';"];
-	if (factoryNames.length > 0) lines.push(`import { ${factoryNames.join(", ")} } from '@prisma-next/target-mongo/migration';`);
-	return lines.join("\n");
+function buildImports(calls) {
+	const requirements = [...BASE_IMPORTS];
+	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
+	return renderImports(requirements);
 }
 function buildDescribeMethod(meta) {
 	const lines = [];
@@ -868,55 +862,12 @@ function buildDescribeMethod(meta) {
 	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: ${renderLiteral(meta.labels)},`);
+	if (meta.labels && meta.labels.length > 0) lines.push(`      labels: ${jsonToTsSource(meta.labels)},`);
 	lines.push("    };");
 	lines.push("  }");
 	lines.push("");
 	return lines.join("\n");
 }
-const renderCallVisitor = {
-	createIndex(call) {
-		return call.options ? `createIndex(${renderLiteral(call.collection)}, ${renderLiteral(call.keys)}, ${renderLiteral(call.options)})` : `createIndex(${renderLiteral(call.collection)}, ${renderLiteral(call.keys)})`;
-	},
-	dropIndex(call) {
-		return `dropIndex(${renderLiteral(call.collection)}, ${renderLiteral(call.keys)})`;
-	},
-	createCollection(call) {
-		return call.options ? `createCollection(${renderLiteral(call.collection)}, ${renderLiteral(call.options)})` : `createCollection(${renderLiteral(call.collection)})`;
-	},
-	dropCollection(call) {
-		return `dropCollection(${renderLiteral(call.collection)})`;
-	},
-	collMod(call) {
-		return call.meta ? `collMod(${renderLiteral(call.collection)}, ${renderLiteral(call.options)}, ${renderLiteral(call.meta)})` : `collMod(${renderLiteral(call.collection)}, ${renderLiteral(call.options)})`;
-	}
-};
-function renderLiteral(value) {
-	if (value === void 0) return "undefined";
-	if (value === null) return "null";
-	if (typeof value === "string") return JSON.stringify(value);
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (Array.isArray(value)) {
-		if (value.length === 0) return "[]";
-		const items = value.map((v) => renderLiteral(v));
-		const singleLine = `[${items.join(", ")}]`;
-		if (singleLine.length <= 80) return singleLine;
-		return `[\n${items.map((i) => `  ${i}`).join(",\n")},\n]`;
-	}
-	if (typeof value === "object") {
-		const entries = Object.entries(value).filter(([, v]) => v !== void 0);
-		if (entries.length === 0) return "{}";
-		const items = entries.map(([k, v]) => `${renderKey(k)}: ${renderLiteral(v)}`);
-		const singleLine = `{ ${items.join(", ")} }`;
-		if (singleLine.length <= 80) return singleLine;
-		return `{\n${items.map((i) => `  ${i}`).join(",\n")},\n}`;
-	}
-	return String(value);
-}
-function renderKey(key) {
-	if (key === "__proto__") return JSON.stringify(key);
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
-}
 function indent(text, spaces) {
 	const pad = " ".repeat(spaces);
 	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : line).join("\n");
@@ -1087,12 +1038,11 @@ var MongoMigrationPlanner = class {
 	/**
 	* Produce an empty `migration.ts` authoring surface for `migration new`.
 	*
-	* Mongo is a class-flow target, so the "empty migration" is a
-	* `PlannerProducedMongoMigration` with no operations; `renderTypeScript()`
-	* emits a stub class with the correct `from`/`to` metadata that the user
-	* then fills in with operations. The contract path on the context is
-	* unused — Mongo's emitted source does not import from the generated
-	* contract `.d.ts`.
+	* The "empty migration" is a `PlannerProducedMongoMigration` with no
+	* operations; `renderTypeScript()` emits a stub class with the correct
+	* `from`/`to` metadata that the user then fills in with operations. The
+	* contract path on the context is unused — Mongo's emitted source does
+	* not import from the generated contract `.d.ts`.
 	*/
 	emptyMigration(context) {
 		return new PlannerProducedMongoMigration([], {
@@ -1140,9 +1090,6 @@ function planMutableOptionsDiffCall(collName, origin, dest) {
 //#endregion
 //#region src/core/mongo-runner.ts
 const READ_ONLY_CHECK_COMMAND_KINDS = new Set(["aggregate", "rawAggregate"]);
-function hasProfileHash(value) {
-	return typeof value === "object" && value !== null && Object.hasOwn(value, "profileHash") && typeof value.profileHash === "string";
-}
 function runnerFailure(code, summary, opts) {
 	return notOk({
 		code,
@@ -1194,11 +1141,23 @@ var MongoMigrationRunner = class {
 			}
 		}
 		const destination = options.plan.destination;
-		const profileHash = hasProfileHash(options.destinationContract) ? options.destinationContract.profileHash : destination.storageHash;
+		const profileHash = options.destinationContract.profileHash ?? destination.storageHash;
 		if (operationsExecuted === 0 && existingMarker?.storageHash === destination.storageHash && existingMarker.profileHash === profileHash) return ok({
 			operationsPlanned: operations.length,
 			operationsExecuted
 		});
+		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 (!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) {
 			if (!await markerOps.updateMarker(existingMarker.storageHash, {
 				storageHash: destination.storageHash,