@prisma-next/adapter-mongo 0.3.0-dev.146 → 0.3.0-dev.162

package/dist/control.mjs

@@ -1,64 +1,977 @@
-import { a as MONGO_STRING_CODEC_ID, i as MONGO_OBJECTID_CODEC_ID, n as MONGO_DATE_CODEC_ID, o as MONGO_VECTOR_CODEC_ID, r as MONGO_INT32_CODEC_ID, t as MONGO_BOOLEAN_CODEC_ID } from "./codec-ids-B-QSSwbW.mjs";
-import { mongoCodec } from "@prisma-next/mongo-codec";
-import { ObjectId } from "mongodb";
+import { a as mongoObjectIdCodec, i as mongoInt32Codec, n as mongoDateCodec, o as mongoStringCodec, r as mongoDoubleCodec, s as mongoVectorCodec, t as mongoBooleanCodec } from "./codecs-9xSaT_DN.mjs";
+import { MongoServerError } from "mongodb";
+import { initMarker, initMarker as initMarker$1, readMarker, readMarker as readMarker$1, updateMarker, updateMarker as updateMarker$1, writeLedgerEntry, writeLedgerEntry as writeLedgerEntry$1 } from "@prisma-next/target-mongo/control";
+import { CollModCommand, CreateCollectionCommand, CreateIndexCommand, DropCollectionCommand, DropIndexCommand, ListCollectionsCommand, ListIndexesCommand, MongoAndExpr, MongoExistsExpr, MongoFieldFilter, MongoNotExpr, MongoOrExpr, buildIndexOpId, defaultMongoIndexName, keysToKeySpec } from "@prisma-next/mongo-query-ast/control";
+import { MongoSchemaCollection, MongoSchemaCollectionOptions, MongoSchemaIR, MongoSchemaIndex, MongoSchemaValidator, canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
+import { type } from "arktype";
+import { notOk, ok } from "@prisma-next/utils/result";
 
-//#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)
+//#region src/core/command-executor.ts
+var MongoCommandExecutor = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async createIndex(cmd) {
+		const keySpec = keysToKeySpec(cmd.keys);
+		const options = {};
+		if (cmd.unique !== void 0) options["unique"] = cmd.unique;
+		if (cmd.sparse !== void 0) options["sparse"] = cmd.sparse;
+		if (cmd.expireAfterSeconds !== void 0) options["expireAfterSeconds"] = cmd.expireAfterSeconds;
+		if (cmd.partialFilterExpression !== void 0) options["partialFilterExpression"] = cmd.partialFilterExpression;
+		if (cmd.name !== void 0) options["name"] = cmd.name;
+		if (cmd.wildcardProjection !== void 0) options["wildcardProjection"] = cmd.wildcardProjection;
+		if (cmd.collation !== void 0) options["collation"] = cmd.collation;
+		if (cmd.weights !== void 0) options["weights"] = cmd.weights;
+		if (cmd.default_language !== void 0) options["default_language"] = cmd.default_language;
+		if (cmd.language_override !== void 0) options["language_override"] = cmd.language_override;
+		await this.db.collection(cmd.collection).createIndex(keySpec, options);
+	}
+	async dropIndex(cmd) {
+		await this.db.collection(cmd.collection).dropIndex(cmd.name);
+	}
+	async createCollection(cmd) {
+		const options = {};
+		if (cmd.capped !== void 0) options["capped"] = cmd.capped;
+		if (cmd.size !== void 0) options["size"] = cmd.size;
+		if (cmd.max !== void 0) options["max"] = cmd.max;
+		if (cmd.timeseries !== void 0) options["timeseries"] = cmd.timeseries;
+		if (cmd.collation !== void 0) options["collation"] = cmd.collation;
+		if (cmd.clusteredIndex !== void 0) options["clusteredIndex"] = cmd.clusteredIndex;
+		if (cmd.validator !== void 0) options["validator"] = cmd.validator;
+		if (cmd.validationLevel !== void 0) options["validationLevel"] = cmd.validationLevel;
+		if (cmd.validationAction !== void 0) options["validationAction"] = cmd.validationAction;
+		if (cmd.changeStreamPreAndPostImages !== void 0) options["changeStreamPreAndPostImages"] = cmd.changeStreamPreAndPostImages;
+		await this.db.createCollection(cmd.collection, options);
+	}
+	async dropCollection(cmd) {
+		await this.db.collection(cmd.collection).drop();
+	}
+	async collMod(cmd) {
+		const command = { collMod: cmd.collection };
+		if (cmd.validator !== void 0) command["validator"] = cmd.validator;
+		if (cmd.validationLevel !== void 0) command["validationLevel"] = cmd.validationLevel;
+		if (cmd.validationAction !== void 0) command["validationAction"] = cmd.validationAction;
+		if (cmd.changeStreamPreAndPostImages !== void 0) command["changeStreamPreAndPostImages"] = cmd.changeStreamPreAndPostImages;
+		await this.db.command(command);
+	}
+};
+var MongoInspectionExecutor = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async listIndexes(cmd) {
+		try {
+			return await this.db.collection(cmd.collection).listIndexes().toArray();
+		} catch (error) {
+			if (error instanceof MongoServerError && error.code === 26) return [];
+			throw error;
+		}
+	}
+	async listCollections(_cmd) {
+		return this.db.listCollections().toArray();
+	}
+};
+
+//#endregion
+//#region src/core/contract-to-schema.ts
+function convertIndex(index) {
+	return new MongoSchemaIndex({
+		keys: index.keys,
+		unique: index.unique,
+		sparse: index.sparse,
+		expireAfterSeconds: index.expireAfterSeconds,
+		partialFilterExpression: index.partialFilterExpression,
+		wildcardProjection: index.wildcardProjection,
+		collation: index.collation,
+		weights: index.weights,
+		default_language: index.default_language,
+		language_override: index.language_override
+	});
+}
+function convertValidator(v) {
+	return new MongoSchemaValidator({
+		jsonSchema: v.jsonSchema,
+		validationLevel: v.validationLevel,
+		validationAction: v.validationAction
+	});
+}
+function convertOptions(o) {
+	return new MongoSchemaCollectionOptions(o);
+}
+function convertCollection(name, def) {
+	return new MongoSchemaCollection({
+		name,
+		indexes: (def.indexes ?? []).map(convertIndex),
+		...def.validator != null && { validator: convertValidator(def.validator) },
+		...def.options != null && { options: convertOptions(def.options) }
+	});
+}
+function contractToMongoSchemaIR(contract) {
+	if (!contract) return new MongoSchemaIR([]);
+	return new MongoSchemaIR(Object.entries(contract.storage.collections).map(([name, def]) => convertCollection(name, def)));
+}
+
+//#endregion
+//#region src/core/ddl-formatter.ts
+function formatKeySpec(keys) {
+	return `{ ${keys.map((k) => `${JSON.stringify(k.field)}: ${JSON.stringify(k.direction)}`).join(", ")} }`;
+}
+function formatOptions(cmd) {
+	const parts = [];
+	if (cmd.unique) parts.push("unique: true");
+	if (cmd.sparse) parts.push("sparse: true");
+	if (cmd.expireAfterSeconds !== void 0) parts.push(`expireAfterSeconds: ${cmd.expireAfterSeconds}`);
+	if (cmd.name) parts.push(`name: ${JSON.stringify(cmd.name)}`);
+	if (cmd.collation) parts.push(`collation: ${JSON.stringify(cmd.collation)}`);
+	if (cmd.weights) parts.push(`weights: ${JSON.stringify(cmd.weights)}`);
+	if (cmd.default_language) parts.push(`default_language: ${JSON.stringify(cmd.default_language)}`);
+	if (cmd.language_override) parts.push(`language_override: ${JSON.stringify(cmd.language_override)}`);
+	if (cmd.wildcardProjection) parts.push(`wildcardProjection: ${JSON.stringify(cmd.wildcardProjection)}`);
+	if (cmd.partialFilterExpression) parts.push(`partialFilterExpression: ${JSON.stringify(cmd.partialFilterExpression)}`);
+	if (parts.length === 0) return void 0;
+	return `{ ${parts.join(", ")} }`;
+}
+function formatCreateCollectionOptions(cmd) {
+	const parts = [];
+	if (cmd.capped) parts.push("capped: true");
+	if (cmd.size !== void 0) parts.push(`size: ${cmd.size}`);
+	if (cmd.max !== void 0) parts.push(`max: ${cmd.max}`);
+	if (cmd.timeseries) parts.push(`timeseries: ${JSON.stringify(cmd.timeseries)}`);
+	if (cmd.collation) parts.push(`collation: ${JSON.stringify(cmd.collation)}`);
+	if (cmd.clusteredIndex) parts.push(`clusteredIndex: ${JSON.stringify(cmd.clusteredIndex)}`);
+	if (cmd.validator) parts.push(`validator: ${JSON.stringify(cmd.validator)}`);
+	if (cmd.validationLevel) parts.push(`validationLevel: ${JSON.stringify(cmd.validationLevel)}`);
+	if (cmd.validationAction) parts.push(`validationAction: ${JSON.stringify(cmd.validationAction)}`);
+	if (cmd.changeStreamPreAndPostImages) parts.push(`changeStreamPreAndPostImages: ${JSON.stringify(cmd.changeStreamPreAndPostImages)}`);
+	if (parts.length === 0) return void 0;
+	return `{ ${parts.join(", ")} }`;
+}
+var MongoDdlCommandFormatter = class {
+	createIndex(cmd) {
+		const keySpec = formatKeySpec(cmd.keys);
+		const opts = formatOptions(cmd);
+		return opts ? `db.${cmd.collection}.createIndex(${keySpec}, ${opts})` : `db.${cmd.collection}.createIndex(${keySpec})`;
+	}
+	dropIndex(cmd) {
+		return `db.${cmd.collection}.dropIndex(${JSON.stringify(cmd.name)})`;
+	}
+	createCollection(cmd) {
+		const opts = formatCreateCollectionOptions(cmd);
+		return opts ? `db.createCollection(${JSON.stringify(cmd.collection)}, ${opts})` : `db.createCollection(${JSON.stringify(cmd.collection)})`;
+	}
+	dropCollection(cmd) {
+		return `db.${cmd.collection}.drop()`;
+	}
+	collMod(cmd) {
+		const parts = [`collMod: ${JSON.stringify(cmd.collection)}`];
+		if (cmd.validator) parts.push(`validator: ${JSON.stringify(cmd.validator)}`);
+		if (cmd.validationLevel) parts.push(`validationLevel: ${JSON.stringify(cmd.validationLevel)}`);
+		if (cmd.validationAction) parts.push(`validationAction: ${JSON.stringify(cmd.validationAction)}`);
+		if (cmd.changeStreamPreAndPostImages) parts.push(`changeStreamPreAndPostImages: ${JSON.stringify(cmd.changeStreamPreAndPostImages)}`);
+		return `db.runCommand({ ${parts.join(", ")} })`;
+	}
+};
+const formatter = new MongoDdlCommandFormatter();
+function formatMongoOperations(operations) {
+	const statements = [];
+	for (const operation of operations) {
+		const candidate = operation;
+		if (!("execute" in candidate) || !Array.isArray(candidate["execute"])) continue;
+		for (const step of candidate["execute"]) if (step.command && typeof step.command.accept === "function") statements.push(step.command.accept(formatter));
+	}
+	return statements;
+}
+
+//#endregion
+//#region src/core/introspect-schema.ts
+const PRISMA_MIGRATIONS_COLLECTION = "_prisma_migrations";
+function parseIndexKeys(keySpec) {
+	const keys = [];
+	for (const [field, direction] of Object.entries(keySpec)) keys.push({
+		field,
+		direction
+	});
+	return keys;
+}
+function isDefaultIdIndex(doc) {
+	const key = doc["key"];
+	if (!key) return false;
+	const entries = Object.entries(key);
+	return entries.length === 1 && entries[0]?.[0] === "_id" && entries[0]?.[1] === 1;
+}
+function parseIndex(doc) {
+	const keySpec = doc["key"];
+	return new MongoSchemaIndex({
+		keys: parseIndexKeys(keySpec),
+		unique: doc["unique"],
+		sparse: doc["sparse"],
+		expireAfterSeconds: doc["expireAfterSeconds"],
+		partialFilterExpression: doc["partialFilterExpression"],
+		wildcardProjection: doc["wildcardProjection"],
+		collation: doc["collation"],
+		weights: doc["weights"],
+		default_language: doc["default_language"],
+		language_override: doc["language_override"]
+	});
+}
+function parseValidator(options) {
+	const validator = options["validator"];
+	if (!validator) return void 0;
+	const jsonSchema = validator["$jsonSchema"];
+	if (!jsonSchema) return void 0;
+	return new MongoSchemaValidator({
+		jsonSchema,
+		validationLevel: options["validationLevel"] ?? "strict",
+		validationAction: options["validationAction"] ?? "error"
+	});
+}
+function parseCollectionOptions(info) {
+	const options = info["options"];
+	if (!options) return void 0;
+	const capped = options["capped"];
+	const size = options["size"];
+	const max = options["max"];
+	const timeseries = options["timeseries"];
+	const collation = options["collation"];
+	const changeStreamPreAndPostImages = options["changeStreamPreAndPostImages"];
+	const clusteredIndex = options["clusteredIndex"];
+	if (!(capped || timeseries || collation || changeStreamPreAndPostImages || clusteredIndex)) return void 0;
+	return new MongoSchemaCollectionOptions({
+		...capped ? { capped: {
+			size: size ?? 0,
+			...max != null ? { max } : {}
+		} } : {},
+		...timeseries ? { timeseries } : {},
+		...collation ? { collation } : {},
+		...changeStreamPreAndPostImages ? { changeStreamPreAndPostImages } : {},
+		...clusteredIndex ? { clusteredIndex } : {}
+	});
+}
+async function introspectSchema(db) {
+	const collectionInfos = await db.listCollections().toArray();
+	const collections = [];
+	for (const info of collectionInfos) {
+		const name = info["name"];
+		const type$1 = info["type"];
+		if (name === PRISMA_MIGRATIONS_COLLECTION) continue;
+		if (name.startsWith("system.")) continue;
+		if (type$1 === "view") continue;
+		const indexes = (await db.collection(name).listIndexes().toArray()).filter((doc) => !isDefaultIdIndex(doc)).map(parseIndex);
+		const validator = parseValidator("options" in info ? info["options"] : {});
+		const options = parseCollectionOptions(info);
+		collections.push(new MongoSchemaCollection({
+			name,
+			indexes,
+			...validator ? { validator } : {},
+			...options ? { options } : {}
+		}));
+	}
+	return new MongoSchemaIR(collections);
+}
+
+//#endregion
+//#region src/core/mongo-control-driver.ts
+var MongoControlDriverImpl = class {
+	familyId = "mongo";
+	targetId = "mongo";
+	db;
+	#client;
+	constructor(db, client) {
+		this.db = db;
+		this.#client = client;
+	}
+	query() {
+		throw new Error("MongoDB control driver does not support SQL queries");
+	}
+	async close() {
+		await this.#client.close();
+	}
+};
+function createMongoControlDriver(db, client) {
+	return new MongoControlDriverImpl(db, client);
+}
+
+//#endregion
+//#region src/core/mongo-ops-serializer.ts
+const CreateIndexJson = type({
+	kind: "\"createIndex\"",
+	collection: "string",
+	keys: type({
+		field: "string",
+		direction: type("1 | -1 | \"text\" | \"2dsphere\" | \"2d\" | \"hashed\"")
+	}).array().atLeastLength(1),
+	"unique?": "boolean",
+	"sparse?": "boolean",
+	"expireAfterSeconds?": "number",
+	"partialFilterExpression?": "Record<string, unknown>",
+	"name?": "string",
+	"wildcardProjection?": "Record<string, unknown>",
+	"collation?": "Record<string, unknown>",
+	"weights?": "Record<string, unknown>",
+	"default_language?": "string",
+	"language_override?": "string"
 });
