@prisma-next/adapter-mongo 0.3.0-dev.135 → 0.3.0-dev.147

package/dist/codec-ids-FBmJhfq-.mjs

@@ -0,0 +1,12 @@
+//#region src/core/codec-ids.ts
+const MONGO_OBJECTID_CODEC_ID = "mongo/objectId@1";
+const MONGO_STRING_CODEC_ID = "mongo/string@1";
+const MONGO_DOUBLE_CODEC_ID = "mongo/double@1";
+const MONGO_INT32_CODEC_ID = "mongo/int32@1";
+const MONGO_BOOLEAN_CODEC_ID = "mongo/bool@1";
+const MONGO_DATE_CODEC_ID = "mongo/date@1";
+const MONGO_VECTOR_CODEC_ID = "mongo/vector@1";
+
+//#endregion
+export { MONGO_OBJECTID_CODEC_ID as a, MONGO_INT32_CODEC_ID as i, MONGO_DATE_CODEC_ID as n, MONGO_STRING_CODEC_ID as o, MONGO_DOUBLE_CODEC_ID as r, MONGO_VECTOR_CODEC_ID as s, MONGO_BOOLEAN_CODEC_ID as t };
+//# sourceMappingURL=codec-ids-FBmJhfq-.mjs.map

package/dist/codec-ids-FBmJhfq-.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-ids-FBmJhfq-.mjs","names":[],"sources":["../src/core/codec-ids.ts"],"sourcesContent":["export const MONGO_OBJECTID_CODEC_ID = 'mongo/objectId@1' as const;\nexport const MONGO_STRING_CODEC_ID = 'mongo/string@1' as const;\nexport const MONGO_DOUBLE_CODEC_ID = 'mongo/double@1' as const;\nexport const MONGO_INT32_CODEC_ID = 'mongo/int32@1' as const;\nexport const MONGO_BOOLEAN_CODEC_ID = 'mongo/bool@1' as const;\nexport const MONGO_DATE_CODEC_ID = 'mongo/date@1' as const;\nexport const MONGO_VECTOR_CODEC_ID = 'mongo/vector@1' as const;\n"],"mappings":";AAAA,MAAa,0BAA0B;AACvC,MAAa,wBAAwB;AACrC,MAAa,wBAAwB;AACrC,MAAa,uBAAuB;AACpC,MAAa,yBAAyB;AACtC,MAAa,sBAAsB;AACnC,MAAa,wBAAwB"}

package/dist/codec-types.d.mts

@@ -1,4 +1,7 @@
 //#region src/exports/codec-types.d.ts
