@prisma-next/target-mongo 0.5.0-dev.3 → 0.5.0-dev.31

package/dist/migration.mjs

@@ -1,4 +1,4 @@
-import { a as dropCollection, c as validatedCollection, i as dataTransform, n as createCollection, o as dropIndex, r as createIndex, s as setValidation, t as collMod } from "./migration-factories-gwi81C8u.mjs";
+import { a as dropCollection, c as validatedCollection, i as dataTransform, n as createCollection, o as dropIndex, r as createIndex, s as setValidation, t as collMod } from "./migration-factories-IG0vjM_u.mjs";
 import { placeholder } from "@prisma-next/errors/migration";
 
 export { collMod, createCollection, createIndex, dataTransform, dropCollection, dropIndex, placeholder, setValidation, validatedCollection };

package/dist/{op-factory-call-BjNAcPSF.d.mts → op-factory-call-CVgzmLJh.d.mts}

@@ -74,4 +74,4 @@ declare function schemaIndexToCreateIndexOptions(index: MongoSchemaIndex): Creat
 declare function schemaCollectionToCreateCollectionOptions(coll: MongoSchemaCollection): CreateCollectionOptions | undefined;
 //#endregion
 export { DropCollectionCall as a, schemaCollectionToCreateCollectionOptions as c, CreateIndexCall as i, schemaIndexToCreateIndexOptions as l, CollModMeta as n, DropIndexCall as o, CreateCollectionCall as r, OpFactoryCall$1 as s, CollModCall as t };
-//# sourceMappingURL=op-factory-call-BjNAcPSF.d.mts.map
+//# sourceMappingURL=op-factory-call-CVgzmLJh.d.mts.map

