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

package/dist/{op-factory-call-CfPGebEH.d.mts → op-factory-call-BjNAcPSF.d.mts}

@@ -1,76 +1,77 @@
 import { MongoSchemaCollection, MongoSchemaIndex } from "@prisma-next/mongo-schema-ir";
-import { CollModOptions, CreateCollectionOptions, CreateIndexOptions, MongoIndexKey } from "@prisma-next/mongo-query-ast/control";
-import { MigrationOperationClass } from "@prisma-next/framework-components/control";
+import { CollModOptions, CreateCollectionOptions, CreateIndexOptions, MongoIndexKey, MongoMigrationPlanOperation } from "@prisma-next/mongo-query-ast/control";
+import { ImportRequirement, TsExpression } from "@prisma-next/ts-render";
+import { MigrationOperationClass, OpFactoryCall } from "@prisma-next/framework-components/control";
 
 //#region src/core/op-factory-call.d.ts
+
 interface CollModMeta {
   readonly id?: string;
   readonly label?: string;
   readonly operationClass?: MigrationOperationClass;
 }
-interface OpFactoryCallVisitor<R> {
-  createIndex(call: CreateIndexCall): R;
-  dropIndex(call: DropIndexCall): R;
-  createCollection(call: CreateCollectionCall): R;
-  dropCollection(call: DropCollectionCall): R;
-  collMod(call: CollModCall): R;
-}
-declare abstract class OpFactoryCallNode {
-  abstract readonly factory: string;
+declare abstract class OpFactoryCallNode extends TsExpression implements OpFactoryCall {
+  abstract readonly factoryName: string;
   abstract readonly operationClass: MigrationOperationClass;
   abstract readonly label: string;
-  abstract accept<R>(visitor: OpFactoryCallVisitor<R>): R;
+  abstract toOp(): MongoMigrationPlanOperation;
+  importRequirements(): readonly ImportRequirement[];
   protected freeze(): void;
 }
 declare class CreateIndexCall extends OpFactoryCallNode {
-  readonly factory: "createIndex";
+  readonly factoryName: "createIndex";
   readonly operationClass: "additive";
   readonly collection: string;
   readonly keys: ReadonlyArray<MongoIndexKey>;
   readonly options: CreateIndexOptions | undefined;
   readonly label: string;
   constructor(collection: string, keys: ReadonlyArray<MongoIndexKey>, options?: CreateIndexOptions);
-  accept<R>(visitor: OpFactoryCallVisitor<R>): R;
+  toOp(): MongoMigrationPlanOperation;
+  renderTypeScript(): string;
 }
 declare class DropIndexCall extends OpFactoryCallNode {
-  readonly factory: "dropIndex";
+  readonly factoryName: "dropIndex";
   readonly operationClass: "destructive";
   readonly collection: string;
   readonly keys: ReadonlyArray<MongoIndexKey>;
   readonly label: string;
   constructor(collection: string, keys: ReadonlyArray<MongoIndexKey>);
-  accept<R>(visitor: OpFactoryCallVisitor<R>): R;
+  toOp(): MongoMigrationPlanOperation;
+  renderTypeScript(): string;
 }
 declare class CreateCollectionCall extends OpFactoryCallNode {
-  readonly factory: "createCollection";
+  readonly factoryName: "createCollection";
   readonly operationClass: "additive";
   readonly collection: string;
   readonly options: CreateCollectionOptions | undefined;
   readonly label: string;
   constructor(collection: string, options?: CreateCollectionOptions);
-  accept<R>(visitor: OpFactoryCallVisitor<R>): R;
+  toOp(): MongoMigrationPlanOperation;
+  renderTypeScript(): string;
 }
 declare class DropCollectionCall extends OpFactoryCallNode {
-  readonly factory: "dropCollection";
+  readonly factoryName: "dropCollection";
   readonly operationClass: "destructive";
   readonly collection: string;
   readonly label: string;
   constructor(collection: string);
-  accept<R>(visitor: OpFactoryCallVisitor<R>): R;
+  toOp(): MongoMigrationPlanOperation;
+  renderTypeScript(): string;
 }
 declare class CollModCall extends OpFactoryCallNode {
-  readonly factory: "collMod";
+  readonly factoryName: "collMod";
   readonly collection: string;
   readonly options: CollModOptions;
   readonly meta: CollModMeta | undefined;
   readonly operationClass: MigrationOperationClass;
   readonly label: string;
   constructor(collection: string, options: CollModOptions, meta?: CollModMeta);
-  accept<R>(visitor: OpFactoryCallVisitor<R>): R;
+  toOp(): MongoMigrationPlanOperation;
+  renderTypeScript(): string;
 }
-type OpFactoryCall = CreateIndexCall | DropIndexCall | CreateCollectionCall | DropCollectionCall | CollModCall;
+type OpFactoryCall$1 = CreateIndexCall | DropIndexCall | CreateCollectionCall | DropCollectionCall | CollModCall;
 declare function schemaIndexToCreateIndexOptions(index: MongoSchemaIndex): CreateIndexOptions;
 declare function schemaCollectionToCreateCollectionOptions(coll: MongoSchemaCollection): CreateCollectionOptions | undefined;
 //#endregion
-export { DropCollectionCall as a, OpFactoryCallVisitor as c, CreateIndexCall as i, schemaCollectionToCreateCollectionOptions as l, CollModMeta as n, DropIndexCall as o, CreateCollectionCall as r, OpFactoryCall as s, CollModCall as t, schemaIndexToCreateIndexOptions as u };
-//# sourceMappingURL=op-factory-call-CfPGebEH.d.mts.map
+export { DropCollectionCall as a, schemaCollectionToCreateCollectionOptions as c, CreateIndexCall as i, schemaIndexToCreateIndexOptions as l, CollModMeta as n, DropIndexCall as o, CreateCollectionCall as r, OpFactoryCall$1 as s, CollModCall as t };
+//# sourceMappingURL=op-factory-call-BjNAcPSF.d.mts.map

package/dist/op-factory-call-BjNAcPSF.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"op-factory-call-BjNAcPSF.d.mts","names":[],"sources":["../src/core/op-factory-call.ts"],"sourcesContent":[],"mappings":";;;;;;;AAwEqC,UA3BpB,WAAA,CA2BoB;EAAiB,SAAA,EAAA,CAAA,EAAA,MAAA;EAgCzC,SAAA,KAAA,CAAA,EAAc,MAAA;EAII,SAAA,cAAA,CAAA,EA5DH,uBA4DG;;uBAvDhB,iBAAA,SAA0B,YAAA,YAAwB,aA0DX,CAAA;EAAd,kBAAA,WAAA,EAAA,MAAA;EAQ9B,kBAAA,cAAA,EAhE0B,uBAgE1B;EAfyB,kBAAA,KAAA,EAAA,MAAA;EAAiB,SAAA,IAAA,CAAA,CAAA,EA/CjC,2BA+CiC;EAwBvC,kBAAA,CAAA,CAAA,EAAA,SArEoB,iBAqEC,EAAA;EAId,UAAA,MAAA,CAAA,CAAA,EAAA,IAAA;;AAWV,cAvEG,eAAA,SAAwB,iBAAA,CAuE3B;EAfgC,SAAA,WAAA,EAAA,aAAA;EAAiB,SAAA,cAAA,EAAA,UAAA;EA0B9C,SAAA,UAAA,EAAmB,MAAA;EAsBnB,SAAA,IAAA,EApGI,aAoGQ,CApGM,aAoGN,CAAA;EAGL,SAAA,OAAA,EAtGA,kBAsGA,GAAA,SAAA;EACH,SAAA,KAAA,EAAA,MAAA;EACU,WAAA,CAAA,UAAA,EAAA,MAAA,EAAA,IAAA,EAnGjB,aAmGiB,CAnGH,aAmGG,CAAA,EAAA,OAAA,CAAA,EAlGb,kBAkGa;EAGgB,IAAA,CAAA,CAAA,EA3FjC,2BA2FiC;EAAuB,gBAAA,CAAA,CAAA,EAAA,MAAA;;AARjC,cAxEpB,aAAA,SAAsB,iBAAA,CAwEF;EAAiB,SAAA,WAAA,EAAA,WAAA;EA6BtC,SAAA,cAAa,EAAA,aAAA;EACrB,SAAA,UAAA,EAAA,MAAA;EACA,SAAA,IAAA,EAnGa,aAmGb,CAnG2B,aAmG3B,CAAA;EACA,SAAA,KAAA,EAAA,MAAA;EACA,WAAA,CAAA,UAAA,EAAA,MAAA,EAAA,IAAA,EAlGoC,aAkGpC,CAlGkD,aAkGlD,CAAA;EACA,IAAA,CAAA,CAAA,EA3FM,2BA2FN;EAAW,gBAAA,CAAA,CAAA,EAAA,MAAA;AAEf;AAcgB,cAlGH,oBAAA,SAA6B,iBAAA,CAmGlC;;;;oBA/FY;;4CAGwB;UAQlC;;;cAWG,kBAAA,SAA2B,iBAAA;;;;;;UAa9B;;;cASG,WAAA,SAAoB,iBAAA;;;oBAGb;iBACH;2BACU;;2CAGgB,uBAAuB;UAUxD;;;KAWE,eAAA,GACR,kBACA,gBACA,uBACA,qBACA;iBAEY,+BAAA,QAAuC,mBAAmB;iBAc1D,yCAAA,OACR,wBACL"}

