@prisma-next/target-mongo 0.4.0-dev.8 → 0.4.1

package/dist/control.mjs

@@ -1,11 +1,13 @@
-import { a as dropIndex, i as dropCollection, n as createCollection, r as createIndex, t as collMod } from "./migration-factories-Brzz-QGG.mjs";
+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 { RawAggregateCommand, RawFindOneAndUpdateCommand, RawInsertOneCommand } from "@prisma-next/mongo-query-ast/execution";
+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 { ifDefined } from "@prisma-next/utils/defined";
 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
@@ -295,6 +297,76 @@ const ExistsFilterJson = type({
 	field: "string",
 	exists: "boolean"
 });
+const RawInsertOneJson = type({
+	kind: "\"rawInsertOne\"",
+	collection: "string",
+	document: "Record<string, unknown>"
+});
+const RawInsertManyJson = type({
+	kind: "\"rawInsertMany\"",
+	collection: "string",
+	documents: "Record<string, unknown>[]"
+});
+const RawUpdateOneJson = type({
+	kind: "\"rawUpdateOne\"",
+	collection: "string",
+	filter: "Record<string, unknown>",
+	update: "Record<string, unknown> | Record<string, unknown>[]"
+});
+const RawUpdateManyJson = type({
+	kind: "\"rawUpdateMany\"",
+	collection: "string",
+	filter: "Record<string, unknown>",
+	update: "Record<string, unknown> | Record<string, unknown>[]"
+});
+const RawDeleteOneJson = type({
+	kind: "\"rawDeleteOne\"",
+	collection: "string",
+	filter: "Record<string, unknown>"
+});
+const RawDeleteManyJson = type({
+	kind: "\"rawDeleteMany\"",
+	collection: "string",
+	filter: "Record<string, unknown>"
+});
+const RawAggregateJson = type({
+	kind: "\"rawAggregate\"",
+	collection: "string",
+	pipeline: "Record<string, unknown>[]"
+});
+const RawFindOneAndUpdateJson = type({
+	kind: "\"rawFindOneAndUpdate\"",
+	collection: "string",
+	filter: "Record<string, unknown>",
+	update: "Record<string, unknown> | Record<string, unknown>[]",
+	upsert: "boolean"
+});
+const RawFindOneAndDeleteJson = type({
+	kind: "\"rawFindOneAndDelete\"",
+	collection: "string",
+	filter: "Record<string, unknown>"
+});
+const TypedAggregateJson = type({
+	kind: "\"aggregate\"",
+	collection: "string",
+	pipeline: "Record<string, unknown>[]"
+});
+const QueryPlanJson = type({
+	collection: "string",
+	command: "Record<string, unknown>",
+	meta: type({
+		target: "string",
+		storageHash: "string",
+		lane: "string",
+		paramDescriptors: "unknown[]",
+		"targetFamily?": "string",
+		"profileHash?": "string",
+		"annotations?": "Record<string, unknown>",
+		"refs?": "Record<string, unknown>",
+		"projection?": "Record<string, string> | string[]",
+		"projectionTypes?": "Record<string, string>"
+	})
+});
 const CheckJson = type({
 	description: "string",
 	source: "Record<string, unknown>",
@@ -305,7 +377,7 @@ const StepJson = type({
 	description: "string",
 	command: "Record<string, unknown>"
 });
-const OperationJson = type({
+const DdlOperationJson = type({
 	id: "string",
 	label: "string",
 	operationClass: "\"additive\" | \"widening\" | \"destructive\"",
@@ -313,6 +385,21 @@ const OperationJson = type({
 	execute: "Record<string, unknown>[]",
 	postcheck: "Record<string, unknown>[]"
 });
+const DataTransformCheckJson = type({
+	description: "string",
+	source: "Record<string, unknown>",
+	filter: "Record<string, unknown>",
+	expect: "\"exists\" | \"notExists\""
+});
+const DataTransformOperationJson = type({
+	id: "string",
+	label: "string",
+	operationClass: "\"data\"",
+	name: "string",
+	precheck: "Record<string, unknown>[]",
+	run: "Record<string, unknown>[]",
+	postcheck: "Record<string, unknown>[]"
+});
 function validate(schema, data, context) {
 	try {
 		return schema.assert(data);
@@ -353,6 +440,108 @@ function deserializeFilterExpr(json) {
 		default: throw new Error(`Unknown filter expression kind: ${kind}`);
 	}
 }
+function deserializePipelineStage(json) {
+	const record = json;
+	const kind = record["kind"];
+	switch (kind) {
+		case "match": return new MongoMatchStage(deserializeFilterExpr(record["filter"]));
+		case "limit": return new MongoLimitStage(record["limit"]);
+		case "sort": return new MongoSortStage(record["sort"]);
+		case "project": return new MongoProjectStage(record["projection"]);
+		case "addFields": return new MongoAddFieldsStage(record["fields"]);
+		case "lookup": {
+			const opts = {
+				from: record["from"],
+				as: record["as"]
+			};
+			if (record["localField"] !== void 0) opts.localField = record["localField"];
+			if (record["foreignField"] !== void 0) opts.foreignField = record["foreignField"];
+			if (record["pipeline"] !== void 0) opts.pipeline = record["pipeline"].map(deserializePipelineStage);
+			if (record["let_"] !== void 0) opts.let_ = record["let_"];
+			return new MongoLookupStage(opts);
+		}
+		case "merge": {
+			const opts = { into: record["into"] };
+			if (record["on"] !== void 0) opts.on = record["on"];
+			if (record["whenMatched"] !== void 0) {
+				const wm = record["whenMatched"];
+				opts.whenMatched = typeof wm === "string" ? wm : wm.map(deserializePipelineStage);
+			}
+			if (record["whenNotMatched"] !== void 0) opts.whenNotMatched = record["whenNotMatched"];
+			return new MongoMergeStage(opts);
+		}
+		default: throw new Error(`Unknown pipeline stage kind: ${kind}`);
+	}
+}
+function deserializeDmlCommand(json) {
+	const kind = json["kind"];
+	switch (kind) {
+		case "rawInsertOne": {
+			const data = validate(RawInsertOneJson, json, "rawInsertOne command");
+			return new RawInsertOneCommand(data.collection, data.document);
+		}
+		case "rawInsertMany": {
+			const data = validate(RawInsertManyJson, json, "rawInsertMany command");
+			return new RawInsertManyCommand(data.collection, data.documents);
+		}
+		case "rawUpdateOne": {
+			const data = validate(RawUpdateOneJson, json, "rawUpdateOne command");
+			return new RawUpdateOneCommand(data.collection, data.filter, data.update);
+		}
+		case "rawUpdateMany": {
+			const data = validate(RawUpdateManyJson, json, "rawUpdateMany command");
+			return new RawUpdateManyCommand(data.collection, data.filter, data.update);
+		}
+		case "rawDeleteOne": {
+			const data = validate(RawDeleteOneJson, json, "rawDeleteOne command");
+			return new RawDeleteOneCommand(data.collection, data.filter);
+		}
+		case "rawDeleteMany": {
+			const data = validate(RawDeleteManyJson, json, "rawDeleteMany command");
+			return new RawDeleteManyCommand(data.collection, data.filter);
+		}
+		case "rawAggregate": {
+			const data = validate(RawAggregateJson, json, "rawAggregate command");
+			return new RawAggregateCommand(data.collection, data.pipeline);
+		}
+		case "rawFindOneAndUpdate": {
+			const data = validate(RawFindOneAndUpdateJson, json, "rawFindOneAndUpdate command");
+			return new RawFindOneAndUpdateCommand(data.collection, data.filter, data.update, data.upsert);
+		}
+		case "rawFindOneAndDelete": {
+			const data = validate(RawFindOneAndDeleteJson, json, "rawFindOneAndDelete command");
+			return new RawFindOneAndDeleteCommand(data.collection, data.filter);
+		}
+		case "aggregate": {
+			const data = validate(TypedAggregateJson, json, "aggregate command");
+			const pipeline = data.pipeline.map(deserializePipelineStage);
+			return new AggregateCommand(data.collection, pipeline);
+		}
+		default: throw new Error(`Unknown DML command kind: ${kind}`);
+	}
+}
+function deserializeMongoQueryPlan(json) {
+	const data = validate(QueryPlanJson, json, "Mongo query plan");
+	const command = deserializeDmlCommand(data.command);
+	const m = data.meta;
+	const meta = {
+		target: m.target,
+		storageHash: m.storageHash,
+		lane: m.lane,
+		paramDescriptors: m.paramDescriptors,
+		...ifDefined("targetFamily", m.targetFamily),
+		...ifDefined("profileHash", m.profileHash),
+		...ifDefined("annotations", m.annotations),
+		...ifDefined("refs", m.refs),
+		...ifDefined("projection", m.projection),
+		...ifDefined("projectionTypes", m.projectionTypes)
+	};
+	return {
+		collection: data.collection,
+		command,
+		meta
+	};
+}
 function deserializeDdlCommand(json) {
 	const kind = json["kind"];
 	switch (kind) {
@@ -429,8 +618,11 @@ function deserializeStep(json) {
 		command: deserializeDdlCommand(data.command)
 	};
 }
-function deserializeMongoOp(json) {
-	const data = validate(OperationJson, json, "migration operation");
+function isDataTransformJson(json) {
+	return typeof json === "object" && json !== null && json["operationClass"] === "data";
+}
+function deserializeDdlOp(json) {
+	const data = validate(DdlOperationJson, json, "migration operation");
 	return {
 		id: data.id,
 		label: data.label,
@@ -440,6 +632,31 @@ function deserializeMongoOp(json) {
 		postcheck: data.postcheck.map(deserializeCheck)
 	};
 }
+function deserializeDataTransformCheck(json) {
+	const data = validate(DataTransformCheckJson, json, "data transform check");
+	return {
+		description: data.description,
+		source: deserializeMongoQueryPlan(data.source),
+		filter: deserializeFilterExpr(data.filter),
+		expect: data.expect
+	};
+}
+function deserializeDataTransformOp(json) {
+	const data = validate(DataTransformOperationJson, json, "data transform operation");
+	return {
+		id: data.id,
+		label: data.label,
+		operationClass: "data",
+		name: data.name,
+		precheck: data.precheck.map(deserializeDataTransformCheck),
+		run: data.run.map(deserializeMongoQueryPlan),
+		postcheck: data.postcheck.map(deserializeDataTransformCheck)
+	};
+}
+function deserializeMongoOp(json) {
+	if (isDataTransformJson(json)) return deserializeDataTransformOp(json);
+	return deserializeDdlOp(json);
+}
 function deserializeMongoOps(json) {
 	return json.map(deserializeMongoOp);
 }
@@ -449,7 +666,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);
 	}
@@ -458,7 +682,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;
@@ -472,12 +696,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;
@@ -489,12 +716,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;
@@ -506,12 +736,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;
@@ -521,12 +754,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;
@@ -541,8 +777,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) {
@@ -582,41 +821,36 @@ 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
+const BASE_IMPORT = {
+	moduleSpecifier: "@prisma-next/family-mongo/migration",
+	symbol: "Migration"
+};
 /**
-* 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` 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.
 */
 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,
@@ -635,15 +869,10 @@ function renderCallsToTypeScript(calls, meta) {
 		""
 	].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_IMPORT];
+	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
+	return renderImports(requirements);
 }
 function buildDescribeMethod(meta) {
 	const lines = [];
@@ -652,55 +881,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");
@@ -871,12 +1057,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([], {
@@ -923,6 +1108,10 @@ 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,
@@ -935,7 +1124,7 @@ var MongoMigrationRunner = class {
 		this.deps = deps;
 	}
 	async execute(options) {
-		const { commandExecutor, inspectionExecutor, markerOps } = this.deps;
+		const { commandExecutor, inspectionExecutor, adapter, driver, markerOps } = this.deps;
 		const operations = deserializeMongoOps(options.plan.operations);
 		const policyCheck = this.enforcePolicyCompatibility(options.policy, operations);
 		if (policyCheck) return policyCheck;
@@ -951,15 +1140,22 @@ var MongoMigrationRunner = class {
 		for (const operation of operations) {
 			options.callbacks?.onOperationStart?.(operation);
 			try {
+				if (operation.operationClass === "data") {
+					const result = await this.executeDataTransform(operation, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks);
+					if (result.failure) return result.failure;
+					if (result.executed) operationsExecuted += 1;
+					continue;
+				}
+				const ddlOp = operation;
 				if (runPostchecks && runIdempotency) {
-					if (await this.allChecksSatisfied(operation.postcheck, inspectionExecutor, filterEvaluator)) continue;
+					if (await this.allChecksSatisfied(ddlOp.postcheck, inspectionExecutor, filterEvaluator)) continue;
 				}
 				if (runPrechecks) {
-					if (!await this.evaluateChecks(operation.precheck, inspectionExecutor, filterEvaluator)) return runnerFailure("PRECHECK_FAILED", `Operation ${operation.id} failed during precheck`, { meta: { operationId: operation.id } });
+					if (!await this.evaluateChecks(ddlOp.precheck, inspectionExecutor, filterEvaluator)) return runnerFailure("PRECHECK_FAILED", `Operation ${operation.id} failed during precheck`, { meta: { operationId: operation.id } });
 				}
-				for (const step of operation.execute) await step.command.accept(commandExecutor);
+				for (const step of ddlOp.execute) await step.command.accept(commandExecutor);
 				if (runPostchecks) {
-					if (!await this.evaluateChecks(operation.postcheck, inspectionExecutor, filterEvaluator)) return runnerFailure("POSTCHECK_FAILED", `Operation ${operation.id} failed during postcheck`, { meta: { operationId: operation.id } });
+					if (!await this.evaluateChecks(ddlOp.postcheck, inspectionExecutor, filterEvaluator)) return runnerFailure("POSTCHECK_FAILED", `Operation ${operation.id} failed during postcheck`, { meta: { operationId: operation.id } });
 				}
 				operationsExecuted += 1;
 			} finally {
@@ -967,7 +1163,7 @@ var MongoMigrationRunner = class {
 			}
 		}
 		const destination = options.plan.destination;
-		const profileHash = options.destinationContract.profileHash ?? destination.storageHash;
+		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
@@ -995,6 +1191,56 @@ var MongoMigrationRunner = class {
 			operationsExecuted
 		});
 	}
+	async executeDataTransform(op, adapter, driver, filterEvaluator, runIdempotency, runPrechecks, runPostchecks) {
+		if (runPostchecks && runIdempotency && op.postcheck.length > 0) {
+			if (await this.evaluateDataTransformChecks(op.postcheck, adapter, driver, filterEvaluator)) return { executed: false };
+		}
+		if (runPrechecks && op.precheck.length > 0) {
+			if (!await this.evaluateDataTransformChecks(op.precheck, adapter, driver, filterEvaluator)) return {
+				executed: false,
+				failure: runnerFailure("PRECHECK_FAILED", `Operation ${op.id} failed during precheck`, { meta: {
+					operationId: op.id,
+					name: op.name
+				} })
+			};
+		}
+		for (const plan of op.run) {
+			const wireCommand = adapter.lower(plan);
+			for await (const _ of driver.execute(wireCommand));
+		}
+		if (runPostchecks && op.postcheck.length > 0) {
+			if (!await this.evaluateDataTransformChecks(op.postcheck, adapter, driver, filterEvaluator)) return {
+				executed: false,
+				failure: runnerFailure("POSTCHECK_FAILED", `Operation ${op.id} failed during postcheck`, { meta: {
+					operationId: op.id,
+					name: op.name
+				} })
+			};
+		}
+		return { executed: true };
+	}
+	async evaluateDataTransformChecks(checks, adapter, driver, filterEvaluator) {
+		for (const check of checks) {
+			const commandKind = check.source.command.kind;
+			if (!READ_ONLY_CHECK_COMMAND_KINDS.has(commandKind)) throw errorRunnerFailed(`Data-transform check rejected: command kind "${commandKind}" is not read-only`, {
+				why: "Data-transform checks must use aggregate or rawAggregate commands so the pre/postcheck path cannot mutate the database.",
+				fix: "Author the check.source as an aggregate pipeline (or rawAggregate) rather than a DML write command.",
+				meta: {
+					checkDescription: check.description,
+					commandKind,
+					collection: check.source.collection
+				}
+			});
+			const wireCommand = adapter.lower(check.source);
+			let matchFound = false;
+			for await (const row of driver.execute(wireCommand)) if (filterEvaluator.evaluate(check.filter, row)) {
+				matchFound = true;
+				break;
+			}
+			if (!(check.expect === "exists" ? matchFound : !matchFound)) return false;
+		}
+		return true;
+	}
 	async evaluateChecks(checks, inspectionExecutor, filterEvaluator) {
 		for (const check of checks) {
 			const matchFound = (await check.source.accept(inspectionExecutor)).some((doc) => filterEvaluator.evaluate(check.filter, doc));