package/dist/{op-factory-call-BjNAcPSF.d.mts.map → op-factory-call-CVgzmLJh.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"op-factory-call-BjNAcPSF.d.mts","names":[],"sources":["../src/core/op-factory-call.ts"],"sourcesContent":[],"mappings":";;;;;;;AAwEqC,UA3BpB,WAAA,CA2BoB;EAAiB,SAAA,EAAA,CAAA,EAAA,MAAA;EAgCzC,SAAA,KAAA,CAAA,EAAc,MAAA;EAII,SAAA,cAAA,CAAA,EA5DH,uBA4DG;;uBAvDhB,iBAAA,SAA0B,YAAA,YAAwB,aA0DX,CAAA;EAAd,kBAAA,WAAA,EAAA,MAAA;EAQ9B,kBAAA,cAAA,EAhE0B,uBAgE1B;EAfyB,kBAAA,KAAA,EAAA,MAAA;EAAiB,SAAA,IAAA,CAAA,CAAA,EA/CjC,2BA+CiC;EAwBvC,kBAAA,CAAA,CAAA,EAAA,SArEoB,iBAqEC,EAAA;EAId,UAAA,MAAA,CAAA,CAAA,EAAA,IAAA;;AAWV,cAvEG,eAAA,SAAwB,iBAAA,CAuE3B;EAfgC,SAAA,WAAA,EAAA,aAAA;EAAiB,SAAA,cAAA,EAAA,UAAA;EA0B9C,SAAA,UAAA,EAAmB,MAAA;EAsBnB,SAAA,IAAA,EApGI,aAoGQ,CApGM,aAoGN,CAAA;EAGL,SAAA,OAAA,EAtGA,kBAsGA,GAAA,SAAA;EACH,SAAA,KAAA,EAAA,MAAA;EACU,WAAA,CAAA,UAAA,EAAA,MAAA,EAAA,IAAA,EAnGjB,aAmGiB,CAnGH,aAmGG,CAAA,EAAA,OAAA,CAAA,EAlGb,kBAkGa;EAGgB,IAAA,CAAA,CAAA,EA3FjC,2BA2FiC;EAAuB,gBAAA,CAAA,CAAA,EAAA,MAAA;;AARjC,cAxEpB,aAAA,SAAsB,iBAAA,CAwEF;EAAiB,SAAA,WAAA,EAAA,WAAA;EA6BtC,SAAA,cAAa,EAAA,aAAA;EACrB,SAAA,UAAA,EAAA,MAAA;EACA,SAAA,IAAA,EAnGa,aAmGb,CAnG2B,aAmG3B,CAAA;EACA,SAAA,KAAA,EAAA,MAAA;EACA,WAAA,CAAA,UAAA,EAAA,MAAA,EAAA,IAAA,EAlGoC,aAkGpC,CAlGkD,aAkGlD,CAAA;EACA,IAAA,CAAA,CAAA,EA3FM,2BA2FN;EAAW,gBAAA,CAAA,CAAA,EAAA,MAAA;AAEf;AAcgB,cAlGH,oBAAA,SAA6B,iBAAA,CAmGlC;;;;oBA/FY;;4CAGwB;UAQlC;;;cAWG,kBAAA,SAA2B,iBAAA;;;;;;UAa9B;;;cASG,WAAA,SAAoB,iBAAA;;;oBAGb;iBACH;2BACU;;2CAGgB,uBAAuB;UAUxD;;;KAWE,eAAA,GACR,kBACA,gBACA,uBACA,qBACA;iBAEY,+BAAA,QAAuC,mBAAmB;iBAc1D,yCAAA,OACR,wBACL"}
+{"version":3,"file":"op-factory-call-CVgzmLJh.d.mts","names":[],"sources":["../src/core/op-factory-call.ts"],"sourcesContent":[],"mappings":";;;;;;;AAwEqC,UA3BpB,WAAA,CA2BoB;EAAiB,SAAA,EAAA,CAAA,EAAA,MAAA;EAgCzC,SAAA,KAAA,CAAA,EAAc,MAAA;EAII,SAAA,cAAA,CAAA,EA5DH,uBA4DG;;uBAvDhB,iBAAA,SAA0B,YAAA,YAAwB,aA0DX,CAAA;EAAd,kBAAA,WAAA,EAAA,MAAA;EAQ9B,kBAAA,cAAA,EAhE0B,uBAgE1B;EAfyB,kBAAA,KAAA,EAAA,MAAA;EAAiB,SAAA,IAAA,CAAA,CAAA,EA/CjC,2BA+CiC;EAwBvC,kBAAA,CAAA,CAAA,EAAA,SArEoB,iBAqEC,EAAA;EAId,UAAA,MAAA,CAAA,CAAA,EAAA,IAAA;;AAWV,cAvEG,eAAA,SAAwB,iBAAA,CAuE3B;EAfgC,SAAA,WAAA,EAAA,aAAA;EAAiB,SAAA,cAAA,EAAA,UAAA;EA0B9C,SAAA,UAAA,EAAmB,MAAA;EAsBnB,SAAA,IAAA,EApGI,aAoGQ,CApGM,aAoGN,CAAA;EAGL,SAAA,OAAA,EAtGA,kBAsGA,GAAA,SAAA;EACH,SAAA,KAAA,EAAA,MAAA;EACU,WAAA,CAAA,UAAA,EAAA,MAAA,EAAA,IAAA,EAnGjB,aAmGiB,CAnGH,aAmGG,CAAA,EAAA,OAAA,CAAA,EAlGb,kBAkGa;EAGgB,IAAA,CAAA,CAAA,EA3FjC,2BA2FiC;EAAuB,gBAAA,CAAA,CAAA,EAAA,MAAA;;AARjC,cAxEpB,aAAA,SAAsB,iBAAA,CAwEF;EAAiB,SAAA,WAAA,EAAA,WAAA;EA6BtC,SAAA,cAAa,EAAA,aAAA;EACrB,SAAA,UAAA,EAAA,MAAA;EACA,SAAA,IAAA,EAnGa,aAmGb,CAnG2B,aAmG3B,CAAA;EACA,SAAA,KAAA,EAAA,MAAA;EACA,WAAA,CAAA,UAAA,EAAA,MAAA,EAAA,IAAA,EAlGoC,aAkGpC,CAlGkD,aAkGlD,CAAA;EACA,IAAA,CAAA,CAAA,EA3FM,2BA2FN;EAAW,gBAAA,CAAA,CAAA,EAAA,MAAA;AAEf;AAcgB,cAlGH,oBAAA,SAA6B,iBAAA,CAmGlC;;;;oBA/FY;;4CAGwB;UAQlC;;;cAWG,kBAAA,SAA2B,iBAAA;;;;;;UAa9B;;;cASG,WAAA,SAAoB,iBAAA;;;oBAGb;iBACH;2BACU;;2CAGgB,uBAAuB;UAUxD;;;KAWE,eAAA,GACR,kBACA,gBACA,uBACA,qBACA;iBAEY,+BAAA,QAAuC,mBAAmB;iBAc1D,yCAAA,OACR,wBACL"}