-const mongoStringCodec = mongoCodec({
-	typeId: MONGO_STRING_CODEC_ID,
-	targetTypes: ["string"],
-	traits: [
-		"equality",
-		"order",
-		"textual"
-	],
-	decode: (wire) => wire,
-	encode: (value) => value
+const DropIndexJson = type({
+	kind: "\"dropIndex\"",
+	collection: "string",
+	name: "string"
 });
-const mongoInt32Codec = mongoCodec({
-	typeId: MONGO_INT32_CODEC_ID,
-	targetTypes: ["int"],
-	traits: [
-		"equality",
-		"order",
-		"numeric"
-	],
-	decode: (wire) => wire,
-	encode: (value) => value
+const CreateCollectionJson = type({
+	kind: "\"createCollection\"",
+	collection: "string",
+	"validator?": "Record<string, unknown>",
+	"validationLevel?": "\"strict\" | \"moderate\"",
+	"validationAction?": "\"error\" | \"warn\"",
+	"capped?": "boolean",
+	"size?": "number",
+	"max?": "number",
+	"timeseries?": "Record<string, unknown>",
+	"collation?": "Record<string, unknown>",
+	"changeStreamPreAndPostImages?": "Record<string, unknown>",
+	"clusteredIndex?": "Record<string, unknown>"
 });
-const mongoBooleanCodec = mongoCodec({
-	typeId: MONGO_BOOLEAN_CODEC_ID,
-	targetTypes: ["bool"],
-	traits: ["equality", "boolean"],
-	decode: (wire) => wire,
-	encode: (value) => value
+const DropCollectionJson = type({
+	kind: "\"dropCollection\"",
+	collection: "string"
 });
-const mongoDateCodec = mongoCodec({
-	typeId: MONGO_DATE_CODEC_ID,
-	targetTypes: ["date"],
-	traits: ["equality", "order"],
-	decode: (wire) => wire,
-	encode: (value) => value
+const CollModJson = type({
+	kind: "\"collMod\"",
+	collection: "string",
+	"validator?": "Record<string, unknown>",
+	"validationLevel?": "\"strict\" | \"moderate\"",
+	"validationAction?": "\"error\" | \"warn\"",
+	"changeStreamPreAndPostImages?": "Record<string, unknown>"
 });
-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}>`;
-	}
+const ListIndexesJson = type({
+	kind: "\"listIndexes\"",
+	collection: "string"
+});
+const ListCollectionsJson = type({ kind: "\"listCollections\"" });
+const FieldFilterJson = type({
+	kind: "\"field\"",
+	field: "string",
+	op: "string",
+	value: "unknown"
+});
+const ExistsFilterJson = type({
+	kind: "\"exists\"",
+	field: "string",
+	exists: "boolean"
+});
+const CheckJson = type({
+	description: "string",
+	source: "Record<string, unknown>",
+	filter: "Record<string, unknown>",
+	expect: "\"exists\" | \"notExists\""
+});
+const StepJson = type({
+	description: "string",
+	command: "Record<string, unknown>"
+});
+const OperationJson = type({
+	id: "string",
+	label: "string",
+	operationClass: "\"additive\" | \"widening\" | \"destructive\"",
+	precheck: "Record<string, unknown>[]",
+	execute: "Record<string, unknown>[]",
+	postcheck: "Record<string, unknown>[]"
 });
+function validate(schema, data, context) {
+	try {
+		return schema.assert(data);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Invalid ${context}: ${message}`);
+	}
+}
+function deserializeFilterExpr(json) {
+	const record = json;
+	const kind = record["kind"];
+	switch (kind) {
+		case "field": {
+			const data = validate(FieldFilterJson, json, "field filter");
+			return MongoFieldFilter.of(data.field, data.op, data.value);
+		}
+		case "and": {
+			const exprs = record["exprs"];
+			if (!Array.isArray(exprs)) throw new Error("Invalid and filter: missing exprs array");
+			return MongoAndExpr.of(exprs.map(deserializeFilterExpr));
+		}
+		case "or": {
+			const exprs = record["exprs"];
+			if (!Array.isArray(exprs)) throw new Error("Invalid or filter: missing exprs array");
+			return MongoOrExpr.of(exprs.map(deserializeFilterExpr));
+		}
+		case "not": {
+			const expr = record["expr"];
+			if (!expr || typeof expr !== "object") throw new Error("Invalid not filter: missing expr");
+			return new MongoNotExpr(deserializeFilterExpr(expr));
+		}
+		case "exists": {
+			const data = validate(ExistsFilterJson, json, "exists filter");
+			return new MongoExistsExpr(data.field, data.exists);
+		}
+		default: throw new Error(`Unknown filter expression kind: ${kind}`);
+	}
+}
+function deserializeDdlCommand(json) {
+	const kind = json["kind"];
+	switch (kind) {
+		case "createIndex": {
+			const data = validate(CreateIndexJson, json, "createIndex command");
+			return new CreateIndexCommand(data.collection, data.keys, {
+				unique: data.unique,
+				sparse: data.sparse,
+				expireAfterSeconds: data.expireAfterSeconds,
+				partialFilterExpression: data.partialFilterExpression,
+				name: data.name,
+				wildcardProjection: data.wildcardProjection,
+				collation: data.collation,
+				weights: data.weights,
+				default_language: data.default_language,
+				language_override: data.language_override
+			});
+		}
+		case "dropIndex": {
+			const data = validate(DropIndexJson, json, "dropIndex command");
+			return new DropIndexCommand(data.collection, data.name);
+		}
+		case "createCollection": {
+			const data = validate(CreateCollectionJson, json, "createCollection command");
+			return new CreateCollectionCommand(data.collection, {
+				validator: data.validator,
+				validationLevel: data.validationLevel,
+				validationAction: data.validationAction,
+				capped: data.capped,
+				size: data.size,
+				max: data.max,
+				timeseries: data.timeseries,
+				collation: data.collation,
+				changeStreamPreAndPostImages: data.changeStreamPreAndPostImages,
+				clusteredIndex: data.clusteredIndex
+			});
+		}
+		case "dropCollection": return new DropCollectionCommand(validate(DropCollectionJson, json, "dropCollection command").collection);
+		case "collMod": {
+			const data = validate(CollModJson, json, "collMod command");
+			return new CollModCommand(data.collection, {
+				validator: data.validator,
+				validationLevel: data.validationLevel,
+				validationAction: data.validationAction,
+				changeStreamPreAndPostImages: data.changeStreamPreAndPostImages
+			});
+		}
+		default: throw new Error(`Unknown DDL command kind: ${kind}`);
+	}
+}
+function deserializeInspectionCommand(json) {
+	const kind = json["kind"];
+	switch (kind) {
+		case "listIndexes": return new ListIndexesCommand(validate(ListIndexesJson, json, "listIndexes command").collection);
+		case "listCollections":
+			validate(ListCollectionsJson, json, "listCollections command");
+			return new ListCollectionsCommand();
+		default: throw new Error(`Unknown inspection command kind: ${kind}`);
+	}
+}
+function deserializeCheck(json) {
+	const data = validate(CheckJson, json, "migration check");
+	return {
+		description: data.description,
+		source: deserializeInspectionCommand(data.source),
+		filter: deserializeFilterExpr(data.filter),
+		expect: data.expect
+	};
+}
+function deserializeStep(json) {
+	const data = validate(StepJson, json, "migration step");
+	return {
+		description: data.description,
+		command: deserializeDdlCommand(data.command)
+	};
+}
+function deserializeMongoOp(json) {
+	const data = validate(OperationJson, json, "migration operation");
+	return {
+		id: data.id,
+		label: data.label,
+		operationClass: data.operationClass,
+		precheck: data.precheck.map(deserializeCheck),
+		execute: data.execute.map(deserializeStep),
+		postcheck: data.postcheck.map(deserializeCheck)
+	};
+}
+function deserializeMongoOps(json) {
+	return json.map(deserializeMongoOp);
+}
+function serializeMongoOps(ops) {
+	return JSON.stringify(ops, null, 2);
+}
+
+//#endregion
+//#region src/core/mongo-planner.ts
+function buildIndexLookupKey(index) {
+	const keys = index.keys.map((k) => `${k.field}:${k.direction}`).join(",");
+	const opts = [
+		index.unique ? "unique" : "",
+		index.sparse ? "sparse" : "",
+		index.expireAfterSeconds != null ? `ttl:${index.expireAfterSeconds}` : "",
+		index.partialFilterExpression ? `pfe:${canonicalize(index.partialFilterExpression)}` : "",
+		index.wildcardProjection ? `wp:${canonicalize(index.wildcardProjection)}` : "",
+		index.collation ? `col:${canonicalize(index.collation)}` : "",
+		index.weights ? `wt:${canonicalize(index.weights)}` : "",
+		index.default_language ? `dl:${index.default_language}` : "",
+		index.language_override ? `lo:${index.language_override}` : ""
+	].filter(Boolean).join(";");
+	return opts ? `${keys}|${opts}` : keys;
+}
+function formatKeys(keys) {
+	return keys.map((k) => `${k.field}:${k.direction}`).join(", ");
+}
+function isTextIndex(keys) {
+	return keys.some((k) => k.direction === "text");
+}
+function planCreateIndex(collection, index) {
+	const { keys } = index;
+	const name = defaultMongoIndexName(keys);
+	const keyFilter = isTextIndex(keys) ? MongoFieldFilter.eq("key._fts", "text") : MongoFieldFilter.eq("key", keysToKeySpec(keys));
+	const fullFilter = index.unique ? MongoAndExpr.of([keyFilter, MongoFieldFilter.eq("unique", true)]) : keyFilter;
+	return {
+		id: buildIndexOpId("create", collection, keys),
+		label: `Create index on ${collection} (${formatKeys(keys)})`,
+		operationClass: "additive",
+		precheck: [{
+			description: `index does not already exist on ${collection}`,
+			source: new ListIndexesCommand(collection),
+			filter: keyFilter,
+			expect: "notExists"
+		}],
+		execute: [{
+			description: `create index on ${collection}`,
+			command: new CreateIndexCommand(collection, keys, {
+				unique: index.unique || void 0,
+				sparse: index.sparse,
+				expireAfterSeconds: index.expireAfterSeconds,
+				partialFilterExpression: index.partialFilterExpression,
+				wildcardProjection: index.wildcardProjection,
+				collation: index.collation,
+				weights: index.weights,
+				default_language: index.default_language,
+				language_override: index.language_override,
+				name
+			})
+		}],
+		postcheck: [{
+			description: `index exists on ${collection}`,
+			source: new ListIndexesCommand(collection),
+			filter: fullFilter,
+			expect: "exists"
+		}]
+	};
+}
+function planDropIndex(collection, index) {
+	const { keys } = index;
+	const indexName = defaultMongoIndexName(keys);
+	const keyFilter = isTextIndex(keys) ? MongoFieldFilter.eq("key._fts", "text") : MongoFieldFilter.eq("key", keysToKeySpec(keys));
+	return {
+		id: buildIndexOpId("drop", collection, keys),
+		label: `Drop index on ${collection} (${formatKeys(keys)})`,
+		operationClass: "destructive",
+		precheck: [{
+			description: `index exists on ${collection}`,
+			source: new ListIndexesCommand(collection),
+			filter: keyFilter,
+			expect: "exists"
+		}],
+		execute: [{
+			description: `drop index on ${collection}`,
+			command: new DropIndexCommand(collection, indexName)
+		}],
+		postcheck: [{
+			description: `index no longer exists on ${collection}`,
+			source: new ListIndexesCommand(collection),
+			filter: keyFilter,
+			expect: "notExists"
+		}]
+	};
+}
+function validatorsEqual(a, b) {
+	if (!a && !b) return true;
+	if (!a || !b) return false;
+	return a.validationLevel === b.validationLevel && a.validationAction === b.validationAction && canonicalize(a.jsonSchema) === canonicalize(b.jsonSchema);
+}
+function classifyValidatorUpdate(origin, dest) {
+	let hasDestructive = false;
+	if (canonicalize(origin.jsonSchema) !== canonicalize(dest.jsonSchema)) hasDestructive = true;
+	if (origin.validationAction !== dest.validationAction) {
+		if (dest.validationAction === "error") hasDestructive = true;
+	}
+	if (origin.validationLevel !== dest.validationLevel) {
+		if (dest.validationLevel === "strict") hasDestructive = true;
+	}
+	return hasDestructive ? "destructive" : "widening";
+}
+function planValidatorDiff(collName, originValidator, destValidator) {
+	if (validatorsEqual(originValidator, destValidator)) return void 0;
+	const collExistsPrecheck = {
+		description: `collection ${collName} exists`,
+		source: new ListCollectionsCommand(),
+		filter: MongoFieldFilter.eq("name", collName),
+		expect: "exists"
+	};
+	if (destValidator) {
+		const operationClass = originValidator ? classifyValidatorUpdate(originValidator, destValidator) : "destructive";
+		return {
+			id: `validator.${collName}.${originValidator ? "update" : "add"}`,
+			label: `${originValidator ? "Update" : "Add"} validator on ${collName}`,
+			operationClass,
+			precheck: [collExistsPrecheck],
+			execute: [{
+				description: `set validator on ${collName}`,
+				command: new CollModCommand(collName, {
+					validator: { $jsonSchema: destValidator.jsonSchema },
+					validationLevel: destValidator.validationLevel,
+					validationAction: destValidator.validationAction
+				})
+			}],
+			postcheck: [{
+				description: `validator applied on ${collName}`,
+				source: new ListCollectionsCommand(),
+				filter: MongoAndExpr.of([
+					MongoFieldFilter.eq("name", collName),
+					MongoFieldFilter.eq("options.validationLevel", destValidator.validationLevel),
+					MongoFieldFilter.eq("options.validationAction", destValidator.validationAction)
+				]),
+				expect: "exists"
+			}]
+		};
+	}
+	return {
+		id: `validator.${collName}.remove`,
+		label: `Remove validator on ${collName}`,
+		operationClass: "widening",
+		precheck: [collExistsPrecheck],
+		execute: [{
+			description: `remove validator on ${collName}`,
+			command: new CollModCommand(collName, {
+				validator: {},
+				validationLevel: "strict",
+				validationAction: "error"
+			})
+		}],
+		postcheck: []
+	};
+}
+function hasImmutableOptionChange(origin, dest) {
+	if (canonicalize(origin?.capped) !== canonicalize(dest?.capped)) return "capped";
+	if (canonicalize(origin?.timeseries) !== canonicalize(dest?.timeseries)) return "timeseries";
+	if (canonicalize(origin?.collation) !== canonicalize(dest?.collation)) return "collation";
+	if (canonicalize(origin?.clusteredIndex) !== canonicalize(dest?.clusteredIndex)) return "clusteredIndex";
+}
+function planCreateCollection(collName, dest) {
+	const opts = dest.options;
+	const validator = dest.validator;
+	return {
+		id: `collection.${collName}.create`,
+		label: `Create collection ${collName}`,
+		operationClass: "additive",
+		precheck: [{
+			description: `collection ${collName} does not exist`,
+			source: new ListCollectionsCommand(),
+			filter: MongoFieldFilter.eq("name", collName),
+			expect: "notExists"
+		}],
+		execute: [{
+			description: `create collection ${collName}`,
+			command: new CreateCollectionCommand(collName, {
+				capped: opts?.capped ? true : void 0,
+				size: opts?.capped?.size,
+				max: opts?.capped?.max,
+				timeseries: opts?.timeseries,
+				collation: opts?.collation,
+				clusteredIndex: opts?.clusteredIndex ? {
+					key: { _id: 1 },
+					unique: true,
+					...opts.clusteredIndex.name != null ? { name: opts.clusteredIndex.name } : {}
+				} : void 0,
+				validator: validator ? { $jsonSchema: validator.jsonSchema } : void 0,
+				validationLevel: validator?.validationLevel,
+				validationAction: validator?.validationAction,
+				changeStreamPreAndPostImages: opts?.changeStreamPreAndPostImages
+			})
+		}],
+		postcheck: []
+	};
+}
+function planDropCollection(collName) {
+	return {
+		id: `collection.${collName}.drop`,
+		label: `Drop collection ${collName}`,
+		operationClass: "destructive",
+		precheck: [],
+		execute: [{
+			description: `drop collection ${collName}`,
+			command: new DropCollectionCommand(collName)
+		}],
+		postcheck: []
+	};
+}
+function planMutableOptionsDiff(collName, origin, dest) {
+	const originCSPPI = origin?.changeStreamPreAndPostImages;
+	const destCSPPI = dest?.changeStreamPreAndPostImages;
+	if (deepEqual(originCSPPI, destCSPPI)) return void 0;
+	return {
+		id: `options.${collName}.update`,
+		label: `Update mutable options on ${collName}`,
+		operationClass: destCSPPI?.enabled ? "widening" : "destructive",
+		precheck: [],
+		execute: [{
+			description: `update options on ${collName}`,
+			command: new CollModCommand(collName, { changeStreamPreAndPostImages: destCSPPI })
+		}],
+		postcheck: []
+	};
+}
+function collectionHasOptions(coll) {
+	return !!(coll.options || coll.validator);
+}
+var MongoMigrationPlanner = class {
+	plan(options) {
+		const contract = options.contract;
+		const originIR = options.schema;
+		const destinationIR = contractToMongoSchemaIR(contract);
+		const collCreates = [];
+		const drops = [];
+		const creates = [];
+		const validatorOps = [];
+		const mutableOptionOps = [];
+		const collDrops = [];
+		const conflicts = [];
+		const allCollectionNames = new Set([...originIR.collectionNames, ...destinationIR.collectionNames]);
+		for (const collName of [...allCollectionNames].sort()) {
+			const originColl = originIR.collection(collName);
+			const destColl = destinationIR.collection(collName);
+			if (!originColl && destColl) {
+				if (collectionHasOptions(destColl)) collCreates.push(planCreateCollection(collName, destColl));
+			} else if (originColl && !destColl) collDrops.push(planDropCollection(collName));
+			else if (originColl && destColl) {
+				const immutableChange = hasImmutableOptionChange(originColl.options, destColl.options);
+				if (immutableChange) conflicts.push({
+					kind: "policy-violation",
+					summary: `Cannot change immutable collection option '${immutableChange}' on ${collName}`,
+					why: `MongoDB does not support modifying the '${immutableChange}' option after collection creation`
+				});
+				const mutableOp = planMutableOptionsDiff(collName, originColl.options, destColl.options);
+				if (mutableOp) mutableOptionOps.push(mutableOp);
+				const validatorOp = planValidatorDiff(collName, originColl.validator, destColl.validator);
+				if (validatorOp) validatorOps.push(validatorOp);
+			}
+			const originLookup = /* @__PURE__ */ new Map();
+			if (originColl) for (const idx of originColl.indexes) originLookup.set(buildIndexLookupKey(idx), idx);
+			const destLookup = /* @__PURE__ */ new Map();
+			if (destColl) for (const idx of destColl.indexes) destLookup.set(buildIndexLookupKey(idx), idx);
+			for (const [lookupKey, idx] of originLookup) if (!destLookup.has(lookupKey)) drops.push(planDropIndex(collName, idx));
+			for (const [lookupKey, idx] of destLookup) if (!originLookup.has(lookupKey)) creates.push(planCreateIndex(collName, idx));
+		}
+		if (conflicts.length > 0) return {
+			kind: "failure",
+			conflicts
+		};
+		const allOps = [
+			...collCreates,
+			...drops,
+			...creates,
+			...validatorOps,
+			...mutableOptionOps,
+			...collDrops
+		];
+		for (const op of allOps) if (!options.policy.allowedOperationClasses.includes(op.operationClass)) conflicts.push({
+			kind: "policy-violation",
+			summary: `${op.operationClass} operation disallowed: ${op.label}`,
+			why: `Policy does not allow '${op.operationClass}' operations`
+		});
+		if (conflicts.length > 0) return {
+			kind: "failure",
+			conflicts
+		};
+		return {
+			kind: "success",
+			plan: {
+				targetId: "mongo",
+				destination: { storageHash: contract.storage.storageHash },
+				operations: allOps
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/core/filter-evaluator.ts
+function getNestedField(doc, path) {
+	const parts = path.split(".");
+	let current = doc;
+	for (const part of parts) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		const record = current;
+		if (!Object.hasOwn(record, part)) return;
+		current = record[part];
+	}
+	return current;
+}
+function evaluateFieldOp(op, actual, expected) {
+	switch (op) {
+		case "$eq": return deepEqual(actual, expected);
+		case "$ne": return !deepEqual(actual, expected);
+		case "$gt": return typeof actual === typeof expected && actual > expected;
+		case "$gte": return typeof actual === typeof expected && actual >= expected;
+		case "$lt": return typeof actual === typeof expected && actual < expected;
+		case "$lte": return typeof actual === typeof expected && actual <= expected;
+		case "$in": return Array.isArray(expected) && expected.some((v) => deepEqual(actual, v));
+		default: throw new Error(`Unsupported filter operator in migration check: ${op}`);
+	}
+}
+var FilterEvaluator = class {
+	doc = {};
+	evaluate(filter, doc) {
+		this.doc = doc;
+		return filter.accept(this);
+	}
+	field(expr) {
+		const value = getNestedField(this.doc, expr.field);
+		return evaluateFieldOp(expr.op, value, expr.value);
+	}
+	and(expr) {
+		return expr.exprs.every((child) => child.accept(this));
+	}
+	or(expr) {
+		return expr.exprs.some((child) => child.accept(this));
+	}
+	not(expr) {
+		return !expr.expr.accept(this);
+	}
+	exists(expr) {
+		const has = getNestedField(this.doc, expr.field) !== void 0;
+		return expr.exists ? has : !has;
+	}
+	expr(_expr) {
+		throw new Error("Aggregation expression filters are not supported in migration checks");
+	}
+};
+
+//#endregion
+//#region src/core/mongo-runner.ts
+function runnerFailure(code, summary, opts) {
+	return notOk({
+		code,
+		summary,
+		...opts
+	});
+}
+function isMongoControlDriverInstance(driver) {
+	return "db" in driver && driver.db != null;
+}
+function extractDb(driver) {
+	if (!isMongoControlDriverInstance(driver)) throw new Error("Mongo control driver does not expose a db property. Use mongoControlDriver.create() from `@prisma-next/driver-mongo/control`.");
+	return driver.db;
+}
+var MongoMigrationRunner = class {
+	async execute(options) {
+		const db = extractDb(options.driver);
+		const operations = deserializeMongoOps(options.plan.operations);
+		const policyCheck = this.enforcePolicyCompatibility(options.policy, operations);
+		if (policyCheck) return policyCheck;
+		const existingMarker = await readMarker$1(db);
+		const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
+		if (markerCheck) return markerCheck;
+		const checks = options.executionChecks;
+		const runPrechecks = checks?.prechecks !== false;
+		const runPostchecks = checks?.postchecks !== false;
+		const runIdempotency = checks?.idempotencyChecks !== false;
+		const commandExecutor = new MongoCommandExecutor(db);
+		const inspectionExecutor = new MongoInspectionExecutor(db);
+		const filterEvaluator = new FilterEvaluator();
+		let operationsExecuted = 0;
+		for (const operation of operations) {
+			options.callbacks?.onOperationStart?.(operation);
+			try {
+				if (runPostchecks && runIdempotency) {
+					if (await this.allChecksSatisfied(operation.postcheck, inspectionExecutor, filterEvaluator)) continue;
+				}
+				if (runPrechecks) {
+					if (!await this.evaluateChecks(operation.precheck, inspectionExecutor, filterEvaluator)) return runnerFailure("PRECHECK_FAILED", `Operation ${operation.id} failed during precheck`, { meta: { operationId: operation.id } });
+				}
+				for (const step of operation.execute) await step.command.accept(commandExecutor);
+				if (runPostchecks) {
+					if (!await this.evaluateChecks(operation.postcheck, inspectionExecutor, filterEvaluator)) return runnerFailure("POSTCHECK_FAILED", `Operation ${operation.id} failed during postcheck`, { meta: { operationId: operation.id } });
+				}
+				operationsExecuted += 1;
+			} finally {
+				options.callbacks?.onOperationComplete?.(operation);
+			}
+		}
+		const destination = options.plan.destination;
+		const profileHash = options.destinationContract.profileHash ?? destination.storageHash;
+		if (operationsExecuted === 0 && existingMarker?.storageHash === destination.storageHash && existingMarker.profileHash === profileHash) return ok({
+			operationsPlanned: operations.length,
+			operationsExecuted
+		});
+		if (existingMarker) {
+			if (!await updateMarker$1(db, existingMarker.storageHash, {
+				storageHash: destination.storageHash,
+				profileHash
+			})) return runnerFailure("MARKER_CAS_FAILURE", "Marker was modified by another process during migration execution.", { meta: {
+				expectedStorageHash: existingMarker.storageHash,
+				destinationStorageHash: destination.storageHash
+			} });
+		} else await initMarker$1(db, {
+			storageHash: destination.storageHash,
+			profileHash
+		});
+		const originHash = existingMarker?.storageHash ?? "";
+		await writeLedgerEntry$1(db, {
+			edgeId: `${originHash}->${destination.storageHash}`,
+			from: originHash,
+			to: destination.storageHash
+		});
+		return ok({
+			operationsPlanned: operations.length,
+			operationsExecuted
+		});
+	}
+	async evaluateChecks(checks, inspectionExecutor, filterEvaluator) {
+		for (const check of checks) {
+			const matchFound = (await check.source.accept(inspectionExecutor)).some((doc) => filterEvaluator.evaluate(check.filter, doc));
+			if (!(check.expect === "exists" ? matchFound : !matchFound)) return false;
+		}
+		return true;
+	}
+	async allChecksSatisfied(checks, inspectionExecutor, filterEvaluator) {
+		if (checks.length === 0) return false;
+		return this.evaluateChecks(checks, inspectionExecutor, filterEvaluator);
+	}
+	enforcePolicyCompatibility(policy, operations) {
+		const allowedClasses = new Set(policy.allowedOperationClasses);
+		for (const operation of operations) if (!allowedClasses.has(operation.operationClass)) return runnerFailure("POLICY_VIOLATION", `Operation ${operation.id} has class "${operation.operationClass}" which is not allowed by policy.`, {
+			why: `Policy only allows: ${[...allowedClasses].join(", ")}.`,
+			meta: {
+				operationId: operation.id,
+				operationClass: operation.operationClass
+			}
+		});
+	}
+	ensureMarkerCompatibility(marker, plan) {
+		const origin = plan.origin ?? null;
+		if (!origin) {
+			if (marker) return runnerFailure("MARKER_ORIGIN_MISMATCH", "Database already has a contract marker but the plan has no origin. This would silently overwrite the existing marker.", { meta: { markerStorageHash: marker.storageHash } });
+			return;
+		}
+		if (!marker) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Missing contract marker: expected origin storage hash ${origin.storageHash}.`, { meta: { expectedOriginStorageHash: origin.storageHash } });
+		if (marker.storageHash !== origin.storageHash) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`, { meta: {
+			markerStorageHash: marker.storageHash,
+			expectedOriginStorageHash: origin.storageHash
+		} });
+	}
+};
 
 //#endregion
 //#region src/exports/control.ts
@@ -72,6 +985,7 @@ const mongoAdapterDescriptor = {
 		codecInstances: [
 			mongoObjectIdCodec,
 			mongoStringCodec,
+			mongoDoubleCodec,
 			mongoInt32Codec,
 			mongoBooleanCodec,
 			mongoDateCodec,
@@ -98,5 +1012,5 @@ const mongoAdapterDescriptor = {
 var control_default = mongoAdapterDescriptor;
 
 //#endregion
-export { control_default as default };
+export { MongoCommandExecutor, MongoInspectionExecutor, MongoMigrationPlanner, MongoMigrationRunner, contractToMongoSchemaIR, createMongoControlDriver, control_default as default, deserializeMongoOps, formatMongoOperations, initMarker, introspectSchema, readMarker, serializeMongoOps, updateMarker, writeLedgerEntry };
 //# sourceMappingURL=control.mjs.map