@prisma-next/family-mongo 0.7.0 → 0.8.0-dev.2

package/dist/control.mjs

@@ -1,16 +1,90 @@
+import { i as contractToMongoSchemaIR, n as canonicalizeSchemasForVerification, r as diffMongoSchemas, t as verifyMongoSchema } from "./verify-mongo-schema-BL7t9YTB.mjs";
+import { t as MongoContractSerializer } from "./mongo-contract-serializer-Co3EaTVj.mjs";
 import { mongoEmission } from "@prisma-next/mongo-emitter";
-import { createMongoRunnerDeps, extractDb, introspectSchema } from "@prisma-next/adapter-mongo/control";
 import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH } from "@prisma-next/framework-components/control";
 import { assertDescriptorSelfConsistency } from "@prisma-next/migration-tools/spaces";
-import { validateMongoContract } from "@prisma-next/mongo-contract";
-import { MongoMigrationPlanner, MongoMigrationRunner, contractToMongoSchemaIR, formatMongoOperations, initMarker, readAllMarkers, readMarker, updateMarker } from "@prisma-next/target-mongo/control";
-import { verifyMongoSchema } from "@prisma-next/target-mongo/schema-verify";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { MongoDriverImpl } from "@prisma-next/driver-mongo";
-import { projectSchemaToSpace } from "@prisma-next/migration-tools/aggregate";
-import { MongoSchemaIR } from "@prisma-next/mongo-schema-ir";
-import mongoTargetDescriptorMeta from "@prisma-next/target-mongo/pack";
-import { notOk, ok } from "@prisma-next/utils/result";
+//#region src/core/operation-preview.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;
+}
+/**
+* Wraps `formatMongoOperations` into the family-agnostic
+* `OperationPreview` shape. Each statement carries
+* `language: 'mongodb-shell'`. Mirrors `sqlOperationsToPreview`.
+*/
+function mongoOperationsToPreview(operations) {
+	return { statements: formatMongoOperations(operations).map((text) => ({
+		text,
+		language: "mongodb-shell"
+	})) };
+}
+//#endregion
 //#region src/core/schema-to-view.ts
 function mongoSchemaToView(schema) {
 	const collectionNodes = schema.collections.map((collection) => collectionToSchemaNode(collection.name, collection));
@@ -104,170 +178,29 @@ function collectionToSchemaNode(name, collection) {
 }
 //#endregion
 //#region src/core/control-instance.ts
-function extractDb$1(driver) {
-	const mongoDriver = driver;
-	if (!mongoDriver.db) throw new Error("Mongo control driver does not expose a db property. Use createMongoControlDriver() from @prisma-next/adapter-mongo/control.");
-	return mongoDriver.db;
+function deserializeMongoContract(contractJson) {
+	return new MongoContractSerializer().deserializeContract(contractJson);
+}
+/**
+* Family-method contract input. By the time control-plane methods
+* (`verify`, `verifySchema`, `sign`, …) are invoked through the CLI
+* control client (`client.ts`), the input has already been threaded
+* through `familyInstance.validateContract`. The value is therefore a
+* class-form `MongoTargetContract` (or a structurally-equivalent
+* envelope post-deserialization) and must NOT be re-fed through
+* structural validation (arktype rejects extra keys like `namespaces`).
+*
+* The parameter type on the framework SPI is `unknown` for variance
+* reasons (so the family can express its own contract type without
+* leaking it to the framework). This helper recovers the validated
+* shape with a single narrow cast.
+*/
+function asValidatedMongoContract(contract) {
+	return contract;
+}
+function isMongoControlAdapter(value) {
+	return typeof value === "object" && value !== null && "readMarker" in value && typeof value.readMarker === "function" && "readAllMarkers" in value && typeof value.readAllMarkers === "function" && "introspectSchema" in value && typeof value.introspectSchema === "function";
 }
-var MongoFamilyInstance = class {
-	familyId = "mongo";
-	validateContract(contractJson) {
-		return validateMongoContract(contractJson).contract;
-	}
-	async verify(options) {
-		const { driver, contract: rawContract, expectedTargetId, contractPath, configPath } = options;
-		const startTime = Date.now();
-		const contract = validateMongoContract(rawContract).contract;
-		const contractStorageHash = contract.storage.storageHash;
-		const contractProfileHash = contract.profileHash;
-		const contractTarget = contract.target;
-		const baseOpts = {
-			contractStorageHash,
-			contractProfileHash,
-			expectedTargetId,
-			contractPath,
-			...ifDefined("configPath", configPath)
-		};
-		if (contractTarget !== expectedTargetId) return buildVerifyResult({
-			...baseOpts,
-			ok: false,
-			code: VERIFY_CODE_TARGET_MISMATCH,
-			summary: "Target mismatch",
-			actualTargetId: contractTarget,
-			totalTime: Date.now() - startTime
-		});
-		const marker = await readMarker(extractDb$1(driver), APP_SPACE_ID);
-		if (!marker) return buildVerifyResult({
-			...baseOpts,
-			ok: false,
-			code: VERIFY_CODE_MARKER_MISSING,
-			summary: "Marker missing",
-			totalTime: Date.now() - startTime
-		});
-		if (marker.storageHash !== contractStorageHash) return buildVerifyResult({
-			...baseOpts,
-			ok: false,
-			code: VERIFY_CODE_HASH_MISMATCH,
-			summary: "Hash mismatch",
-			marker,
-			totalTime: Date.now() - startTime
-		});
-		if (contractProfileHash && marker.profileHash !== contractProfileHash) return buildVerifyResult({
-			...baseOpts,
-			ok: false,
-			code: VERIFY_CODE_HASH_MISMATCH,
-			summary: "Hash mismatch",
-			marker,
-			totalTime: Date.now() - startTime
-		});
-		return buildVerifyResult({
-			...baseOpts,
-			ok: true,
-			summary: "Database matches contract",
-			marker,
-			totalTime: Date.now() - startTime
-		});
-	}
-	async schemaVerify(options) {
-		const { driver, contract: rawContract, strict, contractPath, configPath } = options;
-		const contract = validateMongoContract(rawContract).contract;
-		return verifyMongoSchema({
-			contract,
-			schema: await introspectSchema(extractDb$1(driver)),
-			strict,
-			frameworkComponents: options.frameworkComponents,
-			context: {
-				contractPath,
-				...ifDefined("configPath", configPath)
-			}
-		});
-	}
-	schemaVerifyAgainstSchema(options) {
-		return verifyMongoSchema({
-			contract: validateMongoContract(options.contract).contract,
-			schema: options.schema,
-			strict: options.strict,
-			frameworkComponents: options.frameworkComponents
-		});
-	}
-	async sign(options) {
-		const { driver, contract: rawContract, contractPath, configPath } = options;
-		const startTime = Date.now();
-		const contract = validateMongoContract(rawContract).contract;
-		const contractStorageHash = contract.storage.storageHash;
-		const contractProfileHash = contract.profileHash;
-		const db = extractDb$1(driver);
-		const existingMarker = await readMarker(db, APP_SPACE_ID);
-		let markerCreated = false;
-		let markerUpdated = false;
-		let previousHashes;
-		if (!existingMarker) {
-			await initMarker(db, APP_SPACE_ID, {
-				storageHash: contractStorageHash,
-				profileHash: contractProfileHash
-			});
-			markerCreated = true;
-		} else {
-			const storageHashMatches = existingMarker.storageHash === contractStorageHash;
-			const profileHashMatches = existingMarker.profileHash === contractProfileHash;
-			if (!storageHashMatches || !profileHashMatches) {
-				previousHashes = {
-					storageHash: existingMarker.storageHash,
-					profileHash: existingMarker.profileHash
-				};
-				if (!await updateMarker(db, APP_SPACE_ID, existingMarker.storageHash, {
-					storageHash: contractStorageHash,
-					profileHash: contractProfileHash
-				})) throw new Error("CAS conflict: marker was modified by another process during sign");
-				markerUpdated = true;
-			}
-		}
-		let summary;
-		if (markerCreated) summary = "Database signed (marker created)";
-		else if (markerUpdated) summary = `Database signed (marker updated from ${previousHashes?.storageHash ?? "unknown"})`;
-		else summary = "Database already signed with this contract";
-		return {
-			ok: true,
-			summary,
-			contract: {
-				storageHash: contractStorageHash,
-				profileHash: contractProfileHash
-			},
-			target: {
-				expected: contract.target,
-				actual: contract.target
-			},
-			marker: {
-				created: markerCreated,
-				updated: markerUpdated,
-				...ifDefined("previous", previousHashes)
-			},
-			meta: {
-				contractPath,
-				...ifDefined("configPath", configPath)
-			},
-			timings: { total: Date.now() - startTime }
-		};
-	}
-	async readMarker(options) {
-		return readMarker(extractDb$1(options.driver), options.space);
-	}
-	async readAllMarkers(options) {
-		return readAllMarkers(extractDb$1(options.driver));
-	}
-	async introspect(options) {
-		return introspectSchema(extractDb$1(options.driver));
-	}
-	toSchemaView(schema) {
-		return mongoSchemaToView(schema);
-	}
-	toOperationPreview(operations) {
-		return { statements: formatMongoOperations(operations).map((text) => ({
-			text,
-			language: "mongodb-shell"
-		})) };
-	}
-};
 function buildVerifyResult(opts) {
 	return {
 		ok: opts.ok,
@@ -304,7 +237,157 @@ function createMongoFamilyInstance(controlStack) {
 			headRefHash: headRef.hash
 		});
 	}
-	return new MongoFamilyInstance();
+	const adapter = controlStack.adapter;
+	const getControlAdapter = () => {
+		if (!adapter) throw new Error("Mongo family requires an adapter descriptor in ControlStack");
+		const controlAdapter = adapter.create(controlStack);
+		if (!isMongoControlAdapter(controlAdapter)) throw new Error("Adapter does not implement MongoControlAdapter (missing readMarker, readAllMarkers, or introspectSchema)");
+		return controlAdapter;
+	};
+	const asMongoDriver = (driver) => driver;
+	return {
+		familyId: "mongo",
+		validateContract(contractJson) {
+			return deserializeMongoContract(contractJson);
+		},
+		async verify(options) {
+			const { driver, contract: rawContract, expectedTargetId, contractPath, configPath } = options;
+			const startTime = Date.now();
+			const contract = asValidatedMongoContract(rawContract);
+			const contractStorageHash = contract.storage.storageHash;
+			const contractProfileHash = contract.profileHash;
+			const contractTarget = contract.target;
+			const baseOpts = {
+				contractStorageHash,
+				contractProfileHash,
+				expectedTargetId,
+				contractPath,
+				...ifDefined("configPath", configPath)
+			};
+			if (contractTarget !== expectedTargetId) return buildVerifyResult({
+				...baseOpts,
+				ok: false,
+				code: VERIFY_CODE_TARGET_MISMATCH,
+				summary: "Target mismatch",
+				actualTargetId: contractTarget,
+				totalTime: Date.now() - startTime
+			});
+			const marker = await getControlAdapter().readMarker(asMongoDriver(driver), APP_SPACE_ID);
+			if (!marker) return buildVerifyResult({
+				...baseOpts,
+				ok: false,
+				code: VERIFY_CODE_MARKER_MISSING,
+				summary: "Marker missing",
+				totalTime: Date.now() - startTime
+			});
+			if (marker.storageHash !== contractStorageHash) return buildVerifyResult({
+				...baseOpts,
+				ok: false,
+				code: VERIFY_CODE_HASH_MISMATCH,
+				summary: "Hash mismatch",
+				marker,
+				totalTime: Date.now() - startTime
+			});
+			if (contractProfileHash && marker.profileHash !== contractProfileHash) return buildVerifyResult({
+				...baseOpts,
+				ok: false,
+				code: VERIFY_CODE_HASH_MISMATCH,
+				summary: "Hash mismatch",
+				marker,
+				totalTime: Date.now() - startTime
+			});
+			return buildVerifyResult({
+				...baseOpts,
+				ok: true,
+				summary: "Database matches contract",
+				marker,
+				totalTime: Date.now() - startTime
+			});
+		},
+		verifySchema(options) {
+			return verifyMongoSchema({
+				contract: asValidatedMongoContract(options.contract),
+				schema: options.schema,
+				strict: options.strict,
+				frameworkComponents: options.frameworkComponents
+			});
+		},
+		async sign(options) {
+			const { driver, contract: rawContract, contractPath, configPath } = options;
+			const startTime = Date.now();
+			const contract = asValidatedMongoContract(rawContract);
+			const contractStorageHash = contract.storage.storageHash;
+			const contractProfileHash = contract.profileHash;
+			const controlAdapter = getControlAdapter();
+			const mongoDriver = asMongoDriver(driver);
+			const existingMarker = await controlAdapter.readMarker(mongoDriver, APP_SPACE_ID);
+			let markerCreated = false;
+			let markerUpdated = false;
+			let previousHashes;
+			if (!existingMarker) {
+				await controlAdapter.initMarker(mongoDriver, APP_SPACE_ID, {
+					storageHash: contractStorageHash,
+					profileHash: contractProfileHash
+				});
+				markerCreated = true;
+			} else {
+				const storageHashMatches = existingMarker.storageHash === contractStorageHash;
+				const profileHashMatches = existingMarker.profileHash === contractProfileHash;
+				if (!storageHashMatches || !profileHashMatches) {
+					previousHashes = {
+						storageHash: existingMarker.storageHash,
+						profileHash: existingMarker.profileHash
+					};
+					if (!await controlAdapter.updateMarker(mongoDriver, APP_SPACE_ID, existingMarker.storageHash, {
+						storageHash: contractStorageHash,
+						profileHash: contractProfileHash
+					})) throw new Error("CAS conflict: marker was modified by another process during sign");
+					markerUpdated = true;
+				}
+			}
+			let summary;
+			if (markerCreated) summary = "Database signed (marker created)";
+			else if (markerUpdated) summary = `Database signed (marker updated from ${previousHashes?.storageHash ?? "unknown"})`;
+			else summary = "Database already signed with this contract";
+			return {
+				ok: true,
+				summary,
+				contract: {
+					storageHash: contractStorageHash,
+					profileHash: contractProfileHash
+				},
+				target: {
+					expected: contract.target,
+					actual: contract.target
+				},
+				marker: {
+					created: markerCreated,
+					updated: markerUpdated,
+					...ifDefined("previous", previousHashes)
+				},
+				meta: {
+					contractPath,
+					...ifDefined("configPath", configPath)
+				},
+				timings: { total: Date.now() - startTime }
+			};
+		},
+		async readMarker(options) {
+			return getControlAdapter().readMarker(asMongoDriver(options.driver), options.space);
+		},
+		async readAllMarkers(options) {
+			return getControlAdapter().readAllMarkers(asMongoDriver(options.driver));
+		},
+		async introspect(options) {
+			return getControlAdapter().introspectSchema(asMongoDriver(options.driver));
+		},
+		toSchemaView(schema) {
+			return mongoSchemaToView(schema);
+		},
+		toOperationPreview(operations) {
+			return mongoOperationsToPreview(operations);
+		}
+	};
 }
 //#endregion
 //#region src/core/control-descriptor.ts
@@ -320,108 +403,6 @@ var MongoFamilyDescriptor = class {
 };
 const mongoFamilyDescriptor = new MongoFamilyDescriptor();
 //#endregion
-//#region src/core/mongo-target-descriptor.ts
-/**
-* `migration.ts` default-exports a `Migration` subclass whose `operations`
-* getter returns the ordered list of operations and whose `describe()`
-* returns the manifest identity metadata. `MongoMigrationPlanner.plan()`
-* returns a `MigrationPlanWithAuthoringSurface` that knows how to render
-* itself back to such a file; `MongoMigrationPlanner.emptyMigration()`
-* returns the same shape for `migration new`. Users run the scaffolded
-* `migration.ts` directly (via `node migration.ts`) to self-emit
-* `ops.json` and attest the `migrationHash`.
-*/
-const mongoTargetDescriptor = {
-	...mongoTargetDescriptorMeta,
-	migrations: {
-		createPlanner(_family) {
-			return new MongoMigrationPlanner();
-		},
-		createRunner(family) {
-			let cachedDeps;
-			const runMongo = async (driver, runnerOptions) => {
-				cachedDeps ??= createMongoRunnerDeps(driver, MongoDriverImpl.fromDb(extractDb(driver)), family);
-				return new MongoMigrationRunner(cachedDeps).execute({
-					...runnerOptions,
-					destinationContract: runnerOptions.destinationContract
-				});
-			};
-			return {
-				async execute(options) {
-					const { driver, ...runnerOptions } = options;
-					return runMongo(driver, runnerOptions);
-				},
-				async executeAcrossSpaces({ driver, perSpaceOptions }) {
-					const members = perSpaceOptions.map(toSpaceMember);
-					const perSpaceResults = [];
-					for (let i = 0; i < perSpaceOptions.length; i++) {
-						const spaceOptions = perSpaceOptions[i];
-						if (!spaceOptions) continue;
-						const member = members[i];
-						if (!member) continue;
-						const others = members.filter((_, j) => j !== i);
-						const projectSchema = (schema) => {
-							return new MongoSchemaIR(projectSchemaToSpace(schema, member, others).collections);
-						};
-						const result = await runMongo(driver, {
-							...spaceOptions,
-							projectSchema
-						});
-						if (!result.ok) return notOk({
-							...result.failure,
-							failingSpace: spaceOptions.space
-						});
-						perSpaceResults.push({
-							space: spaceOptions.space,
-							value: result.value
-						});
-					}
-					return ok({ perSpaceResults });
-				}
-			};
-		},
-		contractToSchema(contract) {
-			return contractToMongoSchemaIR(contract);
-		}
-	},
-	create() {
-		return {
-			familyId: "mongo",
-			targetId: "mongo"
-		};
-	}
-};
-/**
-* Synthesise the minimum {@link projectSchemaToSpace}-compatible
-* `ContractSpaceMember` shape from a per-space option entry. The
-* projector only reads `spaceId` and `contract.storage`; the rest of
-* `ContractSpaceMember` (head ref invariants, hydrated migration
-* graph) is irrelevant at runner time and stubbed with sentinels.
-*
-* The `as unknown as ContractSpaceMember` cast is the load-bearing bit
-* — the projector duck-types its members so a sentinel-shaped graph
-* never gets read, but the framework type carries a richer shape.
-*/
-function toSpaceMember(opts) {
-	return {
-		spaceId: opts.space,
-		contract: opts.destinationContract,
-		headRef: {
-			hash: "",
-			invariants: []
-		},
-		migrations: {
-			graph: {
-				nodes: /* @__PURE__ */ new Set(),
-				forwardChain: /* @__PURE__ */ new Map(),
-				reverseChain: /* @__PURE__ */ new Map(),
-				migrationByHash: /* @__PURE__ */ new Map()
-			},
-			packagesByMigrationHash: /* @__PURE__ */ new Map()
-		}
-	};
-}
-//#endregion
-export { createMongoFamilyInstance, mongoFamilyDescriptor, mongoTargetDescriptor };
+export { canonicalizeSchemasForVerification, contractToMongoSchemaIR, createMongoFamilyInstance, diffMongoSchemas, formatMongoOperations, mongoFamilyDescriptor, mongoOperationsToPreview };
 
 //# sourceMappingURL=control.mjs.map