package/dist/schema-verify.d.mts

@@ -0,0 +1,22 @@
+import { MongoSchemaIR } from "@prisma-next/mongo-schema-ir";
+import { OperationContext, VerifyDatabaseSchemaResult } from "@prisma-next/framework-components/control";
+import { MongoContract } from "@prisma-next/mongo-contract";
+import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
+
+//#region src/core/schema-verify/verify-mongo-schema.d.ts
+interface VerifyMongoSchemaOptions {
+  readonly contract: MongoContract;
+  readonly schema: MongoSchemaIR;
+  readonly strict: boolean;
+  readonly context?: OperationContext;
+  /**
+   * Active framework components participating in this composition. Mongo
+   * verification does not currently consult them, but the parameter exists
+   * for parity with `verifySqlSchema` so callers can pass the same envelope.
+   */
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', string>>;
+}
+declare function verifyMongoSchema(options: VerifyMongoSchemaOptions): VerifyDatabaseSchemaResult;
+//#endregion
+export { type VerifyMongoSchemaOptions, verifyMongoSchema };
+//# sourceMappingURL=schema-verify.d.mts.map

package/dist/schema-verify.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-verify.d.mts","names":[],"sources":["../src/core/schema-verify/verify-mongo-schema.ts"],"sourcesContent":[],"mappings":";;;;;;UAaiB,wBAAA;qBACI;EADJ,SAAA,MAAA,EAEE,aAFsB;EACpB,SAAA,MAAA,EAAA,OAAA;EACF,SAAA,OAAA,CAAA,EAEE,gBAFF;EAEE;;;;AASrB;gCAHgC,cAAc;;iBAG9B,iBAAA,UAA2B,2BAA2B"}

package/dist/schema-verify.mjs

@@ -0,0 +1,3 @@
+import { t as verifyMongoSchema } from "./verify-mongo-schema-P0TRBJNs.mjs";
+
+export { verifyMongoSchema };

package/dist/verify-mongo-schema-P0TRBJNs.mjs

