@prisma-next/adapter-mongo 0.11.0 → 0.12.0-dev.10

package/src/lowering.ts

@@ -11,6 +11,7 @@ import type {
 } from '@prisma-next/mongo-query-ast/execution';
 import { isExprArray, isRecordArgs } from '@prisma-next/mongo-query-ast/execution';
 import type { Document } from '@prisma-next/mongo-value';
+import { blindCast } from '@prisma-next/utils/casts';
 import { resolveValue } from './resolve-value';
 
 // Biome flags `{ then: ... }` as a thenable object (noThenProperty). Build via Object.fromEntries to avoid.
@@ -138,6 +139,36 @@ export function lowerAggExpr(expr: MongoAggExpr): unknown {
   return expr.accept(aggExprLoweringVisitor);
 }
 
+/**
+ * Structural phase of filter lowering: transforms the filter AST into a
+ * plain object without resolving any `MongoParamRef` leaves. Field filter
+ * values remain as `MongoValue` (which includes `MongoParamRef`), so the
+ * returned document can be passed to `resolveDraftDoc` in the resolve phase.
+ * Synchronous — no codec calls.
+ */
+export function structuralLowerFilter(filter: MongoFilterExpr): Record<string, unknown> {
+  switch (filter.kind) {
+    case 'field':
+      return { [filter.field]: { [filter.op]: filter.value } };
+    case 'and':
+      return { $and: filter.exprs.map((e) => structuralLowerFilter(e)) };
+    case 'or':
+      return { $or: filter.exprs.map((e) => structuralLowerFilter(e)) };
+    case 'not':
+      return { $nor: [structuralLowerFilter(filter.expr)] };
+    case 'exists':
+      return { [filter.field]: { $exists: filter.exists } };
+    case 'expr':
+      return { $expr: lowerAggExpr(filter.aggExpr) };
+    default: {
+      const _exhaustive: never = filter;
+      throw new Error(
+        `Unhandled filter kind: ${blindCast<MongoFilterExpr, 'exhaustive switch fallback for error message'>(_exhaustive).kind}`,
+      );
+    }
+  }
+}
+
 export async function lowerFilter(
   filter: MongoFilterExpr,
   codecs: MongoCodecRegistry,
@@ -158,7 +189,9 @@ export async function lowerFilter(
       return { $expr: lowerAggExpr(filter.aggExpr) };
     default: {
       const _exhaustive: never = filter;
-      throw new Error(`Unhandled filter kind: ${(_exhaustive as MongoFilterExpr).kind}`);
+      throw new Error(
+        `Unhandled filter kind: ${blindCast<MongoFilterExpr, 'exhaustive switch fallback for error message'>(_exhaustive).kind}`,
+      );
     }
   }
 }
@@ -167,6 +200,12 @@ function isAggExprNode(value: object): value is MongoAggExpr {
   return 'accept' in value && typeof value.accept === 'function';
 }
 