+type Vector<N extends number = number> = readonly number[] & {
+  readonly __vectorLength?: N;
+};
 type CodecTypes = {
   readonly 'mongo/objectId@1': {
     readonly input: string;
@@ -8,6 +11,10 @@ type CodecTypes = {
     readonly input: string;
     readonly output: string;
   };
+  readonly 'mongo/double@1': {
+    readonly input: number;
+    readonly output: number;
+  };
   readonly 'mongo/int32@1': {
     readonly input: number;
     readonly output: number;
@@ -20,7 +27,11 @@ type CodecTypes = {
     readonly input: Date;
     readonly output: Date;
   };
+  readonly 'mongo/vector@1': {
+    readonly input: readonly number[];
+    readonly output: readonly number[];
+  };
 };
 //#endregion
-export { CodecTypes };
+export { CodecTypes, Vector };
 //# sourceMappingURL=codec-types.d.mts.map

package/dist/codec-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"codec-types.d.mts","names":[],"sources":["../src/exports/codec-types.ts"],"sourcesContent":[],"mappings":";KAAY,UAAA;EAAA,SAAA,kBAKiC,EAAA;;;;;;;;;;;;;;;;;oBAAA;qBAAuB"}
+{"version":3,"file":"codec-types.d.mts","names":[],"sources":["../src/exports/codec-types.ts"],"sourcesContent":[],"mappings":";KAAY;EAAA,SAAM,cACW,CAAA,EAAD,CAAC;AAG7B,CAAA;KAAY,UAAA;;;;;;;;;;;;;;;;;;;;;;oBAMiC;qBAAuB"}

package/dist/control.d.mts

@@ -0,0 +1,7 @@
+import { ControlAdapterDescriptor } from "@prisma-next/framework-components/control";
+
+//#region src/exports/control.d.ts
+declare const mongoAdapterDescriptor: ControlAdapterDescriptor<'mongo', 'mongo'>;
+//#endregion
+export { mongoAdapterDescriptor as default };
+//# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"sourcesContent":[],"mappings":";;;cAWM,wBAAwB"}

package/dist/control.mjs

@@ -0,0 +1,114 @@
+import { a as MONGO_OBJECTID_CODEC_ID, i as MONGO_INT32_CODEC_ID, n as MONGO_DATE_CODEC_ID, o as MONGO_STRING_CODEC_ID, r as MONGO_DOUBLE_CODEC_ID, s as MONGO_VECTOR_CODEC_ID, t as MONGO_BOOLEAN_CODEC_ID } from "./codec-ids-FBmJhfq-.mjs";
+import { mongoCodec } from "@prisma-next/mongo-codec";
+import { ObjectId } from "mongodb";
+
+//#region src/core/codecs.ts
+const mongoObjectIdCodec = mongoCodec({
+	typeId: MONGO_OBJECTID_CODEC_ID,
+	targetTypes: ["objectId"],
+	traits: ["equality"],
+	decode: (wire) => wire.toHexString(),
+	encode: (value) => new ObjectId(value)
+});
+const mongoStringCodec = mongoCodec({
+	typeId: MONGO_STRING_CODEC_ID,
+	targetTypes: ["string"],
+	traits: [
+		"equality",
+		"order",
+		"textual"
+	],
+	decode: (wire) => wire,
+	encode: (value) => value
+});
+const mongoDoubleCodec = mongoCodec({
+	typeId: MONGO_DOUBLE_CODEC_ID,
+	targetTypes: ["float"],
+	traits: [
+		"equality",
+		"order",
+		"numeric"
+	],
+	decode: (wire) => wire,
+	encode: (value) => value
+});
+const mongoInt32Codec = mongoCodec({
+	typeId: MONGO_INT32_CODEC_ID,
+	targetTypes: ["int"],
+	traits: [
+		"equality",
+		"order",
+		"numeric"
+	],
+	decode: (wire) => wire,
+	encode: (value) => value
+});
+const mongoBooleanCodec = mongoCodec({
+	typeId: MONGO_BOOLEAN_CODEC_ID,
+	targetTypes: ["bool"],
+	traits: ["equality", "boolean"],
+	decode: (wire) => wire,
+	encode: (value) => value
+});
+const mongoDateCodec = mongoCodec({
+	typeId: MONGO_DATE_CODEC_ID,
+	targetTypes: ["date"],
+	traits: ["equality", "order"],
+	decode: (wire) => wire,
+	encode: (value) => value
+});
+const mongoVectorCodec = mongoCodec({
+	typeId: MONGO_VECTOR_CODEC_ID,
+	targetTypes: ["vector"],
+	traits: ["equality"],
+	decode: (wire) => wire,
+	encode: (value) => value,
+	renderOutputType: (typeParams) => {
+		const length = typeParams["length"];
+		if (length === void 0) return void 0;
+		if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error("renderOutputType: expected positive integer \"length\" for Vector");
+		return `Vector<${length}>`;
+	}
+});
+
+//#endregion
+//#region src/exports/control.ts
+const mongoAdapterDescriptor = {
+	kind: "adapter",
+	id: "mongo",
+	familyId: "mongo",
+	targetId: "mongo",
+	version: "0.0.1",
+	types: { codecTypes: {
+		codecInstances: [
+			mongoObjectIdCodec,
+			mongoStringCodec,
+			mongoDoubleCodec,
+			mongoInt32Codec,
+			mongoBooleanCodec,
+			mongoDateCodec,
+			mongoVectorCodec
+		],
+		import: {
+			package: "@prisma-next/adapter-mongo/codec-types",
+			named: "CodecTypes",
+			alias: "MongoCodecTypes"
+		},
+		typeImports: [{
+			package: "@prisma-next/adapter-mongo/codec-types",
+			named: "Vector",
+			alias: "Vector"
+		}]
+	} },
+	create() {
+		return {
+			familyId: "mongo",
+			targetId: "mongo"
+		};
+	}
+};
+var control_default = mongoAdapterDescriptor;
+
+//#endregion
+export { control_default as default };
+//# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.mjs","names":["mongoAdapterDescriptor: ControlAdapterDescriptor<'mongo', 'mongo'>"],"sources":["../src/core/codecs.ts","../src/exports/control.ts"],"sourcesContent":["import { mongoCodec } from '@prisma-next/mongo-codec';\nimport { ObjectId } from 'mongodb';\nimport {\n  MONGO_BOOLEAN_CODEC_ID,\n  MONGO_DATE_CODEC_ID,\n  MONGO_DOUBLE_CODEC_ID,\n  MONGO_INT32_CODEC_ID,\n  MONGO_OBJECTID_CODEC_ID,\n  MONGO_STRING_CODEC_ID,\n  MONGO_VECTOR_CODEC_ID,\n} from './codec-ids';\n\nexport const mongoObjectIdCodec = mongoCodec({\n  typeId: MONGO_OBJECTID_CODEC_ID,\n  targetTypes: ['objectId'],\n  traits: ['equality'],\n  decode: (wire: ObjectId) => wire.toHexString(),\n  encode: (value: string) => new ObjectId(value),\n});\n\nexport const mongoStringCodec = mongoCodec({\n  typeId: MONGO_STRING_CODEC_ID,\n  targetTypes: ['string'],\n  traits: ['equality', 'order', 'textual'],\n  decode: (wire: string) => wire,\n  encode: (value: string) => value,\n});\n\nexport const mongoDoubleCodec = mongoCodec({\n  typeId: MONGO_DOUBLE_CODEC_ID,\n  targetTypes: ['float'],\n  traits: ['equality', 'order', 'numeric'],\n  decode: (wire: number) => wire,\n  encode: (value: number) => value,\n});\n\nexport const mongoInt32Codec = mongoCodec({\n  typeId: MONGO_INT32_CODEC_ID,\n  targetTypes: ['int'],\n  traits: ['equality', 'order', 'numeric'],\n  decode: (wire: number) => wire,\n  encode: (value: number) => value,\n});\n\nexport const mongoBooleanCodec = mongoCodec({\n  typeId: MONGO_BOOLEAN_CODEC_ID,\n  targetTypes: ['bool'],\n  traits: ['equality', 'boolean'],\n  decode: (wire: boolean) => wire,\n  encode: (value: boolean) => value,\n});\n\nexport const mongoDateCodec = mongoCodec({\n  typeId: MONGO_DATE_CODEC_ID,\n  targetTypes: ['date'],\n  traits: ['equality', 'order'],\n  decode: (wire: Date) => wire,\n  encode: (value: Date) => value,\n});\n\nexport const mongoVectorCodec = mongoCodec({\n  typeId: MONGO_VECTOR_CODEC_ID,\n  targetTypes: ['vector'],\n  traits: ['equality'],\n  decode: (wire: readonly number[]) => wire,\n  encode: (value: readonly number[]) => value,\n  renderOutputType: (typeParams) => {\n    const length = typeParams['length'];\n    if (length === undefined) return undefined;\n    if (typeof length !== 'number' || !Number.isFinite(length) || !Number.isInteger(length)) {\n      throw new Error('renderOutputType: expected positive integer \"length\" for Vector');\n    }\n    return `Vector<${length}>`;\n  },\n});\n","import type { ControlAdapterDescriptor } from '@prisma-next/framework-components/control';\nimport {\n  mongoBooleanCodec,\n  mongoDateCodec,\n  mongoDoubleCodec,\n  mongoInt32Codec,\n  mongoObjectIdCodec,\n  mongoStringCodec,\n  mongoVectorCodec,\n} from '../core/codecs';\n\nconst mongoAdapterDescriptor: ControlAdapterDescriptor<'mongo', 'mongo'> = {\n  kind: 'adapter',\n  id: 'mongo',\n  familyId: 'mongo',\n  targetId: 'mongo',\n  version: '0.0.1',\n  types: {\n    codecTypes: {\n      codecInstances: [\n        mongoObjectIdCodec,\n        mongoStringCodec,\n        mongoDoubleCodec,\n        mongoInt32Codec,\n        mongoBooleanCodec,\n        mongoDateCodec,\n        mongoVectorCodec,\n      ],\n      import: {\n        package: '@prisma-next/adapter-mongo/codec-types',\n        named: 'CodecTypes',\n        alias: 'MongoCodecTypes',\n      },\n      typeImports: [\n        {\n          package: '@prisma-next/adapter-mongo/codec-types',\n          named: 'Vector',\n          alias: 'Vector',\n        },\n      ],\n    },\n  },\n  create() {\n    return { familyId: 'mongo' as const, targetId: 'mongo' as const };\n  },\n};\n\nexport default mongoAdapterDescriptor;\n"],"mappings":";;;;;AAYA,MAAa,qBAAqB,WAAW;CAC3C,QAAQ;CACR,aAAa,CAAC,WAAW;CACzB,QAAQ,CAAC,WAAW;CACpB,SAAS,SAAmB,KAAK,aAAa;CAC9C,SAAS,UAAkB,IAAI,SAAS,MAAM;CAC/C,CAAC;AAEF,MAAa,mBAAmB,WAAW;CACzC,QAAQ;CACR,aAAa,CAAC,SAAS;CACvB,QAAQ;EAAC;EAAY;EAAS;EAAU;CACxC,SAAS,SAAiB;CAC1B,SAAS,UAAkB;CAC5B,CAAC;AAEF,MAAa,mBAAmB,WAAW;CACzC,QAAQ;CACR,aAAa,CAAC,QAAQ;CACtB,QAAQ;EAAC;EAAY;EAAS;EAAU;CACxC,SAAS,SAAiB;CAC1B,SAAS,UAAkB;CAC5B,CAAC;AAEF,MAAa,kBAAkB,WAAW;CACxC,QAAQ;CACR,aAAa,CAAC,MAAM;CACpB,QAAQ;EAAC;EAAY;EAAS;EAAU;CACxC,SAAS,SAAiB;CAC1B,SAAS,UAAkB;CAC5B,CAAC;AAEF,MAAa,oBAAoB,WAAW;CAC1C,QAAQ;CACR,aAAa,CAAC,OAAO;CACrB,QAAQ,CAAC,YAAY,UAAU;CAC/B,SAAS,SAAkB;CAC3B,SAAS,UAAmB;CAC7B,CAAC;AAEF,MAAa,iBAAiB,WAAW;CACvC,QAAQ;CACR,aAAa,CAAC,OAAO;CACrB,QAAQ,CAAC,YAAY,QAAQ;CAC7B,SAAS,SAAe;CACxB,SAAS,UAAgB;CAC1B,CAAC;AAEF,MAAa,mBAAmB,WAAW;CACzC,QAAQ;CACR,aAAa,CAAC,SAAS;CACvB,QAAQ,CAAC,WAAW;CACpB,SAAS,SAA4B;CACrC,SAAS,UAA6B;CACtC,mBAAmB,eAAe;EAChC,MAAM,SAAS,WAAW;AAC1B,MAAI,WAAW,OAAW,QAAO;AACjC,MAAI,OAAO,WAAW,YAAY,CAAC,OAAO,SAAS,OAAO,IAAI,CAAC,OAAO,UAAU,OAAO,CACrF,OAAM,IAAI,MAAM,oEAAkE;AAEpF,SAAO,UAAU,OAAO;;CAE3B,CAAC;;;;AC/DF,MAAMA,yBAAqE;CACzE,MAAM;CACN,IAAI;CACJ,UAAU;CACV,UAAU;CACV,SAAS;CACT,OAAO,EACL,YAAY;EACV,gBAAgB;GACd;GACA;GACA;GACA;GACA;GACA;GACA;GACD;EACD,QAAQ;GACN,SAAS;GACT,OAAO;GACP,OAAO;GACR;EACD,aAAa,CACX;GACE,SAAS;GACT,OAAO;GACP,OAAO;GACR,CACF;EACF,EACF;CACD,SAAS;AACP,SAAO;GAAE,UAAU;GAAkB,UAAU;GAAkB;;CAEpE;AAED,sBAAe"}

package/dist/index.d.mts

@@ -1,7 +1,30 @@
-import { MongoAdapter } from "@prisma-next/mongo-core";
+import { MongoAggExpr, MongoFilterExpr, MongoPipelineStage } from "@prisma-next/mongo-query-ast";
+import { Document } from "@prisma-next/mongo-value";
+import { OperationDescriptor } from "@prisma-next/operations";
+import { MongoAdapter } from "@prisma-next/mongo-lowering";
 
+//#region src/core/operations.d.ts
+declare const mongoVectorNearOperation: Readonly<{
+  method: "near";
+  args: {
+    codecId: "mongo/vector@1";
+    nullable: boolean;
+  }[];
+  returns: {
+    codecId: "mongo/int32@1";
+    nullable: boolean;
+  };
+}>;
+declare const mongoVectorOperationDescriptors: readonly OperationDescriptor[];
+//#endregion
+//#region src/lowering.d.ts
+declare function lowerAggExpr(expr: MongoAggExpr): unknown;
+declare function lowerFilter(filter: MongoFilterExpr): Document;
+declare function lowerStage(stage: MongoPipelineStage): Record<string, unknown>;
+declare function lowerPipeline(stages: ReadonlyArray<MongoPipelineStage>): Array<Record<string, unknown>>;
+//#endregion
 //#region src/mongo-adapter.d.ts
 declare function createMongoAdapter(): MongoAdapter;
 //#endregion
-export { createMongoAdapter };
+export { createMongoAdapter, lowerAggExpr, lowerFilter, lowerPipeline, lowerStage, mongoVectorNearOperation, mongoVectorOperationDescriptors };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/mongo-adapter.ts"],"sourcesContent":[],"mappings":";;;iBAsGgB,kBAAA,CAAA,GAAsB"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/core/operations.ts","../src/lowering.ts","../src/mongo-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;cAGa,0BAAwB;;;;;EAAxB,CAAA,EAAA;EAMA,OAAA,EAAA;;;;AC6Hb,CAAA,CAAA;AAIgB,cDjIH,+BCiIyC,EAAA,SDjIC,mBCiIO,EAAA;;;iBAJ9C,YAAA,OAAmB;iBAInB,WAAA,SAAoB,kBAAkB;iBA8DtC,UAAA,QAAkB,qBAAqB;iBAqMvC,aAAA,SACN,cAAc,sBACrB,MAAM;;;iBC9RO,kBAAA,CAAA,GAAsB"}

