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

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

@@ -0,0 +1,592 @@
+import { MongoSchemaCollection, MongoSchemaCollectionOptions, MongoSchemaIR, MongoSchemaIndex, MongoSchemaValidator, canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
+import { VERIFY_CODE_SCHEMA_FAILURE } from "@prisma-next/framework-components/control";
+import { ifDefined } from "@prisma-next/utils/defined";
+//#region src/core/contract-to-schema.ts
+function stripIrKind(node) {
+	const { kind: _kind, ...rest } = node;
+	return rest;
+}
+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.capped !== void 0 && { capped: o.capped },
+		...o.timeseries !== void 0 && { timeseries: {
+			timeField: o.timeseries.timeField,
+			...o.timeseries.metaField !== void 0 && { metaField: o.timeseries.metaField },
+			...o.timeseries.granularity !== void 0 && { granularity: o.timeseries.granularity }
+		} },
+		...o.collation !== void 0 && { collation: stripIrKind(o.collation) },
+		...o.changeStreamPreAndPostImages !== void 0 && { changeStreamPreAndPostImages: { enabled: o.changeStreamPreAndPostImages.enabled } },
+		...o.clusteredIndex !== void 0 && { clusteredIndex: o.clusteredIndex }
+	});
+}
+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 i, canonicalizeSchemasForVerification as n, diffMongoSchemas as r, verifyMongoSchema as t };
+
+//# sourceMappingURL=verify-mongo-schema-BL7t9YTB.mjs.map