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

package/dist/control.d.mts

@@ -1,5 +1,6 @@
 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 { 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 { MongoContract } from "@prisma-next/mongo-contract";
@@ -7,6 +8,7 @@ import { MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, Migrat
 import { ContractMarkerRecord } from "@prisma-next/contract/types";
 import { Db } from "mongodb";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
+import { MongoAdapter, MongoDriver } from "@prisma-next/mongo-lowering";
 
 //#region src/core/contract-to-schema.d.ts
 declare function contractToMongoSchemaIR(contract: MongoContract | null): MongoSchemaIR;
@@ -43,9 +45,9 @@ declare function writeLedgerEntry(db: Db, entry: {
 }): Promise<void>;
 //#endregion
 //#region src/core/mongo-ops-serializer.d.ts
-declare function deserializeMongoOp(json: unknown): MongoMigrationPlanOperation;
-declare function deserializeMongoOps(json: readonly unknown[]): MongoMigrationPlanOperation[];
-declare function serializeMongoOps(ops: readonly MongoMigrationPlanOperation[]): string;
+declare function deserializeMongoOp(json: unknown): AnyMongoMigrationOperation;
+declare function deserializeMongoOps(json: readonly unknown[]): AnyMongoMigrationOperation[];
+declare function serializeMongoOps(ops: readonly AnyMongoMigrationOperation[]): string;
 //#endregion
 //#region src/core/mongo-planner.d.ts
 type PlanCallsResult = {
@@ -102,6 +104,8 @@ interface MarkerOperations {
 interface MongoRunnerDependencies {
   readonly commandExecutor: MongoDdlCommandVisitor<Promise<void>>;
   readonly inspectionExecutor: MongoInspectionCommandVisitor<Promise<Record<string, unknown>[]>>;
+  readonly adapter: MongoAdapter;
+  readonly driver: MongoDriver;
   readonly markerOps: MarkerOperations;
 }
 declare class MongoMigrationRunner {
@@ -118,6 +122,8 @@ declare class MongoMigrationRunner {
     readonly executionChecks?: MigrationRunnerExecutionChecks;
     readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', 'mongo'>>;
   }): Promise<MigrationRunnerResult>;
+  private executeDataTransform;
+  private evaluateDataTransformChecks;
   private evaluateChecks;
   private allChecksSatisfied;
   private enforcePolicyCompatibility;

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;AHhBa,iBGiCM,gBAAA,CHjCiB,EAAW,EGkC5C,EHlC4C,EAAA,KAAA,EAAA;;;;AC6ClD,CAAA,CAAA,EETG,OFSa,CAAA,IAAA,CAAA;;;iBGiKA,kBAAA,iBAAmC;iBAYnC,mBAAA,4BAA+C;iBAI/C,iBAAA,eAAgC;;;KC9KpC,eAAA;;kBACoC;;;sBACI;;cAEvC,qBAAA,YAAiC;ELpD9B,SAAA,CAAA,OAAA,EAAA;;;qBKwDK;IJXL,SAAA,mBAAqB,EIYH,aJZyB,CIYX,8BJZiC,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA;MIa3E;;;IH5DO,SAAA,MAAgB,EAAA,OAAA;IAGV,SAAA,MAAA,EG6KE,wBH7KF;IAAsB,SAAA,QAAA,EAAA,MAAA;IAK3B,SAAA,mBAAA,EG0KoB,aH1KpB,CG0KkC,8BH1KlC,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA;EAKF,CAAA,CAAA,EGsKN,sBHtKM;EAID;;;;;;;;;ACpCX;EAAqC,cAAA,CAAA,OAAA,EE6NX,wBF7NW,CAAA,EE6NgB,iCF7NhB;;;;UGXpB,gBAAA;gBACD,QAAQ;;;;MAIlB;;IN2BU,SAAA,WAAA,EAAuB,MAAA;;MMvBlC;;ILoEW,SAAA,MAAA,EAAA,MAAqB;;;MK/D/B;AJgBN;AAGmB,UIhBF,uBAAA,CJgBE;EAAsB,SAAA,eAAA,EIfb,sBJea,CIfU,OJeV,CAAA,IAAA,CAAA,CAAA;EAK3B,SAAA,kBAAA,EInBiB,6BJmBjB,CInB+C,OJmB/C,CInBuD,MJmBvD,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,CAAA,CAAA;EAKF,SAAA,SAAA,EIvBU,gBJuBV;;AAQA,cIhBC,oBAAA,CJgBD;EAIG,iBAAA,IAAA;EAKD,WAAA,CAAA,IAAA,EIxBuB,uBJwBvB;EA9B0B,OAAA,CAAA,OAAA,EAAA;IAAkB,SAAA,IAAA,EISvC,aJTuC;;qBIWrC;;MH9BC,gBAAU,EAAA,EAAA,EGgCJ,sBHhCI,CAAA,EAAA,IAAA;MAAK,mBAAA,EAAA,EAAA,EGiCN,sBHjCM,CAAA,EAAA,IAAA;IAAa,CAAA;IAAR,SAAA,eAAA,CAAA,EGmCX,8BHnCW;IAAO,SAAA,mBAAA,EGoCf,aHpCe,CGoCD,8BHpCC,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA;EAgB3B,CAAA,CAAA,EGqBhB,OHrBgB,CGqBR,qBHlBX,CAAA;EAcmB,QAAA,cAAY;EAqBZ,QAAA,kBAAgB;;;;;;;;;;;;;AHjCtC;;;;AC6CA;;;;AC/CA;AAGmB,cK7BN,6BAAA,SACH,SL4BS,CK5BC,0BL4BD,CAAA,YK3BN,iCL2BM,CAAA;EAAsB,iBAAA,KAAA;EAK3B,iBAAA,IAAA;EAKF,SAAA,QAAA,EAAA,OAAA;EAID,WAAA,CAAA,KAAA,EAAA,SKpC0B,aLoC1B,EAAA,EAAA,IAAA,EKnCgB,aLmChB;EAIC,IAAA,UAAA,CAAA,CAAA,EAAA,SKlC0B,0BLkC1B,EAAA;EAIG,QAAA,CAAA,CAAA,EKlCQ,aLkCR;EAKD,gBAAA,CAAA,CAAA,EAAA,MAAA;;;;iBM5CE,SAAA,QAAiB,cAAc,iBAAiB;;;UCzB/C,mBAAA;;;;;;;;;;ATyCjB;;;;AC6CA;iBQtEgB,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":";;;;;;;;;;;;;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"}

package/dist/control.mjs

@@ -1,11 +1,12 @@
-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 { 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 +296,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 +376,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 +384,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 +439,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 +617,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 +631,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);
 }
@@ -923,6 +1139,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 +1155,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 +1171,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 +1194,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 +1222,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));