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

package/dist/control.mjs

@@ -1,10 +1,8 @@
-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 { a as mongoObjectIdCodec, i as mongoInt32Codec, n as mongoDateCodec, o as mongoStringCodec, r as mongoDoubleCodec, s as mongoVectorCodec, t as mongoBooleanCodec } from "./codecs-DGN3pWRt.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";
+import { keysToKeySpec } from "@prisma-next/mongo-query-ast/control";
+import { MongoSchemaCollection, MongoSchemaCollectionOptions, MongoSchemaIR, MongoSchemaIndex, MongoSchemaValidator } from "@prisma-next/mongo-schema-ir";
+import { initMarker, readMarker, updateMarker, writeLedgerEntry } from "@prisma-next/target-mongo/control";
 
 //#region src/core/command-executor.ts
 var MongoCommandExecutor = class {
@@ -72,116 +70,6 @@ var MongoInspectionExecutor = class {
 	}
 };
 
-//#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";
@@ -252,10 +140,10 @@ async function introspectSchema(db) {
 	const collections = [];
 	for (const info of collectionInfos) {
 		const name = info["name"];
-		const type$1 = info["type"];
+		const type = info["type"];
 		if (name === PRISMA_MIGRATIONS_COLLECTION) continue;
 		if (name.startsWith("system.")) continue;
-		if (type$1 === "view") continue;
+		if (type === "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);
@@ -292,686 +180,25 @@ function createMongoControlDriver(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 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) {
-		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: []
-	};
+//#region src/core/runner-deps.ts
+function extractDb(driver) {
+	const mongoDriver = driver;
+	if (!mongoDriver.db) throw new Error("Mongo control driver does not expose a db property. Use mongoControlDriver.create() from `@prisma-next/driver-mongo/control`.");
+	return mongoDriver.db;
 }
-function planMutableOptionsDiff(collName, origin, dest) {
-	const originCSPPI = origin?.changeStreamPreAndPostImages;
-	const destCSPPI = dest?.changeStreamPreAndPostImages;
-	if (deepEqual(originCSPPI, destCSPPI)) return void 0;
+function createMongoRunnerDeps(driver) {
+	const db = extractDb(driver);
 	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));
+		commandExecutor: new MongoCommandExecutor(db),
+		inspectionExecutor: new MongoInspectionExecutor(db),
+		markerOps: {
+			readMarker: () => readMarker(db),
+			initMarker: (dest) => initMarker(db, dest),
+			updateMarker: (expectedFrom, dest) => updateMarker(db, expectedFrom, dest),
+			writeLedgerEntry: (entry) => writeLedgerEntry(db, entry)
 		}
-		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
@@ -981,6 +208,14 @@ const mongoAdapterDescriptor = {
 	familyId: "mongo",
 	targetId: "mongo",
 	version: "0.0.1",
+	scalarTypeDescriptors: new Map([
+		["String", "mongo/string@1"],
+		["Int", "mongo/int32@1"],
+		["Boolean", "mongo/bool@1"],
+		["DateTime", "mongo/date@1"],
+		["ObjectId", "mongo/objectId@1"],
+		["Float", "mongo/double@1"]
+	]),
 	types: { codecTypes: {
 		codecInstances: [
 			mongoObjectIdCodec,
@@ -1012,5 +247,5 @@ const mongoAdapterDescriptor = {
 var control_default = mongoAdapterDescriptor;
 
 //#endregion
-export { MongoCommandExecutor, MongoInspectionExecutor, MongoMigrationPlanner, MongoMigrationRunner, contractToMongoSchemaIR, createMongoControlDriver, control_default as default, deserializeMongoOps, formatMongoOperations, initMarker, introspectSchema, readMarker, serializeMongoOps, updateMarker, writeLedgerEntry };
+export { MongoCommandExecutor, MongoInspectionExecutor, createMongoControlDriver, createMongoRunnerDeps, control_default as default, introspectSchema };
 //# sourceMappingURL=control.mjs.map