@prisma/orm-target-mongo 0.16.0-dev.36

package/dist/mongo-adapter-BkVYI6jn-ChXldtpg.mjs

@@ -0,0 +1,807 @@
+import { t as buildStandardCodecRegistry } from "./codecs-DLWO-Cjc-CWfQj0bY.mjs";
+import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { keysToKeySpec } from "@prisma/orm-family-mongo/query-ast/control";
+import { isExprArray, isRecordArgs } from "@prisma/orm-family-mongo/query-ast/execution";
+import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
+import { checkAborted, raceAgainstAbort, runtimeError } from "@prisma/orm-framework/components/runtime";
+import { MongoParamRef } from "@prisma/orm-family-mongo/value";
+import { AggregateWireCommand, CollModWireCommand, CreateCollectionWireCommand, CreateIndexWireCommand, DeleteManyWireCommand, DeleteOneWireCommand, DropCollectionWireCommand, DropIndexWireCommand, FindOneAndDeleteWireCommand, FindOneAndUpdateWireCommand, InsertManyWireCommand, InsertOneWireCommand, UpdateManyWireCommand, UpdateOneWireCommand } from "@prisma/orm-family-mongo/wire";
+//#region ../../../3-mongo-target/2-mongo-adapter/dist/mongo-adapter-BkVYI6jn.mjs
+/**
+* Resolves a `MongoValue` (which may contain `MongoParamRef` leaves) into the
+* driver-ready wire shape. When a leaf has a `codecId` and the registry has a
+* codec for it, the codec's async `encode` is awaited so codecs may perform
+* asynchronous work (e.g. lookups, key derivations).
+*
+* Object/array nodes dispatch their child resolutions concurrently via
+* `Promise.all` so independent leaves encode in parallel.
+*
+* Codec encode failures are wrapped in a `RUNTIME.ENCODE_FAILED` envelope
+* (mirroring SQL's `wrapEncodeFailure` shape) with `{ label, codec }` details
+* and the original error attached on `cause`. A structured envelope (any error
+* with a dotted `code`, per `isStructuredError`) is re-thrown verbatim so
+* codec-raised envelopes and nested resolvers don't get double-wrapped.
+*
+* `ctx: CodecCallContext` is forwarded verbatim to every
+* `codec.encode(value, ctx)` call. The same `ctx` reference is also passed
+* to nested `resolveValue` invocations so codec authors observe **signal
+* identity** across the entire recursive walk for one `runtime.execute()`.
+*
+* Abort observation (only when `ctx.signal` is provided):
+*
+* - **Already-aborted at entry** — every recursive call pre-checks
+*   `ctx.signal.aborted` and short-circuits with
+*   `RUNTIME.ABORTED { phase: 'encode' }` before any codec is invoked.
+* - **Mid-flight abort** — each per-level `Promise.all` races against the
+*   signal via `raceAgainstAbort`. The runtime returns
+*   `RUNTIME.ABORTED { phase: 'encode' }` promptly even if codec bodies
+*   ignore the signal; in-flight bodies run to completion in the background
+*   (cooperative cancellation, see ADR 204).
+* - `RUNTIME.ENCODE_FAILED` envelopes thrown by a codec body before the
+*   runtime sees the abort pass through unchanged (AC-ERR4).
+*/
+async function resolveValue(value, codecs, ctx) {
+	checkAborted(ctx, "encode");
+	const signal = ctx.signal;
+	if (value instanceof MongoParamRef) {
+		if (value.codecId) {
+			const codec = codecs.get(value.codecId);
+			if (codec?.encode) try {
+				return await raceAgainstAbort(codec.encode(value.value, ctx), signal, "encode");
+			} catch (error) {
+				wrapEncodeFailure(error, value, codec.id);
+			}
+		}
+		return value.value;
+	}
+	if (value === null || typeof value !== "object") return value;
+	if (value instanceof Date) return value;
+	if (Array.isArray(value)) return raceAgainstAbort(Promise.all(value.map((v) => resolveValue(v, codecs, ctx))), signal, "encode");
+	const entries = Object.entries(value);
+	const resolved = await raceAgainstAbort(Promise.all(entries.map(([, val]) => resolveValue(val, codecs, ctx))), signal, "encode");
+	const result = {};
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		if (entry) result[entry[0]] = resolved[i];
+	}
+	return result;
+}
+/**
+* Resolves a draft slot value — which may be `MongoParamRef`, a primitive, a
+* nested plain-object, or an array — into the corresponding wire value.
+* Mirrors `resolveValue`'s traversal strategy but accepts `unknown` so it can
+* handle pipeline stage documents whose field types cannot be narrowed to
+* `MongoValue` statically (e.g. `$geoNear.near: unknown`).
+*/
+async function resolveDraftSlot(value, codecs, ctx) {
+	if (value instanceof MongoParamRef) return resolveValue(value, codecs, ctx);
+	if (value === null || typeof value !== "object") return value;
+	if (value instanceof Date) return value;
+	if (Array.isArray(value)) return raceAgainstAbort(Promise.all(value.map((v) => resolveDraftSlot(v, codecs, ctx))), ctx.signal, "encode");
+	return resolveDraftDoc(blindCast(value), codecs, ctx);
+}
+/**
+* Resolves a pipeline stage draft document by walking every entry and
+* forwarding to {@link resolveDraftSlot}. Used by `MongoAdapterImpl.resolveParams`
+* for aggregate pipeline stages, which carry `unknown`-typed fields (e.g.
+* `$geoNear.near`) alongside filter sub-documents that may contain
+* `MongoParamRef` leaves.
+*/
+async function resolveDraftDoc(doc, codecs, ctx) {
+	checkAborted(ctx, "encode");
+	const entries = Object.entries(doc);
+	const resolved = await raceAgainstAbort(Promise.all(entries.map(([, val]) => resolveDraftSlot(val, codecs, ctx))), ctx.signal, "encode");
+	const result = {};
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		if (entry) result[entry[0]] = resolved[i];
+	}
+	return result;
+}
+function paramRefLabel(ref, codecId) {
+	return ref.name ?? codecId;
+}
+function wrapEncodeFailure(error, ref, codecId) {
+	if (isStructuredError(error)) throw error;
+	const label = paramRefLabel(ref, codecId);
+	const wrapped = runtimeError("RUNTIME.ENCODE_FAILED", `Failed to encode parameter ${label} with codec '${codecId}': ${error instanceof Error ? error.message : String(error)}`, {
+		label,
+		codec: codecId
+	});
+	wrapped.cause = error;
+	throw wrapped;
+}
+const THEN_KEY = "then";
+function condBranch(caseOrIf, thenExpr, elseExpr) {
+	const entries = [[elseExpr ? "if" : "case", lowerAggExpr(caseOrIf)], [THEN_KEY, lowerAggExpr(thenExpr)]];
+	if (elseExpr) entries.push(["else", lowerAggExpr(elseExpr)]);
+	return Object.fromEntries(entries);
+}
+const aggExprLoweringVisitor = {
+	fieldRef(expr) {
+		return `$${expr.path}`;
+	},
+	literal(expr) {
+		return needsLiteralWrap(expr.value) ? { $literal: expr.value } : expr.value;
+	},
+	operator(expr) {
+		const { args } = expr;
+		let loweredArgs;
+		if (isExprArray(args)) loweredArgs = args.map((a) => lowerAggExpr(a));
+		else if (isRecordArgs(args)) loweredArgs = lowerExprRecord(args);
+		else loweredArgs = lowerAggExpr(args);
+		return { [expr.op]: loweredArgs };
+	},
+	accumulator(expr) {
+		if (expr.arg === null) return { [expr.op]: {} };
+		if (isRecordArgs(expr.arg)) return { [expr.op]: lowerExprRecord(expr.arg) };
+		return { [expr.op]: lowerAggExpr(expr.arg) };
+	},
+	cond(expr) {
+		return { $cond: condBranch(expr.condition, expr.then_, expr.else_) };
+	},
+	switch_(expr) {
+		return { $switch: {
+			branches: expr.branches.map((b) => condBranch(b.case_, b.then_)),
+			default: lowerAggExpr(expr.default_)
+		} };
+	},
+	filter(expr) {
+		return { $filter: {
+			input: lowerAggExpr(expr.input),
+			cond: lowerAggExpr(expr.cond),
+			as: expr.as
+		} };
+	},
+	map(expr) {
+		return { $map: {
+			input: lowerAggExpr(expr.input),
+			in: lowerAggExpr(expr.in_),
+			as: expr.as
+		} };
+	},
+	reduce(expr) {
+		return { $reduce: {
+			input: lowerAggExpr(expr.input),
+			initialValue: lowerAggExpr(expr.initialValue),
+			in: lowerAggExpr(expr.in_)
+		} };
+	},
+	let_(expr) {
+		const vars = {};
+		for (const [key, val] of Object.entries(expr.vars)) vars[key] = lowerAggExpr(val);
+		return { $let: {
+			vars,
+			in: lowerAggExpr(expr.in_)
+		} };
+	},
+	mergeObjects(expr) {
+		return { $mergeObjects: expr.exprs.map((e) => lowerAggExpr(e)) };
+	}
+};
+function needsLiteralWrap(value) {
+	if (typeof value === "string" && value.startsWith("$")) return true;
+	if (Array.isArray(value)) return value.some((v) => needsLiteralWrap(v));
+	if (value !== null && typeof value === "object") return Object.entries(value).some(([k, v]) => k.startsWith("$") || needsLiteralWrap(v));
+	return false;
+}
+function lowerAggExpr(expr) {
+	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.
+*/
+function structuralLowerFilter(filter) {
+	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 = filter;
+			return assertNever(_exhaustive, `Unhandled filter kind: ${blindCast(_exhaustive).kind}`);
+		}
+	}
+}
+async function lowerFilter(filter, codecs, ctx) {
+	switch (filter.kind) {
+		case "field": return { [filter.field]: { [filter.op]: await resolveValue(filter.value, codecs, ctx) } };
+		case "and": return { $and: await Promise.all(filter.exprs.map((e) => lowerFilter(e, codecs, ctx))) };
+		case "or": return { $or: await Promise.all(filter.exprs.map((e) => lowerFilter(e, codecs, ctx))) };
+		case "not": return { $nor: [await lowerFilter(filter.expr, codecs, ctx)] };
+		case "exists": return { [filter.field]: { $exists: filter.exists } };
+		case "expr": return { $expr: lowerAggExpr(filter.aggExpr) };
+		default: {
+			const _exhaustive = filter;
+			return assertNever(_exhaustive, `Unhandled filter kind: ${blindCast(_exhaustive).kind}`);
+		}
+	}
+}
+function isAggExprNode(value) {
+	return "accept" in value && typeof value.accept === "function";
+}
+function isAggExprArray(val) {
+	return Array.isArray(val);
+}
+function lowerGroupId(groupId) {
+	if (groupId === null) return null;
+	if (isAggExprNode(groupId)) return lowerAggExpr(groupId);
+	return lowerExprRecord(groupId);
+}
+function lowerExprRecord(fields) {
+	const result = {};
+	for (const [key, val] of Object.entries(fields)) if (isAggExprArray(val)) result[key] = val.map((v) => lowerAggExpr(v));
+	else result[key] = lowerAggExpr(val);
+	return result;
+}
+function lowerProjectionValue(value) {
+	if (typeof value === "number") return value;
+	return lowerAggExpr(value);
+}
+function lowerWindowField(wf) {
+	const lowered = lowerAggExpr(wf.operator);
+	if (typeof lowered !== "object" || lowered === null) throw new InternalError("Window field operator must lower to an object");
+	const result = { ...lowered };
+	if (wf.window) result["window"] = { ...wf.window };
+	return result;
+}
+async function lowerStage(stage, codecs, ctx) {
+	switch (stage.kind) {
+		case "match": return { $match: await lowerFilter(stage.filter, codecs, ctx) };
+		case "project": {
+			const projection = {};
+			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 = {
+				from: stage.from,
+				as: stage.as
+			};
+			if (stage.localField !== void 0) lookup["localField"] = stage.localField;
+			if (stage.foreignField !== void 0) lookup["foreignField"] = stage.foreignField;
+			if (stage.pipeline) lookup["pipeline"] = await Promise.all(stage.pipeline.map((s) => lowerStage(s, codecs, ctx)));
+			if (stage.let_) lookup["let"] = lowerExprRecord(stage.let_);
+			return { $lookup: lookup };
+		}
+		case "unwind": {
+			const unwind = {
+				path: stage.path,
+				preserveNullAndEmptyArrays: stage.preserveNullAndEmptyArrays
+			};
+			if (stage.includeArrayIndex !== void 0) unwind["includeArrayIndex"] = stage.includeArrayIndex;
+			return { $unwind: unwind };
+		}
+		case "group": {
+			const group = { _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 = { coll: stage.collection };
+			if (stage.pipeline) unionWith["pipeline"] = await Promise.all(stage.pipeline.map((s) => lowerStage(s, codecs, ctx)));
+			return { $unionWith: unionWith };
+		}
+		case "bucket": {
+			const bucket = {
+				groupBy: lowerAggExpr(stage.groupBy),
+				boundaries: [...stage.boundaries]
+			};
+			if (stage.default_ !== void 0) bucket["default"] = stage.default_;
+			if (stage.output) bucket["output"] = lowerExprRecord(stage.output);
+			return { $bucket: bucket };
+		}
+		case "bucketAuto": {
+			const bucketAuto = {
+				groupBy: lowerAggExpr(stage.groupBy),
+				buckets: stage.buckets
+			};
+			if (stage.output) bucketAuto["output"] = lowerExprRecord(stage.output);
+			if (stage.granularity !== void 0) bucketAuto["granularity"] = stage.granularity;
+			return { $bucketAuto: bucketAuto };
+		}
+		case "geoNear": {
+			const geoNear = {
+				near: stage.near,
+				distanceField: stage.distanceField
+			};
+			if (stage.spherical !== void 0) geoNear["spherical"] = stage.spherical;
+			if (stage.maxDistance !== void 0) geoNear["maxDistance"] = stage.maxDistance;
+			if (stage.minDistance !== void 0) geoNear["minDistance"] = stage.minDistance;
+			if (stage.query) geoNear["query"] = await lowerFilter(stage.query, codecs, ctx);
+			if (stage.key !== void 0) geoNear["key"] = stage.key;
+			if (stage.distanceMultiplier !== void 0) geoNear["distanceMultiplier"] = stage.distanceMultiplier;
+			if (stage.includeLocs !== void 0) geoNear["includeLocs"] = stage.includeLocs;
+			return { $geoNear: geoNear };
+		}
+		case "facet": {
+			const facetEntries = Object.entries(stage.facets);
+			const facetPipelines = await Promise.all(facetEntries.map(([, pipeline]) => Promise.all(pipeline.map((s) => lowerStage(s, codecs, ctx)))));
+			const facet = {};
+			for (let i = 0; i < facetEntries.length; i++) {
+				const entry = facetEntries[i];
+				if (entry) facet[entry[0]] = facetPipelines[i];
+			}
+			return { $facet: facet };
+		}
+		case "graphLookup": {
+			const graphLookup = {
+				from: stage.from,
+				startWith: lowerAggExpr(stage.startWith),
+				connectFromField: stage.connectFromField,
+				connectToField: stage.connectToField,
+				as: stage.as
+			};
+			if (stage.maxDepth !== void 0) graphLookup["maxDepth"] = stage.maxDepth;
+			if (stage.depthField !== void 0) graphLookup["depthField"] = stage.depthField;
+			if (stage.restrictSearchWithMatch) graphLookup["restrictSearchWithMatch"] = await lowerFilter(stage.restrictSearchWithMatch, codecs, ctx);
+			return { $graphLookup: graphLookup };
+		}
+		case "merge": {
+			const merge = { into: stage.into };
+			if (stage.on !== void 0) merge["on"] = stage.on;
+			if (stage.whenMatched !== void 0) merge["whenMatched"] = Array.isArray(stage.whenMatched) ? await Promise.all(stage.whenMatched.map((s) => lowerStage(s, codecs, ctx))) : stage.whenMatched;
+			if (stage.whenNotMatched !== void 0) merge["whenNotMatched"] = stage.whenNotMatched;
+			return { $merge: merge };
+		}
+		case "setWindowFields": {
+			const swf = {};
+			if (stage.partitionBy) swf["partitionBy"] = lowerAggExpr(stage.partitionBy);
+			if (stage.sortBy) swf["sortBy"] = { ...stage.sortBy };
+			const output = {};
+			for (const [key, wf] of Object.entries(stage.output)) output[key] = lowerWindowField(wf);
+			swf["output"] = output;
+			return { $setWindowFields: swf };
+		}
+		case "densify": {
+			const densify = {
+				field: stage.field,
+				range: { ...stage.range }
+			};
+			if (stage.partitionByFields) densify["partitionByFields"] = [...stage.partitionByFields];
+			return { $densify: densify };
+		}
+		case "fill": {
+			const fill = {};
+			if (stage.partitionBy) fill["partitionBy"] = lowerAggExpr(stage.partitionBy);
+			if (stage.partitionByFields) fill["partitionByFields"] = [...stage.partitionByFields];
+			if (stage.sortBy) fill["sortBy"] = { ...stage.sortBy };
+			const output = {};
+			for (const [key, fo] of Object.entries(stage.output)) {
+				const entry = {};
+				if (fo.method !== void 0) entry["method"] = fo.method;
+				if (fo.value !== void 0) entry["value"] = lowerAggExpr(fo.value);
+				output[key] = entry;
+			}
+			fill["output"] = output;
+			return { $fill: fill };
+		}
+		case "search": {
+			const search = { ...stage.config };
+			if (stage.index !== void 0) search["index"] = stage.index;
+			return { $search: search };
+		}
+		case "searchMeta": {
+			const searchMeta = { ...stage.config };
+			if (stage.index !== void 0) searchMeta["index"] = stage.index;
+			return { $searchMeta: searchMeta };
+		}
+		case "vectorSearch": {
+			const vs = {
+				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 = stage;
+			return assertNever(_exhaustive, `Unhandled stage kind: ${blindCast(_exhaustive).kind}`);
+		}
+	}
+}
+async function lowerPipeline(stages, codecs, ctx) {
+	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.
+*/
+function structuralLowerStage(stage) {
+	switch (stage.kind) {
+		case "match": return { $match: structuralLowerFilter(stage.filter) };
+		case "project": {
+			const projection = {};
+			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 = {
+				from: stage.from,
+				as: stage.as
+			};
+			if (stage.localField !== void 0) lookup["localField"] = stage.localField;
+			if (stage.foreignField !== void 0) 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 = {
+				path: stage.path,
+				preserveNullAndEmptyArrays: stage.preserveNullAndEmptyArrays
+			};
+			if (stage.includeArrayIndex !== void 0) unwind["includeArrayIndex"] = stage.includeArrayIndex;
+			return { $unwind: unwind };
+		}
+		case "group": {
+			const group = { _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 = { coll: stage.collection };
+			if (stage.pipeline) unionWith["pipeline"] = structuralLowerPipeline(stage.pipeline);
+			return { $unionWith: unionWith };
+		}
+		case "bucket": {
+			const bucket = {
+				groupBy: lowerAggExpr(stage.groupBy),
+				boundaries: [...stage.boundaries]
+			};
+			if (stage.default_ !== void 0) bucket["default"] = stage.default_;
+			if (stage.output) bucket["output"] = lowerExprRecord(stage.output);
+			return { $bucket: bucket };
+		}
+		case "bucketAuto": {
+			const bucketAuto = {
+				groupBy: lowerAggExpr(stage.groupBy),
+				buckets: stage.buckets
+			};
+			if (stage.output) bucketAuto["output"] = lowerExprRecord(stage.output);
+			if (stage.granularity !== void 0) bucketAuto["granularity"] = stage.granularity;
+			return { $bucketAuto: bucketAuto };
+		}
+		case "geoNear": {
+			const geoNear = {
+				near: stage.near,
+				distanceField: stage.distanceField
+			};
+			if (stage.spherical !== void 0) geoNear["spherical"] = stage.spherical;
+			if (stage.maxDistance !== void 0) geoNear["maxDistance"] = stage.maxDistance;
+			if (stage.minDistance !== void 0) geoNear["minDistance"] = stage.minDistance;
+			if (stage.query) geoNear["query"] = structuralLowerFilter(stage.query);
+			if (stage.key !== void 0) geoNear["key"] = stage.key;
+			if (stage.distanceMultiplier !== void 0) geoNear["distanceMultiplier"] = stage.distanceMultiplier;
+			if (stage.includeLocs !== void 0) geoNear["includeLocs"] = stage.includeLocs;
+			return { $geoNear: geoNear };
+		}
+		case "facet": {
+			const facet = {};
+			for (const [key, pipeline] of Object.entries(stage.facets)) facet[key] = structuralLowerPipeline(pipeline);
+			return { $facet: facet };
+		}
+		case "graphLookup": {
+			const graphLookup = {
+				from: stage.from,
+				startWith: lowerAggExpr(stage.startWith),
+				connectFromField: stage.connectFromField,
+				connectToField: stage.connectToField,
+				as: stage.as
+			};
+			if (stage.maxDepth !== void 0) graphLookup["maxDepth"] = stage.maxDepth;
+			if (stage.depthField !== void 0) graphLookup["depthField"] = stage.depthField;
+			if (stage.restrictSearchWithMatch) graphLookup["restrictSearchWithMatch"] = structuralLowerFilter(stage.restrictSearchWithMatch);
+			return { $graphLookup: graphLookup };
+		}
+		case "merge": {
+			const merge = { into: stage.into };
+			if (stage.on !== void 0) merge["on"] = stage.on;
+			if (stage.whenMatched !== void 0) merge["whenMatched"] = Array.isArray(stage.whenMatched) ? structuralLowerPipeline(stage.whenMatched) : stage.whenMatched;
+			if (stage.whenNotMatched !== void 0) merge["whenNotMatched"] = stage.whenNotMatched;
+			return { $merge: merge };
+		}
+		case "setWindowFields": {
+			const swf = {};
+			if (stage.partitionBy) swf["partitionBy"] = lowerAggExpr(stage.partitionBy);
+			if (stage.sortBy) swf["sortBy"] = { ...stage.sortBy };
+			const output = {};
+			for (const [key, wf] of Object.entries(stage.output)) output[key] = lowerWindowField(wf);
+			swf["output"] = output;
+			return { $setWindowFields: swf };
+		}
+		case "densify": {
+			const densify = {
+				field: stage.field,
+				range: { ...stage.range }
+			};
+			if (stage.partitionByFields) densify["partitionByFields"] = [...stage.partitionByFields];
+			return { $densify: densify };
+		}
+		case "fill": {
+			const fill = {};
+			if (stage.partitionBy) fill["partitionBy"] = lowerAggExpr(stage.partitionBy);
+			if (stage.partitionByFields) fill["partitionByFields"] = [...stage.partitionByFields];
+			if (stage.sortBy) fill["sortBy"] = { ...stage.sortBy };
+			const output = {};
+			for (const [key, fo] of Object.entries(stage.output)) {
+				const entry = {};
+				if (fo.method !== void 0) entry["method"] = fo.method;
+				if (fo.value !== void 0) entry["value"] = lowerAggExpr(fo.value);
+				output[key] = entry;
+			}
+			fill["output"] = output;
+			return { $fill: fill };
+		}
+		case "search": {
+			const search = { ...stage.config };
+			if (stage.index !== void 0) search["index"] = stage.index;
+			return { $search: search };
+		}
+		case "searchMeta": {
+			const searchMeta = { ...stage.config };
+			if (stage.index !== void 0) searchMeta["index"] = stage.index;
+			return { $searchMeta: searchMeta };
+		}
+		case "vectorSearch": {
+			const vs = {
+				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 = stage;
+			return assertNever(_exhaustive, `Unhandled stage kind: ${blindCast(_exhaustive).kind}`);
+		}
+	}
+}
+function structuralLowerPipeline(stages) {
+	return stages.map((s) => structuralLowerStage(s));
+}
+function isUpdatePipeline(update) {
+	return Array.isArray(update);
+}
+function isDraftUpdatePipeline(update) {
+	return Array.isArray(update);
+}
+async function resolveUpdate(update, codecs, ctx) {
+	if (isDraftUpdatePipeline(update)) return Promise.all(update.map((stage) => resolveDraftDoc(stage, codecs, ctx)));
+	return resolveDraftDoc(update, codecs, ctx);
+}
+function lowerDdlCommand(command) {
+	switch (command.kind) {
+		case "createCollection": return new CreateCollectionWireCommand(command.collection, command);
+		case "createIndex": return new CreateIndexWireCommand(command.collection, keysToKeySpec(command.keys), command);
+		case "dropCollection": return new DropCollectionWireCommand(command.collection);
+		case "dropIndex": return new DropIndexWireCommand(command.collection, command.name);
+		case "collMod": return new CollModWireCommand(command.collection, command);
+		// v8 ignore next 4
+		default: {
+			const _exhaustive = command;
+			return assertNever(_exhaustive, `Unknown DDL command kind: ${blindCast(_exhaustive).kind}`);
+		}
+	}
+}
+var MongoAdapterImpl = class {
+	#codecs;
+	constructor(codecs) {
+		this.#codecs = codecs;
+	}
+	structuralLower(plan) {
+		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 = command;
+				return assertNever(_exhaustive, `Unknown command kind: ${blindCast(_exhaustive).kind}`);
+			}
+		}
+	}
+	async resolveParams(draft, ctx) {
+		switch (draft.kind) {
+			case "insertOne": return new InsertOneWireCommand(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([resolveDraftDoc(draft.filter, this.#codecs, ctx), resolveUpdate(draft.update, this.#codecs, ctx)]);
+				return new UpdateOneWireCommand(draft.collection, filter, update, draft.upsert);
+			}
+			case "updateMany": {
+				const [filter, update] = await Promise.all([resolveDraftDoc(draft.filter, this.#codecs, ctx), resolveUpdate(draft.update, this.#codecs, ctx)]);
+				return new UpdateManyWireCommand(draft.collection, filter, update, draft.upsert);
+			}
+			case "deleteOne": return new DeleteOneWireCommand(draft.collection, await resolveDraftDoc(draft.filter, this.#codecs, ctx));
+			case "deleteMany": return new DeleteManyWireCommand(draft.collection, await resolveDraftDoc(draft.filter, this.#codecs, ctx));
+			case "findOneAndUpdate": {
+				const [filter, update] = await Promise.all([resolveDraftDoc(draft.filter, this.#codecs, ctx), resolveUpdate(draft.update, this.#codecs, ctx)]);
+				return new FindOneAndUpdateWireCommand(draft.collection, filter, update, draft.upsert, draft.sort, draft.returnDocument);
+			}
+			case "findOneAndDelete": return new FindOneAndDeleteWireCommand(draft.collection, await resolveDraftDoc(draft.filter, this.#codecs, ctx), draft.sort);
+			case "aggregate": return new AggregateWireCommand(draft.collection, await Promise.all(draft.pipeline.map((stage) => resolveDraftDoc(stage, this.#codecs, ctx))));
+			case "rawAggregate": return new AggregateWireCommand(draft.collection, draft.pipeline);
+			case "rawInsertOne": return new InsertOneWireCommand(draft.collection, draft.document);
+			case "rawInsertMany": return new InsertManyWireCommand(draft.collection, draft.documents);
+			case "rawUpdateOne": return new UpdateOneWireCommand(draft.collection, draft.filter, draft.update);
+			case "rawUpdateMany": return new UpdateManyWireCommand(draft.collection, draft.filter, draft.update);
+			case "rawDeleteOne": return new DeleteOneWireCommand(draft.collection, draft.filter);
+			case "rawDeleteMany": return new DeleteManyWireCommand(draft.collection, draft.filter);
+			case "rawFindOneAndUpdate": return new FindOneAndUpdateWireCommand(draft.collection, draft.filter, draft.update, draft.upsert, draft.sort, draft.returnDocument);
+			case "rawFindOneAndDelete": return new FindOneAndDeleteWireCommand(draft.collection, draft.filter, draft.sort);
+			// v8 ignore next 4
+			default: {
+				const _exhaustive = draft;
+				return assertNever(_exhaustive, `Unknown draft kind: ${blindCast(_exhaustive).kind}`);
+			}
+		}
+	}
+	lower(plan, ctx) {
+		if ("collection" in plan) return this.resolveParams(this.structuralLower(plan), ctx);
+		return Promise.resolve(lowerDdlCommand(plan.command));
+	}
+};
+/**
+* Construct a Mongo adapter with the standard wire-type codecs registered
+* for encode-side dispatch (`MongoParamRef.codecId` lookups).
+*
+* The runtime-side codec registry the runtime decodes against is composed
+* separately by `createMongoExecutionContext`. This factory exists for
+* direct adapter use (the runtime descriptor's `create(stack)` calls
+* through it). User code should compose a stack/context instead.
+*/
+function createMongoAdapter() {
+	return new MongoAdapterImpl(buildStandardCodecRegistry());
+}
+//#endregion
+export { lowerStage as a, lowerPipeline as i, lowerAggExpr as n, lowerFilter as r, createMongoAdapter as t };
+
+//# sourceMappingURL=mongo-adapter-BkVYI6jn-ChXldtpg.mjs.map