+function isAggExprArray(
+  val: MongoAggExpr | ReadonlyArray<MongoAggExpr>,
+): val is ReadonlyArray<MongoAggExpr> {
+  return Array.isArray(val);
+}
+
 function lowerGroupId(groupId: MongoGroupId): unknown {
   if (groupId === null) return null;
   if (isAggExprNode(groupId)) return lowerAggExpr(groupId);
@@ -178,10 +217,10 @@ function lowerExprRecord(
 ): Record<string, unknown> {
   const result: Record<string, unknown> = {};
   for (const [key, val] of Object.entries(fields)) {
-    if (Array.isArray(val)) {
-      result[key] = val.map((v: MongoAggExpr) => lowerAggExpr(v));
+    if (isAggExprArray(val)) {
+      result[key] = val.map((v) => lowerAggExpr(v));
     } else {
-      result[key] = lowerAggExpr(val as MongoAggExpr);
+      result[key] = lowerAggExpr(val);
     }
   }
   return result;
@@ -417,7 +456,9 @@ export async function lowerStage(
     }
     default: {
       const _exhaustive: never = stage;
-      throw new Error(`Unhandled stage kind: ${(_exhaustive as MongoPipelineStage).kind}`);
+      throw new Error(
+        `Unhandled stage kind: ${blindCast<MongoPipelineStage, 'exhaustive switch fallback for error message'>(_exhaustive).kind}`,
+      );
     }
   }
 }
@@ -429,3 +470,218 @@ export async function lowerPipeline(
 ): Promise<Array<Record<string, unknown>>> {
   return Promise.all(stages.map((s) => lowerStage(s, codecs, ctx)));
 }
+
+/**
+ * Structural phase of stage lowering: mirrors `lowerStage` but defers all
+ * `MongoParamRef` resolution. Filter sub-documents within stages (e.g.
+ * `$match`, `$geoNear.query`, `$graphLookup.restrictSearchWithMatch`) are
+ * produced by `structuralLowerFilter` and therefore retain `MongoParamRef`
+ * leaves. Sub-pipelines (e.g. `$lookup.pipeline`, `$facet.*`) recurse via
+ * `structuralLowerPipeline`. Synchronous — no codec calls.
+ */
+export function structuralLowerStage(stage: MongoPipelineStage): Record<string, unknown> {
+  switch (stage.kind) {
+    case 'match':
+      return { $match: structuralLowerFilter(stage.filter) };
+    case 'project': {
+      const projection: Record<string, unknown> = {};
+      for (const [key, val] of Object.entries(stage.projection)) {
+        projection[key] = lowerProjectionValue(val);
+      }
+      return { $project: projection };
+    }
+    case 'sort':
+      return { $sort: { ...stage.sort } };
+    case 'limit':
+      return { $limit: stage.limit };
+    case 'skip':
+      return { $skip: stage.skip };
+    case 'lookup': {
+      const lookup: Record<string, unknown> = {
+        from: stage.from,
+        as: stage.as,
+      };
+      if (stage.localField !== undefined) lookup['localField'] = stage.localField;
+      if (stage.foreignField !== undefined) lookup['foreignField'] = stage.foreignField;
+      if (stage.pipeline) {
+        lookup['pipeline'] = structuralLowerPipeline(stage.pipeline);
+      }
+      if (stage.let_) {
+        lookup['let'] = lowerExprRecord(stage.let_);
+      }
+      return { $lookup: lookup };
+    }
+    case 'unwind': {
+      const unwind: Record<string, unknown> = {
+        path: stage.path,
+        preserveNullAndEmptyArrays: stage.preserveNullAndEmptyArrays,
+      };
+      if (stage.includeArrayIndex !== undefined) {
+        unwind['includeArrayIndex'] = stage.includeArrayIndex;
+      }
+      return { $unwind: unwind };
+    }
+    case 'group': {
+      const group: Record<string, unknown> = { _id: lowerGroupId(stage.groupId) };
+      for (const [key, acc] of Object.entries(stage.accumulators)) {
+        group[key] = lowerAggExpr(acc);
+      }
+      return { $group: group };
+    }
+    case 'addFields':
+      return { $addFields: lowerExprRecord(stage.fields) };
+    case 'replaceRoot':
+      return { $replaceRoot: { newRoot: lowerAggExpr(stage.newRoot) } };
+    case 'count':
+      return { $count: stage.field };
+    case 'sortByCount':
+      return { $sortByCount: lowerAggExpr(stage.expr) };
+    case 'sample':
+      return { $sample: { size: stage.size } };
+    case 'redact':
+      return { $redact: lowerAggExpr(stage.expr) };
+    case 'out':
+      return { $out: stage.db ? { db: stage.db, coll: stage.collection } : stage.collection };
+    case 'unionWith': {
+      const unionWith: Record<string, unknown> = { coll: stage.collection };
+      if (stage.pipeline) {
+        unionWith['pipeline'] = structuralLowerPipeline(stage.pipeline);
+      }
+      return { $unionWith: unionWith };
+    }
+    case 'bucket': {
+      const bucket: Record<string, unknown> = {
+        groupBy: lowerAggExpr(stage.groupBy),
+        boundaries: [...stage.boundaries],
+      };
+      if (stage.default_ !== undefined) bucket['default'] = stage.default_;
+      if (stage.output) bucket['output'] = lowerExprRecord(stage.output);
+      return { $bucket: bucket };
+    }
+    case 'bucketAuto': {
+      const bucketAuto: Record<string, unknown> = {
+        groupBy: lowerAggExpr(stage.groupBy),
+        buckets: stage.buckets,
+      };
+      if (stage.output) bucketAuto['output'] = lowerExprRecord(stage.output);
+      if (stage.granularity !== undefined) bucketAuto['granularity'] = stage.granularity;
+      return { $bucketAuto: bucketAuto };
+    }
+    case 'geoNear': {
+      const geoNear: Record<string, unknown> = {
+        near: stage.near,
+        distanceField: stage.distanceField,
+      };
+      if (stage.spherical !== undefined) geoNear['spherical'] = stage.spherical;
+      if (stage.maxDistance !== undefined) geoNear['maxDistance'] = stage.maxDistance;
+      if (stage.minDistance !== undefined) geoNear['minDistance'] = stage.minDistance;
+      if (stage.query) geoNear['query'] = structuralLowerFilter(stage.query);
+      if (stage.key !== undefined) geoNear['key'] = stage.key;
+      if (stage.distanceMultiplier !== undefined)
+        geoNear['distanceMultiplier'] = stage.distanceMultiplier;
+      if (stage.includeLocs !== undefined) geoNear['includeLocs'] = stage.includeLocs;
+      return { $geoNear: geoNear };
+    }
+    case 'facet': {
+      const facet: Record<string, unknown> = {};
+      for (const [key, pipeline] of Object.entries(stage.facets)) {
+        facet[key] = structuralLowerPipeline(pipeline);
+      }
+      return { $facet: facet };
+    }
+    case 'graphLookup': {
+      const graphLookup: Record<string, unknown> = {
+        from: stage.from,
+        startWith: lowerAggExpr(stage.startWith),
+        connectFromField: stage.connectFromField,
+        connectToField: stage.connectToField,
+        as: stage.as,
+      };
+      if (stage.maxDepth !== undefined) graphLookup['maxDepth'] = stage.maxDepth;
+      if (stage.depthField !== undefined) graphLookup['depthField'] = stage.depthField;
+      if (stage.restrictSearchWithMatch)
+        graphLookup['restrictSearchWithMatch'] = structuralLowerFilter(
+          stage.restrictSearchWithMatch,
+        );
+      return { $graphLookup: graphLookup };
+    }
+    case 'merge': {
+      const merge: Record<string, unknown> = { into: stage.into };
+      if (stage.on !== undefined) merge['on'] = stage.on;
+      if (stage.whenMatched !== undefined) {
+        merge['whenMatched'] = Array.isArray(stage.whenMatched)
+          ? structuralLowerPipeline(stage.whenMatched)
+          : stage.whenMatched;
+      }
+      if (stage.whenNotMatched !== undefined) merge['whenNotMatched'] = stage.whenNotMatched;
+      return { $merge: merge };
+    }
+    case 'setWindowFields': {
+      const swf: Record<string, unknown> = {};
+      if (stage.partitionBy) swf['partitionBy'] = lowerAggExpr(stage.partitionBy);
+      if (stage.sortBy) swf['sortBy'] = { ...stage.sortBy };
+      const output: Record<string, unknown> = {};
+      for (const [key, wf] of Object.entries(stage.output)) {
+        output[key] = lowerWindowField(wf);
+      }
+      swf['output'] = output;
+      return { $setWindowFields: swf };
+    }
+    case 'densify': {
+      const densify: Record<string, unknown> = {
+        field: stage.field,
+        range: { ...stage.range },
+      };
+      if (stage.partitionByFields) densify['partitionByFields'] = [...stage.partitionByFields];
+      return { $densify: densify };
+    }
+    case 'fill': {
+      const fill: Record<string, unknown> = {};
+      if (stage.partitionBy) fill['partitionBy'] = lowerAggExpr(stage.partitionBy);
+      if (stage.partitionByFields) fill['partitionByFields'] = [...stage.partitionByFields];
+      if (stage.sortBy) fill['sortBy'] = { ...stage.sortBy };
+      const output: Record<string, unknown> = {};
+      for (const [key, fo] of Object.entries(stage.output)) {
+        const entry: Record<string, unknown> = {};
+        if (fo.method !== undefined) entry['method'] = fo.method;
+        if (fo.value !== undefined) entry['value'] = lowerAggExpr(fo.value);
+        output[key] = entry;
+      }
+      fill['output'] = output;
+      return { $fill: fill };
+    }
+    case 'search': {
+      const search: Record<string, unknown> = { ...stage.config };
+      if (stage.index !== undefined) search['index'] = stage.index;
+      return { $search: search };
+    }
+    case 'searchMeta': {
+      const searchMeta: Record<string, unknown> = { ...stage.config };
+      if (stage.index !== undefined) searchMeta['index'] = stage.index;
+      return { $searchMeta: searchMeta };
+    }
+    case 'vectorSearch': {
+      const vs: Record<string, unknown> = {
+        index: stage.index,
+        path: stage.path,
+        queryVector: [...stage.queryVector],
+        numCandidates: stage.numCandidates,
+        limit: stage.limit,
+      };
+      if (stage.filter) vs['filter'] = { ...stage.filter };
+      return { $vectorSearch: vs };
+    }
+    default: {
+      const _exhaustive: never = stage;
+      throw new Error(
+        `Unhandled stage kind: ${blindCast<MongoPipelineStage, 'exhaustive switch fallback for error message'>(_exhaustive).kind}`,
+      );
+    }
+  }
+}
+
+export function structuralLowerPipeline(
+  stages: ReadonlyArray<MongoPipelineStage>,
+): Array<Record<string, unknown>> {
+  return stages.map((s) => structuralLowerStage(s));
+}

package/src/mongo-adapter.ts

@@ -1,12 +1,11 @@
 import type { CodecCallContext } from '@prisma-next/framework-components/codec';
 import type { MongoCodecRegistry } from '@prisma-next/mongo-codec';
-import type { MongoAdapter } from '@prisma-next/mongo-lowering';
+import type { MongoAdapter, MongoLoweredDraft } from '@prisma-next/mongo-lowering';
 import type {
   MongoQueryPlan,
   MongoUpdatePipelineStage,
   MongoUpdateSpec,
 } from '@prisma-next/mongo-query-ast/execution';
-import type { Document, MongoExpr } from '@prisma-next/mongo-value';
 import type { AnyMongoWireCommand } from '@prisma-next/mongo-wire';
 import {
   AggregateWireCommand,
@@ -19,9 +18,10 @@ import {
   UpdateManyWireCommand,
   UpdateOneWireCommand,
 } from '@prisma-next/mongo-wire';
+import { blindCast } from '@prisma-next/utils/casts';
 import { buildStandardCodecRegistry } from './core/codecs';
-import { lowerFilter, lowerPipeline, lowerStage } from './lowering';
-import { resolveValue } from './resolve-value';
+import { structuralLowerFilter, structuralLowerPipeline } from './lowering';
+import { resolveDraftDoc } from './resolve-value';
 
 function isUpdatePipeline(
   update: MongoUpdateSpec,
@@ -29,6 +29,23 @@ function isUpdatePipeline(
   return Array.isArray(update);
 }
 
+function isDraftUpdatePipeline(
+  update: Record<string, unknown> | ReadonlyArray<Record<string, unknown>>,
+): update is ReadonlyArray<Record<string, unknown>> {
+  return Array.isArray(update);
+}
+
+async function resolveUpdate(
+  update: Record<string, unknown> | ReadonlyArray<Record<string, unknown>>,
+  codecs: MongoCodecRegistry,
+  ctx: CodecCallContext,
+): Promise<Record<string, unknown> | ReadonlyArray<Record<string, unknown>>> {
+  if (isDraftUpdatePipeline(update)) {
+    return Promise.all(update.map((stage) => resolveDraftDoc(stage, codecs, ctx)));
+  }
+  return resolveDraftDoc(update, codecs, ctx);
+}
+
 class MongoAdapterImpl implements MongoAdapter {
   readonly #codecs: MongoCodecRegistry;
 
@@ -36,125 +53,237 @@ class MongoAdapterImpl implements MongoAdapter {
     this.#codecs = codecs;
   }
 
-  async #resolveDocument(expr: MongoExpr, ctx: CodecCallContext): Promise<Document> {
-    const entries = Object.entries(expr);
-    const resolved = await Promise.all(
-      entries.map(([, val]) => resolveValue(val, this.#codecs, ctx)),
-    );
-    const result: Record<string, unknown> = {};
-    for (let i = 0; i < entries.length; i++) {
-      const entry = entries[i];
-      if (entry) {
-        result[entry[0]] = resolved[i];
+  structuralLower(plan: MongoQueryPlan): MongoLoweredDraft {
+    const { command } = plan;
+    switch (command.kind) {
+      case 'insertOne':
+        return { kind: 'insertOne', collection: command.collection, document: command.document };
+      case 'insertMany':
+        return {
+          kind: 'insertMany',
+          collection: command.collection,
+          documents: command.documents,
+        };
+      case 'updateOne':
+        return {
+          kind: 'updateOne',
+          collection: command.collection,
+          filter: structuralLowerFilter(command.filter),
+          update: isUpdatePipeline(command.update)
+            ? structuralLowerPipeline(command.update)
+            : command.update,
+          upsert: command.upsert,
+        };
+      case 'updateMany':
+        return {
+          kind: 'updateMany',
+          collection: command.collection,
+          filter: structuralLowerFilter(command.filter),
+          update: isUpdatePipeline(command.update)
+            ? structuralLowerPipeline(command.update)
+            : command.update,
+          upsert: command.upsert,
+        };
+      case 'deleteOne':
+        return {
+          kind: 'deleteOne',
+          collection: command.collection,
+          filter: structuralLowerFilter(command.filter),
+        };
+      case 'deleteMany':
+        return {
+          kind: 'deleteMany',
+          collection: command.collection,
+          filter: structuralLowerFilter(command.filter),
+        };
+      case 'findOneAndUpdate':
+        return {
+          kind: 'findOneAndUpdate',
+          collection: command.collection,
+          filter: structuralLowerFilter(command.filter),
+          update: isUpdatePipeline(command.update)
+            ? structuralLowerPipeline(command.update)
+            : command.update,
+          upsert: command.upsert,
+          sort: command.sort,
+          returnDocument: command.returnDocument,
+        };
+      case 'findOneAndDelete':
+        return {
+          kind: 'findOneAndDelete',
+          collection: command.collection,
+          filter: structuralLowerFilter(command.filter),
+          sort: command.sort,
+        };
+      case 'aggregate':
+        return {
+          kind: 'aggregate',
+          collection: command.collection,
+          pipeline: structuralLowerPipeline(command.pipeline),
+        };
+      case 'rawAggregate':
+        return { kind: 'rawAggregate', collection: command.collection, pipeline: command.pipeline };
+      case 'rawInsertOne':
+        return {
+          kind: 'rawInsertOne',
+          collection: command.collection,
+          document: command.document,
+        };
+      case 'rawInsertMany':
+        return {
+          kind: 'rawInsertMany',
+          collection: command.collection,
+          documents: command.documents,
+        };
+      case 'rawUpdateOne':
+        return {
+          kind: 'rawUpdateOne',
+          collection: command.collection,
+          filter: command.filter,
+          update: command.update,
+        };
+      case 'rawUpdateMany':
+        return {
+          kind: 'rawUpdateMany',
+          collection: command.collection,
+          filter: command.filter,
+          update: command.update,
+        };
+      case 'rawDeleteOne':
+        return { kind: 'rawDeleteOne', collection: command.collection, filter: command.filter };
+      case 'rawDeleteMany':
+        return { kind: 'rawDeleteMany', collection: command.collection, filter: command.filter };
+      case 'rawFindOneAndUpdate':
+        return {
+          kind: 'rawFindOneAndUpdate',
+          collection: command.collection,
+          filter: command.filter,
+          update: command.update,
+          upsert: command.upsert,
+          sort: command.sort,
+          returnDocument: command.returnDocument,
+        };
+      case 'rawFindOneAndDelete':
+        return {
+          kind: 'rawFindOneAndDelete',
+          collection: command.collection,
+          filter: command.filter,
+          sort: command.sort,
+        };
+      // v8 ignore next 4
+      default: {
+        const _exhaustive: never = command;
+        throw new Error(
+          `Unknown command kind: ${blindCast<{ kind: string }, 'exhaustive switch fallback for error message'>(_exhaustive).kind}`,
+        );
       }
     }
-    return result;
   }
 
-  async #lowerUpdate(
-    update: MongoUpdateSpec,
+  async resolveParams(
+    draft: MongoLoweredDraft,
     ctx: CodecCallContext,
-  ): Promise<Document | ReadonlyArray<Document>> {
-    if (isUpdatePipeline(update)) {
-      return Promise.all(update.map((stage) => lowerStage(stage, this.#codecs, ctx)));
-    }
-    return this.#resolveDocument(update, ctx);
-  }
-
-  async lower(plan: MongoQueryPlan, ctx: CodecCallContext): Promise<AnyMongoWireCommand> {
-    const { command } = plan;
-    switch (command.kind) {
+  ): Promise<AnyMongoWireCommand> {
+    switch (draft.kind) {
       case 'insertOne':
         return new InsertOneWireCommand(
-          command.collection,
-          await this.#resolveDocument(command.document, ctx),
+          draft.collection,
+          await resolveDraftDoc(draft.document, this.#codecs, ctx),
+        );
+      case 'insertMany':
+        return new InsertManyWireCommand(
+          draft.collection,
+          await Promise.all(draft.documents.map((doc) => resolveDraftDoc(doc, this.#codecs, ctx))),
         );
       case 'updateOne': {
         const [filter, update] = await Promise.all([
-          lowerFilter(command.filter, this.#codecs, ctx),
-          this.#lowerUpdate(command.update, ctx),
+          resolveDraftDoc(draft.filter, this.#codecs, ctx),
+          resolveUpdate(draft.update, this.#codecs, ctx),
         ]);
-        return new UpdateOneWireCommand(command.collection, filter, update, command.upsert);
+        return new UpdateOneWireCommand(draft.collection, filter, update, draft.upsert);
       }
-      case 'insertMany':
-        return new InsertManyWireCommand(
-          command.collection,
-          await Promise.all(command.documents.map((doc) => this.#resolveDocument(doc, ctx))),
-        );
       case 'updateMany': {
         const [filter, update] = await Promise.all([
-          lowerFilter(command.filter, this.#codecs, ctx),
-          this.#lowerUpdate(command.update, ctx),
+          resolveDraftDoc(draft.filter, this.#codecs, ctx),
+          resolveUpdate(draft.update, this.#codecs, ctx),
         ]);
-        return new UpdateManyWireCommand(command.collection, filter, update, command.upsert);
+        return new UpdateManyWireCommand(draft.collection, filter, update, draft.upsert);
       }
       case 'deleteOne':
         return new DeleteOneWireCommand(
-          command.collection,
-          await lowerFilter(command.filter, this.#codecs, ctx),
+          draft.collection,
+          await resolveDraftDoc(draft.filter, this.#codecs, ctx),
         );
       case 'deleteMany':
         return new DeleteManyWireCommand(
-          command.collection,
-          await lowerFilter(command.filter, this.#codecs, ctx),
+          draft.collection,
+          await resolveDraftDoc(draft.filter, this.#codecs, ctx),
         );
       case 'findOneAndUpdate': {
         const [filter, update] = await Promise.all([
-          lowerFilter(command.filter, this.#codecs, ctx),
-          this.#lowerUpdate(command.update, ctx),
+          resolveDraftDoc(draft.filter, this.#codecs, ctx),
+          resolveUpdate(draft.update, this.#codecs, ctx),
         ]);
         return new FindOneAndUpdateWireCommand(
-          command.collection,
+          draft.collection,
           filter,
           update,
-          command.upsert,
-          command.sort,
-          command.returnDocument,
+          draft.upsert,
+          draft.sort,
+          draft.returnDocument,
         );
       }
       case 'findOneAndDelete':
         return new FindOneAndDeleteWireCommand(
-          command.collection,
-          await lowerFilter(command.filter, this.#codecs, ctx),
-          command.sort,
+          draft.collection,
+          await resolveDraftDoc(draft.filter, this.#codecs, ctx),
+          draft.sort,
         );
       case 'aggregate':
         return new AggregateWireCommand(
-          command.collection,
-          await lowerPipeline(command.pipeline, this.#codecs, ctx),
+          draft.collection,
+          await Promise.all(
+            draft.pipeline.map((stage) => resolveDraftDoc(stage, this.#codecs, ctx)),
+          ),
         );
       case 'rawAggregate':
-        return new AggregateWireCommand(command.collection, command.pipeline);
+        return new AggregateWireCommand(draft.collection, draft.pipeline);
       case 'rawInsertOne':
-        return new InsertOneWireCommand(command.collection, command.document);
+        return new InsertOneWireCommand(draft.collection, draft.document);
       case 'rawInsertMany':
-        return new InsertManyWireCommand(command.collection, command.documents);
+        return new InsertManyWireCommand(draft.collection, draft.documents);
       case 'rawUpdateOne':
-        return new UpdateOneWireCommand(command.collection, command.filter, command.update);
+        return new UpdateOneWireCommand(draft.collection, draft.filter, draft.update);
       case 'rawUpdateMany':
-        return new UpdateManyWireCommand(command.collection, command.filter, command.update);
+        return new UpdateManyWireCommand(draft.collection, draft.filter, draft.update);
       case 'rawDeleteOne':
-        return new DeleteOneWireCommand(command.collection, command.filter);
+        return new DeleteOneWireCommand(draft.collection, draft.filter);
       case 'rawDeleteMany':
-        return new DeleteManyWireCommand(command.collection, command.filter);
+        return new DeleteManyWireCommand(draft.collection, draft.filter);
       case 'rawFindOneAndUpdate':
         return new FindOneAndUpdateWireCommand(
-          command.collection,
-          command.filter,
-          command.update,
-          command.upsert,
-          command.sort,
-          command.returnDocument,
+          draft.collection,
+          draft.filter,
+          draft.update,
+          draft.upsert,
+          draft.sort,
+          draft.returnDocument,
         );
       case 'rawFindOneAndDelete':
-        return new FindOneAndDeleteWireCommand(command.collection, command.filter, command.sort);
+        return new FindOneAndDeleteWireCommand(draft.collection, draft.filter, draft.sort);
       // v8 ignore next 4
       default: {
-        const _exhaustive: never = command;
-        throw new Error(`Unknown command kind: ${(_exhaustive as { kind: string }).kind}`);
+        const _exhaustive: never = draft;
+        throw new Error(
+          `Unknown draft kind: ${blindCast<{ kind: string }, 'exhaustive switch fallback for error message'>(_exhaustive).kind}`,
+        );
       }
     }
   }
+
+  lower(plan: MongoQueryPlan, ctx: CodecCallContext): Promise<AnyMongoWireCommand> {
+    return this.resolveParams(this.structuralLower(plan), ctx);
+  }
 }
 
 /**