package/package.json

@@ -1,21 +1,23 @@
 {
   "name": "@prisma-next/target-mongo",
-  "version": "0.4.0-dev.8",
+  "version": "0.4.1",
   "type": "module",
   "sideEffects": false,
   "description": "MongoDB target pack for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.29",
     "mongodb": "^6.16.0",
-    "@prisma-next/contract": "0.4.0-dev.8",
-    "@prisma-next/framework-components": "0.4.0-dev.8",
-    "@prisma-next/mongo-contract": "0.4.0-dev.8",
-    "@prisma-next/mongo-query-ast": "0.4.0-dev.8",
-    "@prisma-next/migration-tools": "0.4.0-dev.8",
-    "@prisma-next/errors": "0.4.0-dev.8",
-    "@prisma-next/mongo-value": "0.4.0-dev.8",
-    "@prisma-next/mongo-schema-ir": "0.4.0-dev.8",
-    "@prisma-next/utils": "0.4.0-dev.8"
+    "@prisma-next/contract": "0.4.1",
+    "@prisma-next/migration-tools": "0.4.1",
+    "@prisma-next/framework-components": "0.4.1",
+    "@prisma-next/errors": "0.4.1",
+    "@prisma-next/ts-render": "0.4.1",
+    "@prisma-next/mongo-lowering": "0.4.1",
+    "@prisma-next/mongo-contract": "0.4.1",
+    "@prisma-next/mongo-query-ast": "0.4.1",
+    "@prisma-next/utils": "0.4.1",
+    "@prisma-next/mongo-schema-ir": "0.4.1",
+    "@prisma-next/mongo-value": "0.4.1"
   },
   "devDependencies": {
     "mongodb-memory-server": "10.4.3",

package/src/core/migration-factories.ts

@@ -1,4 +1,9 @@
-import type { MongoIndexKey } from '@prisma-next/mongo-query-ast/control';
+import type {
+  MongoDataTransformCheck,
+  MongoDataTransformOperation,
+  MongoFilterExpr,
+  MongoIndexKey,
+} from '@prisma-next/mongo-query-ast/control';
 import {
   buildIndexOpId,
   CollModCommand,
@@ -14,11 +19,74 @@ import {
   ListCollectionsCommand,
   ListIndexesCommand,
   MongoAndExpr,
+  MongoExistsExpr,
   MongoFieldFilter,
   type MongoMigrationPlanOperation,
 } from '@prisma-next/mongo-query-ast/control';
+import type { MongoQueryPlan } from '@prisma-next/mongo-query-ast/execution';
 import type { CollModMeta } from './op-factory-call';
 
+interface Buildable {
+  build(): MongoQueryPlan;
+}
+
+function isBuildable(value: unknown): value is Buildable {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'build' in value &&
+    typeof (value as { build: unknown }).build === 'function'
+  );
+}
+
+function resolveQuery(value: MongoQueryPlan | Buildable): MongoQueryPlan {
+  return isBuildable(value) ? value.build() : value;
+}
+
+// Every MongoDB document carries `_id`, so `exists('_id')` is equivalent to
+// "match all". The filter AST has no identity/always-true expression.
+const MATCH_ALL_FILTER: MongoFilterExpr = MongoExistsExpr.exists('_id');
+
+export function dataTransform(
+  name: string,
+  options: {
+    check?: {
+      source: () => MongoQueryPlan | Buildable;
+      filter?: MongoFilterExpr;
+      expect?: 'exists' | 'notExists';
+      description?: string;
+    };
+    run: () => MongoQueryPlan | Buildable;
+  },
+): MongoDataTransformOperation {
+  let precheck: readonly MongoDataTransformCheck[] = [];
+  let postcheck: readonly MongoDataTransformCheck[] = [];
+
+  if (options.check) {
+    const source = resolveQuery(options.check.source());
+    const filter = options.check.filter ?? MATCH_ALL_FILTER;
+    const description = options.check.description ?? `Check for data transform: ${name}`;
+    const precheckExpect = options.check.expect ?? 'exists';
+    const postcheckExpect: 'exists' | 'notExists' =
+      precheckExpect === 'exists' ? 'notExists' : 'exists';
+
+    precheck = [{ description, source, filter, expect: precheckExpect }];
+    postcheck = [{ description, source, filter, expect: postcheckExpect }];
+  }
+
+  const run: MongoQueryPlan[] = [resolveQuery(options.run())];
+
+  return {
+    id: `data_transform.${name}`,
+    label: `Data transform: ${name}`,
+    operationClass: 'data',
+    name,
+    precheck,
+    run,
+    postcheck,
+  };
+}
+
 function formatKeys(keys: ReadonlyArray<MongoIndexKey>): string {
   return keys.map((k) => `${k.field}:${k.direction}`).join(', ');
 }

package/src/core/mongo-ops-serializer.ts

@@ -1,7 +1,9 @@
+import type { PlanMeta } from '@prisma-next/contract/types';
 import type { MigrationOperationClass } from '@prisma-next/framework-components/control';
 import {
   type AnyMongoDdlCommand,
   type AnyMongoInspectionCommand,
+  type AnyMongoMigrationOperation,
   CollModCommand,
   CreateCollectionCommand,
   CreateIndexCommand,
@@ -10,6 +12,8 @@ import {
   ListCollectionsCommand,
   ListIndexesCommand,
   MongoAndExpr,
+  type MongoDataTransformCheck,
+  type MongoDataTransformOperation,
   MongoExistsExpr,
   MongoFieldFilter,
   type MongoFilterExpr,
@@ -19,6 +23,30 @@ import {
   MongoNotExpr,
   MongoOrExpr,
 } from '@prisma-next/mongo-query-ast/control';
+import {
+  AggregateCommand,
+  type AnyMongoCommand,
+  MongoAddFieldsStage,
+  MongoLimitStage,
+  MongoLookupStage,
+  MongoMatchStage,
+  MongoMergeStage,
+  type MongoPipelineStage,
+  MongoProjectStage,
+  type MongoQueryPlan,
+  MongoSortStage,
+  type MongoUpdatePipelineStage,
+  RawAggregateCommand,
+  RawDeleteManyCommand,
+  RawDeleteOneCommand,
+  RawFindOneAndDeleteCommand,
+  RawFindOneAndUpdateCommand,
+  RawInsertManyCommand,
+  RawInsertOneCommand,
+  RawUpdateManyCommand,
+  RawUpdateOneCommand,
+} from '@prisma-next/mongo-query-ast/execution';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { type } from 'arktype';
 
 const IndexKeyDirection = type('1 | -1 | "text" | "2dsphere" | "2d" | "hashed"');
@@ -97,6 +125,97 @@ const ExistsFilterJson = type({
   exists: 'boolean',
 });
 
+// ============================================================================
+// DML command schemas
+// ============================================================================
+
+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 PlanMetaJson = 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 QueryPlanJson = type({
+  collection: 'string',
+  command: 'Record<string, unknown>',
+  meta: PlanMetaJson,
+});
+
+// ============================================================================
+// DDL check/step schemas
+// ============================================================================
+
 const CheckJson = type({
   description: 'string',
   source: 'Record<string, unknown>',
@@ -109,7 +228,7 @@ const StepJson = type({
   command: 'Record<string, unknown>',
 });
 
-const OperationJson = type({
+const DdlOperationJson = type({
   id: 'string',
   label: 'string',
   operationClass: '"additive" | "widening" | "destructive"',
@@ -118,6 +237,23 @@ const OperationJson = type({
   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<T>(schema: { assert: (data: unknown) => T }, data: unknown, context: string): T {
   try {
     return schema.assert(data);
@@ -161,6 +297,151 @@ function deserializeFilterExpr(json: unknown): MongoFilterExpr {
   }
 }
 
+// ============================================================================
+// Pipeline stage deserialization
+// ============================================================================
+
+export function deserializePipelineStage(json: unknown): MongoPipelineStage {
+  const record = json as Record<string, unknown>;
+  const kind = record['kind'] as string;
+  switch (kind) {
+    case 'match':
+      return new MongoMatchStage(deserializeFilterExpr(record['filter']));
+    case 'limit':
+      return new MongoLimitStage(record['limit'] as number);
+    case 'sort':
+      return new MongoSortStage(record['sort'] as Record<string, 1 | -1>);
+    case 'project':
+      return new MongoProjectStage(record['projection'] as Record<string, 0 | 1>);
+    case 'addFields':
+      return new MongoAddFieldsStage(record['fields'] as Record<string, never>);
+    case 'lookup': {
+      const opts: {
+        from: string;
+        as: string;
+        localField?: string;
+        foreignField?: string;
+        pipeline?: ReadonlyArray<MongoPipelineStage>;
+        let_?: Record<string, never>;
+      } = {
+        from: record['from'] as string,
+        as: record['as'] as string,
+      };
+      if (record['localField'] !== undefined) opts.localField = record['localField'] as string;
+      if (record['foreignField'] !== undefined)
+        opts.foreignField = record['foreignField'] as string;
+      if (record['pipeline'] !== undefined)
+        opts.pipeline = (record['pipeline'] as unknown[]).map(deserializePipelineStage);
+      if (record['let_'] !== undefined) opts.let_ = record['let_'] as Record<string, never>;
+      return new MongoLookupStage(opts);
+    }
+    case 'merge': {
+      const opts: {
+        into: string | { db: string; coll: string };
+        on?: string | ReadonlyArray<string>;
+        whenMatched?: string | ReadonlyArray<MongoUpdatePipelineStage>;
+        whenNotMatched?: string;
+      } = {
+        into: record['into'] as string | { db: string; coll: string },
+      };
+      if (record['on'] !== undefined) opts.on = record['on'] as string | string[];
+      if (record['whenMatched'] !== undefined) {
+        const wm = record['whenMatched'];
+        opts.whenMatched =
+          typeof wm === 'string'
+            ? wm
+            : ((wm as unknown[]).map(deserializePipelineStage) as MongoUpdatePipelineStage[]);
+      }
+      if (record['whenNotMatched'] !== undefined)
+        opts.whenNotMatched = record['whenNotMatched'] as string;
+      return new MongoMergeStage(opts);
+    }
+    default:
+      throw new Error(`Unknown pipeline stage kind: ${kind}`);
+  }
+}
+
+// ============================================================================
+// DML command deserialization
+// ============================================================================
+
+export function deserializeDmlCommand(json: unknown): AnyMongoCommand {
+  const record = json as Record<string, unknown>;
+  const kind = record['kind'] as string;
+  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}`);
+  }
+}
+
+// ============================================================================
+// MongoQueryPlan deserialization
+// ============================================================================
+
+export function deserializeMongoQueryPlan(json: unknown): MongoQueryPlan {
+  const data = validate(QueryPlanJson, json, 'Mongo query plan');
+  const command = deserializeDmlCommand(data.command);
+  const m = data.meta;
+  const meta: PlanMeta = {
+    target: m.target,
+    storageHash: m.storageHash,
+    lane: m.lane,
+    paramDescriptors: m.paramDescriptors as PlanMeta['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 };
+}
+
+// ============================================================================
+// DDL command deserialization
+// ============================================================================
+
 function deserializeDdlCommand(json: unknown): AnyMongoDdlCommand {
   const record = json as Record<string, unknown>;
   const kind = record['kind'] as string;
@@ -256,8 +537,16 @@ function deserializeStep(json: unknown): MongoMigrationStep {
   };
 }
 
-export function deserializeMongoOp(json: unknown): MongoMigrationPlanOperation {
-  const data = validate(OperationJson, json, 'migration operation');
+function isDataTransformJson(json: unknown): boolean {
+  return (
+    typeof json === 'object' &&
+    json !== null &&
+    (json as Record<string, unknown>)['operationClass'] === 'data'
+  );
+}
+
+function deserializeDdlOp(json: unknown): MongoMigrationPlanOperation {
+  const data = validate(DdlOperationJson, json, 'migration operation');
   return {
     id: data.id,
     label: data.label,
@@ -268,10 +557,40 @@ export function deserializeMongoOp(json: unknown): MongoMigrationPlanOperation {
   };
 }
 
-export function deserializeMongoOps(json: readonly unknown[]): MongoMigrationPlanOperation[] {
+function deserializeDataTransformCheck(json: unknown): MongoDataTransformCheck {
+  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: unknown): MongoDataTransformOperation {
+  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),
+  };
+}
+
+export function deserializeMongoOp(json: unknown): AnyMongoMigrationOperation {
+  if (isDataTransformJson(json)) {
+    return deserializeDataTransformOp(json);
+  }
+  return deserializeDdlOp(json);
+}
+
+export function deserializeMongoOps(json: readonly unknown[]): AnyMongoMigrationOperation[] {
   return json.map(deserializeMongoOp);
 }
 
-export function serializeMongoOps(ops: readonly MongoMigrationPlanOperation[]): string {
+export function serializeMongoOps(ops: readonly AnyMongoMigrationOperation[]): string {
   return JSON.stringify(ops, null, 2);
 }

package/src/core/mongo-planner.ts

@@ -243,12 +243,11 @@ export 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 {
     return new PlannerProducedMongoMigration([], {