@@ -0,0 +1,582 @@
+import { MongoSchemaCollection, MongoSchemaCollectionOptions, MongoSchemaIR, MongoSchemaIndex, MongoSchemaValidator, canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { VERIFY_CODE_SCHEMA_FAILURE } from "@prisma-next/framework-components/control";
+
+//#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/schema-diff.ts
+function diffMongoSchemas(live, expected, strict) {
+	const issues = [];
+	const collectionChildren = [];
+	let pass = 0;
+	let warn = 0;
+	let fail = 0;
+	const allNames = new Set([...live.collectionNames, ...expected.collectionNames]);
+	for (const name of [...allNames].sort()) {
+		const liveColl = live.collection(name);
+		const expectedColl = expected.collection(name);
+		if (!liveColl && expectedColl) {
+			issues.push({
+				kind: "missing_table",
+				table: name,
+				message: `Collection "${name}" is missing from the database`
+			});
+			collectionChildren.push({
+				status: "fail",
+				kind: "collection",
+				name,
+				contractPath: `storage.collections.${name}`,
+				code: "MISSING_COLLECTION",
+				message: `Collection "${name}" is missing`,
+				expected: name,
+				actual: null,
+				children: []
+			});
+			fail++;
+			continue;
+		}
+		if (liveColl && !expectedColl) {
+			const status = strict ? "fail" : "warn";
+			issues.push({
+				kind: "extra_table",
+				table: name,
+				message: `Extra collection "${name}" exists in the database but not in the contract`
+			});
+			collectionChildren.push({
+				status,
+				kind: "collection",
+				name,
+				contractPath: `storage.collections.${name}`,
+				code: "EXTRA_COLLECTION",
+				message: `Extra collection "${name}" found`,
+				expected: null,
+				actual: name,
+				children: []
+			});
+			if (status === "fail") fail++;
+			else warn++;
+			continue;
+		}
+		const lc = liveColl;
+		const ec = expectedColl;
+		const indexChildren = diffIndexes(name, lc, ec, strict, issues);
+		const validatorChildren = diffValidator(name, lc, ec, strict, issues);
+		const optionsChildren = diffOptions(name, lc, ec, strict, issues);
+		const children = [
+			...indexChildren,
+			...validatorChildren,
+			...optionsChildren
+		];
+		const worstStatus = children.reduce((s, c) => c.status === "fail" ? "fail" : c.status === "warn" && s !== "fail" ? "warn" : s, "pass");
+		for (const c of children) if (c.status === "pass") pass++;
+		else if (c.status === "warn") warn++;
+		else fail++;
+		if (children.length === 0) pass++;
+		collectionChildren.push({
+			status: worstStatus,
+			kind: "collection",
+			name,
+			contractPath: `storage.collections.${name}`,
+			code: worstStatus === "pass" ? "MATCH" : "DRIFT",
+			message: worstStatus === "pass" ? `Collection "${name}" matches` : `Collection "${name}" has drift`,
+			expected: name,
+			actual: name,
+			children
+		});
+	}
+	const rootStatus = fail > 0 ? "fail" : warn > 0 ? "warn" : "pass";
+	const totalNodes = pass + warn + fail + collectionChildren.length;
+	return {
+		root: {
+			status: rootStatus,
+			kind: "root",
+			name: "mongo-schema",
+			contractPath: "storage",
+			code: rootStatus === "pass" ? "MATCH" : "DRIFT",
+			message: rootStatus === "pass" ? "Schema matches" : "Schema has drift",
+			expected: null,
+			actual: null,
+			children: collectionChildren
+		},
+		issues,
+		counts: {
+			pass,
+			warn,
+			fail,
+			totalNodes
+		}
+	};
+}
+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 formatIndexName(index) {
+	return index.keys.map((k) => `${k.field}:${k.direction}`).join(", ");
+}
+function diffIndexes(collName, live, expected, strict, issues) {
+	const nodes = [];
+	const liveLookup = /* @__PURE__ */ new Map();
+	for (const idx of live.indexes) liveLookup.set(buildIndexLookupKey(idx), idx);
+	const expectedLookup = /* @__PURE__ */ new Map();
+	for (const idx of expected.indexes) expectedLookup.set(buildIndexLookupKey(idx), idx);
+	for (const [key, idx] of expectedLookup) if (liveLookup.has(key)) nodes.push({
+		status: "pass",
+		kind: "index",
+		name: formatIndexName(idx),
+		contractPath: `storage.collections.${collName}.indexes`,
+		code: "MATCH",
+		message: `Index ${formatIndexName(idx)} matches`,
+		expected: key,
+		actual: key,
+		children: []
+	});
+	else {
+		issues.push({
+			kind: "index_mismatch",
+			table: collName,
+			indexOrConstraint: formatIndexName(idx),
+			message: `Index ${formatIndexName(idx)} missing on collection "${collName}"`
+		});
+		nodes.push({
+			status: "fail",
+			kind: "index",
+			name: formatIndexName(idx),
+			contractPath: `storage.collections.${collName}.indexes`,
+			code: "MISSING_INDEX",
+			message: `Index ${formatIndexName(idx)} missing`,
+			expected: key,
+			actual: null,
+			children: []
+		});
+	}
+	for (const [key, idx] of liveLookup) if (!expectedLookup.has(key)) {
+		const status = strict ? "fail" : "warn";
+		issues.push({
+			kind: "extra_index",
+			table: collName,
+			indexOrConstraint: formatIndexName(idx),
+			message: `Extra index ${formatIndexName(idx)} on collection "${collName}"`
+		});
+		nodes.push({
+			status,
+			kind: "index",
+			name: formatIndexName(idx),
+			contractPath: `storage.collections.${collName}.indexes`,
+			code: "EXTRA_INDEX",
+			message: `Extra index ${formatIndexName(idx)}`,
+			expected: null,
+			actual: key,
+			children: []
+		});
+	}
+	return nodes;
+}
+function diffValidator(collName, live, expected, strict, issues) {
+	if (!live.validator && !expected.validator) return [];
+	if (expected.validator && !live.validator) {
+		issues.push({
+			kind: "type_missing",
+			table: collName,
+			message: `Validator missing on collection "${collName}"`
+		});
+		return [{
+			status: "fail",
+			kind: "validator",
+			name: "validator",
+			contractPath: `storage.collections.${collName}.validator`,
+			code: "MISSING_VALIDATOR",
+			message: "Validator missing",
+			expected: canonicalize(expected.validator.jsonSchema),
+			actual: null,
+			children: []
+		}];
+	}
+	if (!expected.validator && live.validator) {
+		const status = strict ? "fail" : "warn";
+		issues.push({
+			kind: "extra_validator",
+			table: collName,
+			message: `Extra validator on collection "${collName}"`
+		});
+		return [{
+			status,
+			kind: "validator",
+			name: "validator",
+			contractPath: `storage.collections.${collName}.validator`,
+			code: "EXTRA_VALIDATOR",
+			message: "Extra validator found",
+			expected: null,
+			actual: canonicalize(live.validator.jsonSchema),
+			children: []
+		}];
+	}
+	const liveVal = live.validator;
+	const expectedVal = expected.validator;
+	const liveSchema = canonicalize(liveVal.jsonSchema);
+	const expectedSchema = canonicalize(expectedVal.jsonSchema);
+	if (liveSchema !== expectedSchema || liveVal.validationLevel !== expectedVal.validationLevel || liveVal.validationAction !== expectedVal.validationAction) {
+		issues.push({
+			kind: "type_mismatch",
+			table: collName,
+			expected: expectedSchema,
+			actual: liveSchema,
+			message: `Validator mismatch on collection "${collName}"`
+		});
+		return [{
+			status: "fail",
+			kind: "validator",
+			name: "validator",
+			contractPath: `storage.collections.${collName}.validator`,
+			code: "VALIDATOR_MISMATCH",
+			message: "Validator mismatch",
+			expected: {
+				jsonSchema: expectedVal.jsonSchema,
+				validationLevel: expectedVal.validationLevel,
+				validationAction: expectedVal.validationAction
+			},
+			actual: {
+				jsonSchema: liveVal.jsonSchema,
+				validationLevel: liveVal.validationLevel,
+				validationAction: liveVal.validationAction
+			},
+			children: []
+		}];
+	}
+	return [{
+		status: "pass",
+		kind: "validator",
+		name: "validator",
+		contractPath: `storage.collections.${collName}.validator`,
+		code: "MATCH",
+		message: "Validator matches",
+		expected: expectedSchema,
+		actual: liveSchema,
+		children: []
+	}];
+}
+function diffOptions(collName, live, expected, strict, issues) {
+	if (!live.options && !expected.options) return [];
+	if (!expected.options && live.options) {
+		const status = strict ? "fail" : "warn";
+		issues.push({
+			kind: "type_mismatch",
+			table: collName,
+			actual: canonicalize(live.options),
+			message: `Extra collection options on "${collName}"`
+		});
+		return [{
+			status,
+			kind: "options",
+			name: "options",
+			contractPath: `storage.collections.${collName}.options`,
+			code: "EXTRA_OPTIONS",
+			message: "Extra collection options found",
+			expected: null,
+			actual: live.options,
+			children: []
+		}];
+	}
+	if (deepEqual(live.options, expected.options)) return [{
+		status: "pass",
+		kind: "options",
+		name: "options",
+		contractPath: `storage.collections.${collName}.options`,
+		code: "MATCH",
+		message: "Collection options match",
+		expected: canonicalize(expected.options),
+		actual: canonicalize(live.options),
+		children: []
+	}];
+	issues.push({
+		kind: "type_mismatch",
+		table: collName,
+		expected: canonicalize(expected.options),
+		actual: canonicalize(live.options),
+		message: `Collection options mismatch on "${collName}"`
+	});
+	return [{
+		status: "fail",
+		kind: "options",
+		name: "options",
+		contractPath: `storage.collections.${collName}.options`,
+		code: "OPTIONS_MISMATCH",
+		message: "Collection options mismatch",
+		expected: expected.options,
+		actual: live.options,
+		children: []
+	}];
+}
+
+//#endregion
+//#region src/core/schema-verify/canonicalize-introspection.ts
+function canonicalizeSchemasForVerification(live, expected) {
+	const expectedByName = /* @__PURE__ */ new Map();
+	for (const c of expected.collections) expectedByName.set(c.name, c);
+	const liveByName = /* @__PURE__ */ new Map();
+	for (const c of live.collections) liveByName.set(c.name, c);
+	const canonicalLive = live.collections.map((c) => canonicalizeLiveCollection(c, expectedByName.get(c.name)));
+	const canonicalExpected = expected.collections.map((c) => canonicalizeExpectedCollection(c, liveByName.get(c.name)));
+	return {
+		live: new MongoSchemaIR(canonicalLive),
+		expected: new MongoSchemaIR(canonicalExpected)
+	};
+}
+function canonicalizeLiveCollection(liveColl, expectedColl) {
+	const expectedIndexes = expectedColl?.indexes ?? [];
+	const indexes = liveColl.indexes.map((idx) => canonicalizeLiveIndex(idx, findExpectedIndexCounterpart(idx, expectedIndexes)));
+	const options = liveColl.options ? canonicalizeLiveOptions(liveColl.options, expectedColl?.options) : void 0;
+	return new MongoSchemaCollection({
+		name: liveColl.name,
+		indexes,
+		...ifDefined("validator", liveColl.validator),
+		...ifDefined("options", options)
+	});
+}
+function canonicalizeExpectedCollection(expectedColl, liveColl) {
+	const indexes = expectedColl.indexes.map(canonicalizeTextIndexKeyOrder);
+	const options = expectedColl.options ? canonicalizeExpectedOptions(expectedColl.options, liveColl?.options) : void 0;
+	return new MongoSchemaCollection({
+		name: expectedColl.name,
+		indexes,
+		...ifDefined("validator", expectedColl.validator),
+		...ifDefined("options", options)
+	});
+}
+function canonicalizeTextIndexKeyOrder(index) {
+	if (!index.keys.some((k) => k.direction === "text")) return index;
+	return new MongoSchemaIndex({
+		keys: sortTextKeys(index.keys),
+		unique: index.unique,
+		...ifDefined("sparse", index.sparse),
+		...ifDefined("expireAfterSeconds", index.expireAfterSeconds),
+		...ifDefined("partialFilterExpression", index.partialFilterExpression),
+		...ifDefined("wildcardProjection", index.wildcardProjection),
+		...ifDefined("collation", index.collation),
+		...ifDefined("weights", index.weights),
+		...ifDefined("default_language", index.default_language),
+		...ifDefined("language_override", index.language_override)
+	});
+}
+/**
+* Returns a copy of `keys` with text-direction entries sorted alphabetically
+* while preserving the relative position of non-text entries. Compound text
+* indexes (`{a: 1, _fts: 'text', _ftsx: 1, b: 1}`) keep their scalar
+* prefix/suffix layout; only the contiguous text block is reordered.
+*/
+function sortTextKeys(keys) {
+	const textEntries = keys.filter((k) => k.direction === "text");
+	if (textEntries.length <= 1) return keys;
+	const sortedText = [...textEntries].sort((a, b) => a.field.localeCompare(b.field));
+	let textIdx = 0;
+	return keys.map((k) => {
+		if (k.direction !== "text") return k;
+		const next = sortedText[textIdx++];
+		/* v8 ignore next 3 -- @preserve invariant guard: textIdx is always < sortedText.length here because we only consume sortedText for text-direction entries and sortedText is built from the same filter. */
+		if (next === void 0) throw new Error("sortTextKeys: text-key counts mismatched");
+		return next;
+	});
+}
+function canonicalizeLiveIndex(liveIndex, expectedIndex) {
+	const projectedKeys = sortTextKeys(projectTextIndexKeys(liveIndex));
+	const collation = liveIndex.collation ? stripUnspecifiedFields(liveIndex.collation, expectedIndex?.collation) : liveIndex.collation;
+	const weights = expectedIndex?.weights === void 0 && hasDefaultTextWeights(projectedKeys, liveIndex.weights) ? void 0 : liveIndex.weights;
+	const default_language = expectedIndex?.default_language === void 0 && liveIndex.default_language === "english" ? void 0 : liveIndex.default_language;
+	const language_override = expectedIndex?.language_override === void 0 && liveIndex.language_override === "language" ? void 0 : liveIndex.language_override;
+	return new MongoSchemaIndex({
+		keys: projectedKeys,
+		unique: liveIndex.unique,
+		...ifDefined("sparse", liveIndex.sparse),
+		...ifDefined("expireAfterSeconds", liveIndex.expireAfterSeconds),
+		...ifDefined("partialFilterExpression", liveIndex.partialFilterExpression),
+		...ifDefined("wildcardProjection", liveIndex.wildcardProjection),
+		...ifDefined("collation", collation),
+		...ifDefined("weights", weights),
+		...ifDefined("default_language", default_language),
+		...ifDefined("language_override", language_override)
+	});
+}
+/**
+* Locate the contract-side index that corresponds to a live index for the
+* purpose of contract-aware normalization. We deliberately match by the
+* *projected* (contract-shaped) key list — so a live `_fts/_ftsx` index
+* resolves to a contract `{title: 'text', body: 'text'}` index — and pick
+* the first match. Contracts very rarely contain duplicate-key indexes; if
+* we have no counterpart we fall back to no normalization for that index.
+*/
+function findExpectedIndexCounterpart(liveIndex, expectedIndexes) {
+	const liveKeySig = sortTextKeys(projectTextIndexKeys(liveIndex)).map((k) => `${k.field}:${k.direction}`).join(",");
+	for (const expected of expectedIndexes) if (sortTextKeys(expected.keys).map((k) => `${k.field}:${k.direction}`).join(",") === liveKeySig) return expected;
+}
+/**
+* MongoDB expands a contract-shaped text index like
+* `[{title: 'text'}, {body: 'text'}]` into its internal weighted vector
+* representation `[{_fts: 'text'}, {_ftsx: 1}]`. We project back to
+* contract-shaped keys via `weights`, iterating in whatever order MongoDB
+* returns them (alphabetical, in practice). `sortTextKeys` is applied
+* downstream to canonicalize the order on both sides, so this projection
+* does not depend on a specific iteration order.
+*/
+function projectTextIndexKeys(liveIndex) {
+	if (!(liveIndex.keys.length >= 1 && liveIndex.keys.some((k) => k.field === "_fts" && k.direction === "text")) || !liveIndex.weights) return liveIndex.keys;
+	const textKeys = Object.keys(liveIndex.weights).map((field) => ({
+		field,
+		direction: "text"
+	}));
+	const projectedKeys = [];
+	for (const key of liveIndex.keys) {
+		if (key.field === "_ftsx") continue;
+		if (key.field === "_fts") {
+			projectedKeys.push(...textKeys);
+			continue;
+		}
+		projectedKeys.push(key);
+	}
+	return projectedKeys;
+}
+/**
+* MongoDB's server-default `weights` for an authored-without-weights text
+* index assigns `1` to every text-direction field. Returns `true` only when
+* `liveWeights` is exactly that uniform shape (every projected text-direction
+* key weighted at `1`) so the canonicalizer leaves non-default weights —
+* including out-of-band relevance tweaks — visible to the verifier.
+*
+* `projectTextIndexKeys` derives text-direction keys from the live weights
+* map, so the count is guaranteed to match; we only have to check the value
+* shape.
+*/
+function hasDefaultTextWeights(projectedKeys, liveWeights) {
+	if (liveWeights === void 0) return false;
+	return projectedKeys.filter((k) => k.direction === "text").map((k) => k.field).every((field) => liveWeights[field] === 1);
+}
+function canonicalizeLiveOptions(liveOptions, expectedOptions) {
+	const collation = liveOptions.collation ? stripUnspecifiedFields(liveOptions.collation, expectedOptions?.collation) : void 0;
+	const timeseries = liveOptions.timeseries ? stripUnspecifiedFields(liveOptions.timeseries, expectedOptions?.timeseries) : void 0;
+	const clusteredIndex = liveOptions.clusteredIndex ? stripUnspecifiedFields(liveOptions.clusteredIndex, expectedOptions?.clusteredIndex) : void 0;
+	const changeStreamPreAndPostImages = isDisabledChangeStream(liveOptions.changeStreamPreAndPostImages) ? void 0 : liveOptions.changeStreamPreAndPostImages;
+	if (!(liveOptions.capped || timeseries || collation || changeStreamPreAndPostImages || clusteredIndex)) return void 0;
+	return new MongoSchemaCollectionOptions({
+		...ifDefined("capped", liveOptions.capped),
+		...ifDefined("timeseries", timeseries),
+		...ifDefined("collation", collation),
+		...ifDefined("changeStreamPreAndPostImages", changeStreamPreAndPostImages),
+		...ifDefined("clusteredIndex", clusteredIndex)
+	});
+}
+function canonicalizeExpectedOptions(expectedOptions, _liveOptions) {
+	const changeStreamPreAndPostImages = isDisabledChangeStream(expectedOptions.changeStreamPreAndPostImages) ? void 0 : expectedOptions.changeStreamPreAndPostImages;
+	if (!(expectedOptions.capped || expectedOptions.timeseries || expectedOptions.collation || changeStreamPreAndPostImages || expectedOptions.clusteredIndex)) return void 0;
+	return new MongoSchemaCollectionOptions({
+		...ifDefined("capped", expectedOptions.capped),
+		...ifDefined("timeseries", expectedOptions.timeseries),
+		...ifDefined("collation", expectedOptions.collation),
+		...ifDefined("changeStreamPreAndPostImages", changeStreamPreAndPostImages),
+		...ifDefined("clusteredIndex", expectedOptions.clusteredIndex)
+	});
+}
+function isDisabledChangeStream(value) {
+	return value !== void 0 && value.enabled === false;
+}
+/**
+* Returns a copy of `live` containing only the keys that `expected` defines.
+* Used for option families whose individual sub-fields are server-extended
+* with platform defaults (collation, timeseries, clusteredIndex), so the
+* verifier should compare only what the contract actually authored.
+*
+* When `expected` is `undefined` — i.e. the contract authored nothing for
+* this whole option family but the live IR has it — we return `live`
+* unchanged so the verifier still sees the entire live block and can
+* surface it as drift. (Returning `undefined` here would silently strip a
+* server-attached collation/timeseries/clusteredIndex that the contract
+* never asked for, hiding real drift.)
+*/
+function stripUnspecifiedFields(live, expected) {
+	if (expected === void 0) return live;
+	const out = {};
+	for (const key of Object.keys(expected)) if (Object.hasOwn(live, key)) out[key] = live[key];
+	return out;
+}
+
+//#endregion
+//#region src/core/schema-verify/verify-mongo-schema.ts
+function verifyMongoSchema(options) {
+	const { contract, schema, strict, context } = options;
+	const startTime = Date.now();
+	const { live: canonicalLive, expected: canonicalExpected } = canonicalizeSchemasForVerification(schema, contractToMongoSchemaIR(contract));
+	const { root, issues, counts } = diffMongoSchemas(canonicalLive, canonicalExpected, strict);
+	const ok = counts.fail === 0;
+	const profileHash = typeof contract.profileHash === "string" ? contract.profileHash : "";
+	return {
+		ok,
+		...ifDefined("code", ok ? void 0 : VERIFY_CODE_SCHEMA_FAILURE),
+		summary: ok ? "Schema matches contract" : `Schema verification found ${counts.fail} issue(s)`,
+		contract: {
+			storageHash: contract.storage.storageHash,
+			...profileHash ? { profileHash } : {}
+		},
+		target: { expected: contract.target },
+		schema: {
+			issues,
+			root,
+			counts
+		},
+		meta: {
+			strict,
+			...ifDefined("contractPath", context?.contractPath),
+			...ifDefined("configPath", context?.configPath)
+		},
+		timings: { total: Date.now() - startTime }
+	};
+}
+
+//#endregion
+export { contractToMongoSchemaIR as n, verifyMongoSchema as t };
+//# sourceMappingURL=verify-mongo-schema-P0TRBJNs.mjs.map