package/dist/index.mjs

@@ -1,52 +1,369 @@
-import { AggregateWireCommand, DeleteOneWireCommand, FindWireCommand, InsertOneWireCommand, MongoParamRef, UpdateOneWireCommand } from "@prisma-next/mongo-core";
+import { i as MONGO_INT32_CODEC_ID, s as MONGO_VECTOR_CODEC_ID } from "./codec-ids-FBmJhfq-.mjs";
+import { isExprArray, isRecordArgs } from "@prisma-next/mongo-query-ast";
+import { MongoParamRef } from "@prisma-next/mongo-value";
+import { AggregateWireCommand, DeleteManyWireCommand, DeleteOneWireCommand, FindOneAndDeleteWireCommand, FindOneAndUpdateWireCommand, InsertManyWireCommand, InsertOneWireCommand, UpdateManyWireCommand, UpdateOneWireCommand } from "@prisma-next/mongo-wire";
 
+//#region src/core/operations.ts
+const mongoVectorNearOperation = Object.freeze({
+	method: "near",
+	args: [{
+		codecId: MONGO_VECTOR_CODEC_ID,
+		nullable: false
+	}],
+	returns: {
+		codecId: MONGO_INT32_CODEC_ID,
+		nullable: false
+	}
+});
+const mongoVectorOperationDescriptors = [mongoVectorNearOperation];
+
+//#endregion
+//#region src/resolve-value.ts
+function resolveValue(value) {
+	if (value instanceof MongoParamRef) return value.value;
+	if (value === null || typeof value !== "object") return value;
+	if (value instanceof Date) return value;
+	if (Array.isArray(value)) return value.map((v) => resolveValue(v));
+	const result = {};
+	for (const [key, val] of Object.entries(value)) result[key] = resolveValue(val);
+	return result;
+}
+
+//#endregion
+//#region src/lowering.ts
+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);
+}
+function lowerFilter(filter) {
+	switch (filter.kind) {
+		case "field": return { [filter.field]: { [filter.op]: resolveValue(filter.value) } };
+		case "and": return { $and: filter.exprs.map((e) => lowerFilter(e)) };
+		case "or": return { $or: filter.exprs.map((e) => lowerFilter(e)) };
+		case "not": return { $nor: [lowerFilter(filter.expr)] };
+		case "exists": return { [filter.field]: { $exists: filter.exists } };
+		case "expr": return { $expr: lowerAggExpr(filter.aggExpr) };
+		default: {
+			const _exhaustive = filter;
+			throw new Error(`Unhandled filter kind: ${_exhaustive.kind}`);
+		}
+	}
+}
+function isAggExprNode(value) {
+	return "accept" in value && typeof value.accept === "function";
+}
+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 (Array.isArray(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 Error("Window field operator must lower to an object");
+	const result = { ...lowered };
+	if (wf.window) result["window"] = { ...wf.window };
+	return result;
+}
+function lowerStage(stage) {
+	switch (stage.kind) {
+		case "match": return { $match: lowerFilter(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"] = stage.pipeline.map((s) => lowerStage(s));
+			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"] = stage.pipeline.map((s) => lowerStage(s));
+			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"] = lowerFilter(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] = pipeline.map((s) => lowerStage(s));
+			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"] = lowerFilter(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) ? stage.whenMatched.map((s) => lowerStage(s)) : 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;
+			throw new Error(`Unhandled stage kind: ${_exhaustive.kind}`);
+		}
+	}
+}
+function lowerPipeline(stages) {
+	return stages.map(lowerStage);
+}
+
+//#endregion
 //#region src/mongo-adapter.ts
+function resolveDocument(expr) {
+	const result = {};
+	for (const [key, val] of Object.entries(expr)) result[key] = resolveValue(val);
+	return result;
+}
+function isUpdatePipeline(update) {
+	return Array.isArray(update);
+}
+function lowerUpdate(update) {
+	if (isUpdatePipeline(update)) return update.map((stage) => lowerStage(stage));
+	return resolveDocument(update);
+}
 var MongoAdapterImpl = class {
-	lower(queryPlan, _context) {
-		const wireCommand = this.#lowerCommand(queryPlan.command);
-		return Object.freeze({
-			wireCommand,
-			command: queryPlan.command,
-			meta: queryPlan.meta
-		});
-	}
-	#lowerCommand(command) {
+	lower(plan) {
+		const { command } = plan;
 		switch (command.kind) {
-			case "find": {
-				const options = {};
-				if (command.projection) options.projection = { ...command.projection };
-				if (command.sort) options.sort = { ...command.sort };
-				if (command.limit !== void 0) options.limit = command.limit;
-				if (command.skip !== void 0) options.skip = command.skip;
-				return new FindWireCommand(command.collection, command.filter ? this.#resolveDocument(command.filter) : void 0, options);
-			}
-			case "insertOne": return new InsertOneWireCommand(command.collection, this.#resolveDocument(command.document));
-			case "updateOne": return new UpdateOneWireCommand(command.collection, this.#resolveDocument(command.filter), this.#resolveDocument(command.update));
-			case "deleteOne": return new DeleteOneWireCommand(command.collection, this.#resolveDocument(command.filter));
-			case "aggregate": return new AggregateWireCommand(command.collection, command.pipeline.map((stage) => ({ ...stage })));
+			case "insertOne": return new InsertOneWireCommand(command.collection, resolveDocument(command.document));
+			case "updateOne": return new UpdateOneWireCommand(command.collection, lowerFilter(command.filter), lowerUpdate(command.update));
+			case "insertMany": return new InsertManyWireCommand(command.collection, command.documents.map((doc) => resolveDocument(doc)));
+			case "updateMany": return new UpdateManyWireCommand(command.collection, lowerFilter(command.filter), lowerUpdate(command.update));
+			case "deleteOne": return new DeleteOneWireCommand(command.collection, lowerFilter(command.filter));
+			case "deleteMany": return new DeleteManyWireCommand(command.collection, lowerFilter(command.filter));
+			case "findOneAndUpdate": return new FindOneAndUpdateWireCommand(command.collection, lowerFilter(command.filter), lowerUpdate(command.update), command.upsert);
+			case "findOneAndDelete": return new FindOneAndDeleteWireCommand(command.collection, lowerFilter(command.filter));
+			case "aggregate": return new AggregateWireCommand(command.collection, lowerPipeline(command.pipeline));
+			case "rawAggregate": return new AggregateWireCommand(command.collection, command.pipeline);
+			case "rawInsertOne": return new InsertOneWireCommand(command.collection, command.document);
+			case "rawInsertMany": return new InsertManyWireCommand(command.collection, command.documents);
+			case "rawUpdateOne": return new UpdateOneWireCommand(command.collection, command.filter, command.update);
+			case "rawUpdateMany": return new UpdateManyWireCommand(command.collection, command.filter, command.update);
+			case "rawDeleteOne": return new DeleteOneWireCommand(command.collection, command.filter);
+			case "rawDeleteMany": return new DeleteManyWireCommand(command.collection, command.filter);
+			case "rawFindOneAndUpdate": return new FindOneAndUpdateWireCommand(command.collection, command.filter, command.update, command.upsert);
+			case "rawFindOneAndDelete": return new FindOneAndDeleteWireCommand(command.collection, command.filter);
 			default: {
 				const _exhaustive = command;
 				throw new Error(`Unknown command kind: ${_exhaustive.kind}`);
 			}
 		}
 	}
-	#resolveValue(value) {
-		if (value instanceof MongoParamRef) return value.value;
-		if (value === null || typeof value !== "object") return value;
-		if (value instanceof Date) return value;
-		if (Array.isArray(value)) return value.map((v) => this.#resolveValue(v));
-		return this.#resolveDocument(value);
-	}
-	#resolveDocument(expr) {
-		const result = {};
-		for (const [key, val] of Object.entries(expr)) result[key] = this.#resolveValue(val);
-		return result;
-	}
 };
 function createMongoAdapter() {
 	return new MongoAdapterImpl();
 }
 
 //#endregion
-export { createMongoAdapter };
+export { createMongoAdapter, lowerAggExpr, lowerFilter, lowerPipeline, lowerStage, mongoVectorNearOperation, mongoVectorOperationDescriptors };
 //# sourceMappingURL=index.mjs.map