@prisma-next/target-mongo 0.4.0-dev.1 → 0.4.0-dev.3

package/dist/control.mjs

@@ -1,5 +1,173 @@
+import { a as dropIndex, i as dropCollection, n as createCollection, r as createIndex, t as collMod } from "./migration-factories-Brzz-QGG.mjs";
+import { MongoSchemaCollection, MongoSchemaCollectionOptions, MongoSchemaIR, MongoSchemaIndex, MongoSchemaValidator, canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
 import { RawAggregateCommand, RawFindOneAndUpdateCommand, RawInsertOneCommand } from "@prisma-next/mongo-query-ast/execution";
+import { CollModCommand, CreateCollectionCommand, CreateIndexCommand, DropCollectionCommand, DropIndexCommand, ListCollectionsCommand, ListIndexesCommand, MongoAndExpr, MongoExistsExpr, MongoFieldFilter, MongoNotExpr, MongoOrExpr } from "@prisma-next/mongo-query-ast/control";
+import { type } from "arktype";
+import { notOk, ok } from "@prisma-next/utils/result";
 
+//#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/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/marker-ledger.ts
 const COLLECTION = "_prisma_migrations";
 const MARKER_ID = "marker";
@@ -58,5 +226,741 @@ async function writeLedgerEntry(db, entry) {
 }
 
 //#endregion
-export { initMarker, readMarker, updateMarker, writeLedgerEntry };
+//#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 DropIndexJson = type({
+	kind: "\"dropIndex\"",
+	collection: "string",
+	name: "string"
+});
+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 DropCollectionJson = type({
+	kind: "\"dropCollection\"",
+	collection: "string"
+});
+const CollModJson = type({
+	kind: "\"collMod\"",
+	collection: "string",
+	"validator?": "Record<string, unknown>",
+	"validationLevel?": "\"strict\" | \"moderate\"",
+	"validationAction?": "\"error\" | \"warn\"",
+	"changeStreamPreAndPostImages?": "Record<string, unknown>"
+});
+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) {
+		/* v8 ignore start -- assertion libraries always throw Error instances */
+		const message = error instanceof Error ? error.message : String(error);
+		/* v8 ignore stop */
+		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/op-factory-call.ts
+var OpFactoryCallNode = class {
+	freeze() {
+		Object.freeze(this);
+	}
+};
+function formatKeys(keys) {
+	return keys.map((k) => `${k.field}:${k.direction}`).join(", ");
+}
+var CreateIndexCall = class extends OpFactoryCallNode {
+	factory = "createIndex";
+	operationClass = "additive";
+	collection;
+	keys;
+	options;
+	label;
+	constructor(collection, keys, options) {
+		super();
+		this.collection = collection;
+		this.keys = keys;
+		this.options = options;
+		this.label = `Create index on ${collection} (${formatKeys(keys)})`;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.createIndex(this);
+	}
+};
+var DropIndexCall = class extends OpFactoryCallNode {
+	factory = "dropIndex";
+	operationClass = "destructive";
+	collection;
+	keys;
+	label;
+	constructor(collection, keys) {
+		super();
+		this.collection = collection;
+		this.keys = keys;
+		this.label = `Drop index on ${collection} (${formatKeys(keys)})`;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.dropIndex(this);
+	}
+};
+var CreateCollectionCall = class extends OpFactoryCallNode {
+	factory = "createCollection";
+	operationClass = "additive";
+	collection;
+	options;
+	label;
+	constructor(collection, options) {
+		super();
+		this.collection = collection;
+		this.options = options;
+		this.label = `Create collection ${collection}`;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.createCollection(this);
+	}
+};
+var DropCollectionCall = class extends OpFactoryCallNode {
+	factory = "dropCollection";
+	operationClass = "destructive";
+	collection;
+	label;
+	constructor(collection) {
+		super();
+		this.collection = collection;
+		this.label = `Drop collection ${collection}`;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.dropCollection(this);
+	}
+};
+var CollModCall = class extends OpFactoryCallNode {
+	factory = "collMod";
+	collection;
+	options;
+	meta;
+	operationClass;
+	label;
+	constructor(collection, options, meta) {
+		super();
+		this.collection = collection;
+		this.options = options;
+		this.meta = meta;
+		this.operationClass = meta?.operationClass ?? "destructive";
+		this.label = meta?.label ?? `Modify collection ${collection}`;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.collMod(this);
+	}
+};
+function schemaIndexToCreateIndexOptions(index) {
+	return {
+		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
+	};
+}
+function schemaCollectionToCreateCollectionOptions(coll) {
+	const opts = coll.options;
+	const validator = coll.validator;
+	if (!opts && !validator) return void 0;
+	return {
+		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
+	};
+}
+
+//#endregion
+//#region src/core/render-ops.ts
+const renderVisitor = {
+	createIndex(call) {
+		return createIndex(call.collection, call.keys, call.options);
+	},
+	dropIndex(call) {
+		return dropIndex(call.collection, call.keys);
+	},
+	createCollection(call) {
+		return createCollection(call.collection, call.options);
+	},
+	dropCollection(call) {
+		return dropCollection(call.collection);
+	},
+	collMod(call) {
+		return collMod(call.collection, call.options, call.meta);
+	}
+};
+function renderOps(calls) {
+	return calls.map((call) => call.accept(renderVisitor));
+}
+
+//#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 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 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 collectionHasOptions(coll) {
+	return !!(coll.options || coll.validator);
+}
+var MongoMigrationPlanner = class {
+	planCalls(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) {
+				if (destColl && collectionHasOptions(destColl)) {
+					const opts = schemaCollectionToCreateCollectionOptions(destColl);
+					collCreates.push(new CreateCollectionCall(collName, opts));
+				}
+			} else if (!destColl) collDrops.push(new DropCollectionCall(collName));
+			else {
+				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 mutableCall = planMutableOptionsDiffCall(collName, originColl.options, destColl.options);
+				if (mutableCall) mutableOptionOps.push(mutableCall);
+				const validatorCall = planValidatorDiffCall(collName, originColl.validator, destColl.validator);
+				if (validatorCall) validatorOps.push(validatorCall);
+			}
+			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(new DropIndexCall(collName, idx.keys));
+			for (const [lookupKey, idx] of destLookup) if (!originLookup.has(lookupKey)) creates.push(new CreateIndexCall(collName, idx.keys, schemaIndexToCreateIndexOptions(idx)));
+		}
+		if (conflicts.length > 0) return {
+			kind: "failure",
+			conflicts
+		};
+		const allCalls = [
+			...collCreates,
+			...drops,
+			...creates,
+			...validatorOps,
+			...mutableOptionOps,
+			...collDrops
+		];
+		for (const call of allCalls) if (!options.policy.allowedOperationClasses.includes(call.operationClass)) conflicts.push({
+			kind: "policy-violation",
+			summary: `${call.operationClass} operation disallowed: ${call.label}`,
+			why: `Policy does not allow '${call.operationClass}' operations`
+		});
+		if (conflicts.length > 0) return {
+			kind: "failure",
+			conflicts
+		};
+		return {
+			kind: "success",
+			calls: allCalls
+		};
+	}
+	plan(options) {
+		const contract = options.contract;
+		const result = this.planCalls(options);
+		if (result.kind === "failure") return result;
+		return {
+			kind: "success",
+			plan: {
+				targetId: "mongo",
+				destination: { storageHash: contract.storage.storageHash },
+				operations: renderOps(result.calls)
+			}
+		};
+	}
+};
+function planValidatorDiffCall(collName, originValidator, destValidator) {
+	if (validatorsEqual(originValidator, destValidator)) return void 0;
+	if (destValidator) {
+		const operationClass = originValidator ? classifyValidatorUpdate(originValidator, destValidator) : "destructive";
+		return new CollModCall(collName, {
+			validator: { $jsonSchema: destValidator.jsonSchema },
+			validationLevel: destValidator.validationLevel,
+			validationAction: destValidator.validationAction
+		}, {
+			id: `validator.${collName}.${originValidator ? "update" : "add"}`,
+			label: `${originValidator ? "Update" : "Add"} validator on ${collName}`,
+			operationClass
+		});
+	}
+	return new CollModCall(collName, {
+		validator: {},
+		validationLevel: "strict",
+		validationAction: "error"
+	}, {
+		id: `validator.${collName}.remove`,
+		label: `Remove validator on ${collName}`,
+		operationClass: "widening"
+	});
+}
+function planMutableOptionsDiffCall(collName, origin, dest) {
+	const originCSPPI = origin?.changeStreamPreAndPostImages;
+	const destCSPPI = dest?.changeStreamPreAndPostImages;
+	if (deepEqual(originCSPPI, destCSPPI)) return void 0;
+	const desiredCSPPI = destCSPPI ?? { enabled: false };
+	return new CollModCall(collName, { changeStreamPreAndPostImages: desiredCSPPI }, {
+		id: `options.${collName}.update`,
+		label: `Update mutable options on ${collName}`,
+		operationClass: desiredCSPPI.enabled ? "widening" : "destructive"
+	});
+}
+
+//#endregion
+//#region src/core/mongo-runner.ts
+function runnerFailure(code, summary, opts) {
+	return notOk({
+		code,
+		summary,
+		...opts
+	});
+}
+var MongoMigrationRunner = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async execute(options) {
+		const { commandExecutor, inspectionExecutor, markerOps } = this.deps;
+		const operations = deserializeMongoOps(options.plan.operations);
+		const policyCheck = this.enforcePolicyCompatibility(options.policy, operations);
+		if (policyCheck) return policyCheck;
+		const existingMarker = await markerOps.readMarker();
+		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 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 markerOps.updateMarker(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 markerOps.initMarker({
+			storageHash: destination.storageHash,
+			profileHash
+		});
+		const originHash = existingMarker?.storageHash ?? "";
+		await markerOps.writeLedgerEntry({
+			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/core/render-typescript.ts
+function renderTypeScript(calls, meta) {
+	const imports = buildImports(collectFactoryNames(calls));
+	const planBody = calls.map((c) => c.accept(renderCallVisitor)).join(",\n");
+	return [
+		imports,
+		"",
+		"class M extends Migration {",
+		meta ? buildDescribeMethod(meta) : "",
+		"  override plan() {",
+		"    return [",
+		indent(planBody, 6),
+		"    ];",
+		"  }",
+		"}",
+		"",
+		"export default M;",
+		"Migration.run(import.meta.url, M);",
+		""
+	].join("\n");
+}
+function collectFactoryNames(calls) {
+	const names = /* @__PURE__ */ new Set();
+	for (const call of calls) names.add(call.factory);
+	return [...names].sort();
+}
+function buildImports(factoryNames) {
+	const lines = ["import { Migration } from '@prisma-next/family-mongo/migration';"];
+	if (factoryNames.length > 0) lines.push(`import { ${factoryNames.join(", ")} } from '@prisma-next/target-mongo/migration';`);
+	return lines.join("\n");
+}
+function buildDescribeMethod(meta) {
+	const lines = [];
+	lines.push("  override describe() {");
+	lines.push("    return {");
+	lines.push(`      from: ${JSON.stringify(meta.from)},`);
+	lines.push(`      to: ${JSON.stringify(meta.to)},`);
+	if (meta.kind) lines.push(`      kind: ${JSON.stringify(meta.kind)},`);
+	if (meta.labels && meta.labels.length > 0) lines.push(`      labels: ${renderLiteral(meta.labels)},`);
+	lines.push("    };");
+	lines.push("  }");
+	lines.push("");
+	return lines.join("\n");
+}
+const renderCallVisitor = {
+	createIndex(call) {
+		return call.options ? `createIndex(${renderLiteral(call.collection)}, ${renderLiteral(call.keys)}, ${renderLiteral(call.options)})` : `createIndex(${renderLiteral(call.collection)}, ${renderLiteral(call.keys)})`;
+	},
+	dropIndex(call) {
+		return `dropIndex(${renderLiteral(call.collection)}, ${renderLiteral(call.keys)})`;
+	},
+	createCollection(call) {
+		return call.options ? `createCollection(${renderLiteral(call.collection)}, ${renderLiteral(call.options)})` : `createCollection(${renderLiteral(call.collection)})`;
+	},
+	dropCollection(call) {
+		return `dropCollection(${renderLiteral(call.collection)})`;
+	},
+	collMod(call) {
+		return call.meta ? `collMod(${renderLiteral(call.collection)}, ${renderLiteral(call.options)}, ${renderLiteral(call.meta)})` : `collMod(${renderLiteral(call.collection)}, ${renderLiteral(call.options)})`;
+	}
+};
+function renderLiteral(value) {
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		const items = value.map((v) => renderLiteral(v));
+		const singleLine = `[${items.join(", ")}]`;
+		if (singleLine.length <= 80) return singleLine;
+		return `[\n${items.map((i) => `  ${i}`).join(",\n")},\n]`;
+	}
+	if (typeof value === "object") {
+		const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+		if (entries.length === 0) return "{}";
+		const items = entries.map(([k, v]) => `${renderKey(k)}: ${renderLiteral(v)}`);
+		const singleLine = `{ ${items.join(", ")} }`;
+		if (singleLine.length <= 80) return singleLine;
+		return `{\n${items.map((i) => `  ${i}`).join(",\n")},\n}`;
+	}
+	return String(value);
+}
+function renderKey(key) {
+	if (key === "__proto__") return JSON.stringify(key);
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function indent(text, spaces) {
+	const pad = " ".repeat(spaces);
+	return text.split("\n").map((line) => line.trim() ? `${pad}${line}` : line).join("\n");
+}
+
+//#endregion
+export { CollModCall, CreateCollectionCall, CreateIndexCall, DropCollectionCall, DropIndexCall, FilterEvaluator, MongoMigrationPlanner, MongoMigrationRunner, contractToMongoSchemaIR, deserializeMongoOp, deserializeMongoOps, formatMongoOperations, initMarker, readMarker, renderOps, renderTypeScript, schemaCollectionToCreateCollectionOptions, schemaIndexToCreateIndexOptions, serializeMongoOps, updateMarker, writeLedgerEntry };
 //# sourceMappingURL=control.mjs.map