@prisma/orm-family-mongo 0.16.0-dev.36

package/dist/interpreter-BxbUTQ3k-ClR98Ned.mjs

@@ -0,0 +1,1091 @@
+import { l as MongoValidator, o as MongoIndex } from "./entity-kinds-B4KNTF8z-DPIuUuuB.mjs";
+import { a as applyPolymorphicScopeToMongoIndex, r as MongoStorage, s as buildMongoNamespace } from "./dist-DHrEJnhK.mjs";
+import { t as mongoContractCanonicalizationHooks } from "./canonicalization-hooks-DF3Z6sjO.mjs";
+import { crossRef } from "@prisma/orm-framework/contract/types";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { computeProfileHash, computeStorageHash } from "@prisma/orm-framework/contract/hashing";
+import { errorEnumCodecNotInPackStack } from "@prisma/orm-framework/errors/control";
+import { instantiateAuthoringEntityType, isAuthoringEntityTypeDescriptor } from "@prisma/orm-framework/components/authoring";
+import { nodePslSpan, parseQuotedStringLiteral } from "@prisma/orm-framework/psl-parser";
+import { assertDefined } from "@prisma/orm-framework/utils/assertions";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+//#region ../../../2-mongo-family/2-authoring/contract-psl/dist/interpreter-BxbUTQ3k.mjs
+function resolveBsonType(codecId, codecLookup) {
+	return codecLookup?.targetTypesFor(codecId)?.[0];
+}
+function fieldToBsonSchema(field, valueObjects, codecLookup, valueSets) {
+	if (field.type.kind === "scalar") {
+		const bsonType = resolveBsonType(field.type.codecId, codecLookup);
+		if (!bsonType) return void 0;
+		const enumValues = field.valueSet !== void 0 ? valueSets?.[field.valueSet.entityName]?.values ?? null : null;
+		if ("many" in field && field.many) {
+			const items = { bsonType };
+			if (enumValues) items["enum"] = enumValues;
+			return {
+				bsonType: "array",
+				items
+			};
+		}
+		if (field.nullable) {
+			const s = { bsonType: ["null", bsonType] };
+			if (enumValues) s["enum"] = [...enumValues, null];
+			return s;
+		}
+		const s = { bsonType };
+		if (enumValues) s["enum"] = enumValues;
+		return s;
+	}
+	if (field.type.kind === "valueObject") {
+		const vo = valueObjects?.[field.type.name];
+		if (!vo) return void 0;
+		const voSchema = deriveObjectSchema(vo.fields, valueObjects, codecLookup, valueSets);
+		if ("many" in field && field.many) return {
+			bsonType: "array",
+			items: voSchema
+		};
+		if (field.nullable) return { oneOf: [{ bsonType: "null" }, voSchema] };
+		return voSchema;
+	}
+}
+function deriveObjectSchema(fields, valueObjects, codecLookup, valueSets) {
+	const properties = {};
+	const required = [];
+	for (const [fieldName, field] of Object.entries(fields)) {
+		const schema = fieldToBsonSchema(field, valueObjects, codecLookup, valueSets);
+		if (schema) {
+			properties[fieldName] = schema;
+			if (!field.nullable) required.push(fieldName);
+		}
+	}
+	const result = {
+		bsonType: "object",
+		properties,
+		additionalProperties: false
+	};
+	if (required.length > 0) result["required"] = required.sort();
+	return result;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deriveJsonSchema(fields, valueObjects, codecLookup, valueSets) {
+	return new MongoValidator({
+		jsonSchema: deriveObjectSchema(fields, valueObjects, codecLookup, valueSets),
+		validationLevel: "strict",
+		validationAction: "error"
+	});
+}
+function derivePolymorphicJsonSchema(baseFields, discriminatorField, variants, valueObjects, codecLookup, valueSets) {
+	const baseSchema = deriveObjectSchema(baseFields, valueObjects, codecLookup, valueSets);
+	const baseProperties = isRecord(baseSchema["properties"]) ? baseSchema["properties"] : {};
+	const oneOf = [];
+	for (const variant of variants) {
+		const variantOnlyFields = {};
+		for (const [name, field] of Object.entries(variant.fields)) if (!(name in baseFields)) variantOnlyFields[name] = field;
+		const variantProperties = {};
+		const variantRequired = [discriminatorField];
+		for (const [name, field] of Object.entries(variantOnlyFields)) {
+			const schema = fieldToBsonSchema(field, valueObjects, codecLookup, valueSets);
+			if (schema) {
+				variantProperties[name] = schema;
+				if (!field.nullable) variantRequired.push(name);
+			}
+		}
+		const entry = {
+			properties: {
+				...baseProperties,
+				[discriminatorField]: { enum: [variant.discriminatorValue] },
+				...variantProperties
+			},
+			required: variantRequired.sort(),
+			additionalProperties: false
+		};
+		oneOf.push(entry);
+	}
+	const jsonSchema = { ...baseSchema };
+	delete jsonSchema["additionalProperties"];
+	if (oneOf.length > 0) jsonSchema["oneOf"] = oneOf;
+	return new MongoValidator({
+		jsonSchema,
+		validationLevel: "strict",
+		validationAction: "error"
+	});
+}
+function getPositionalArgument(attr, index = 0) {
+	return attr.args.filter((arg) => arg.kind === "positional")[index]?.value;
+}
+function getNamedArgument(attr, name) {
+	return attr.args.find((a) => a.kind === "named" && a.name === name)?.value;
+}
+function parseFieldList(value) {
+	const inner = value.replace(/^\[/, "").replace(/\]$/, "").trim();
+	if (inner.length === 0) return [];
+	return splitTopLevel(inner).map((s) => s.trim());
+}
+function parseIndexFieldList(value) {
+	return parseFieldList(value).map(parseIndexFieldSegment);
+}
+function parseIndexFieldSegment(segment) {
+	const wildcardMatch = segment.match(/^wildcard\(\s*(.*?)\s*\)$/);
+	if (wildcardMatch) {
+		const scope = wildcardMatch[1] ?? "";
+		return {
+			name: scope.length > 0 ? `${scope}.$**` : "$**",
+			isWildcard: true
+		};
+	}
+	const modifierMatch = segment.match(/^(\w+)\(\s*sort:\s*(\w+)\s*\)$/);
+	if (modifierMatch) return {
+		name: modifierMatch[1] ?? segment,
+		isWildcard: false,
+		direction: modifierMatch[2] === "Desc" ? -1 : 1
+	};
+	return {
+		name: segment,
+		isWildcard: false
+	};
+}
+function splitTopLevel(input) {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i];
+		if (ch === "(" || ch === "[" || ch === "{") depth++;
+		else if (ch === ")" || ch === "]" || ch === "}") depth = Math.max(0, depth - 1);
+		else if (ch === "," && depth === 0) {
+			parts.push(input.slice(start, i));
+			start = i + 1;
+		}
+	}
+	parts.push(input.slice(start));
+	return parts;
+}
+function lowerFirst(value) {
+	if (value.length === 0) return value;
+	return value[0]?.toLowerCase() + value.slice(1);
+}
+function getAttribute(attributes, name) {
+	return attributes.find((attr) => attr.name === name);
+}
+function getMapName(attributes) {
+	const mapAttr = getAttribute(attributes, "map");
+	if (!mapAttr) return void 0;
+	const arg = mapAttr.args[0];
+	if (!arg) return void 0;
+	return stripQuotes(arg.value);
+}
+function parseRelationAttribute(attributes) {
+	const relationAttr = getAttribute(attributes, "relation");
+	if (!relationAttr) return void 0;
+	let relationName;
+	let fieldsArg;
+	let referencesArg;
+	for (const arg of relationAttr.args) if (arg.kind === "positional") relationName = stripQuotes(arg.value);
+	else if (arg.name === "name") relationName = stripQuotes(arg.value);
+	else if (arg.name === "fields") fieldsArg = arg;
+	else if (arg.name === "references") referencesArg = arg;
+	const fields = fieldsArg ? parseFieldList(fieldsArg.value) : void 0;
+	const references = referencesArg ? parseFieldList(referencesArg.value) : void 0;
+	return {
+		...ifDefined("relationName", relationName),
+		...ifDefined("fields", fields),
+		...ifDefined("references", references)
+	};
+}
+function stripQuotes(value) {
+	if (value.startsWith("\"") && value.endsWith("\"")) return value.slice(1, -1);
+	return value;
+}
+/**
+* Encode an authored enum value to its codec-encoded JSON form via the codec resolved by id from the
+* contract's codec lookup, so a non-identity `encodeJson` (permitted by the `mongoCodec` factory) is
+* respected. Matches the TS builder's `encodeEnumValue`: the lookup is always threaded in production,
+* and a codecId the lookup cannot resolve is a hard error — the enum uses a codec that is not part of
+* the contract's pack stack.
+*/
+function encodeEnumValue(value, codecId, codecLookup) {
+	const codec = codecLookup.get(codecId);
+	if (!codec) throw errorEnumCodecNotInPackStack({ codecId });
+	return codec.encodeJson(value);
+}
+/**
+* Mongo's PSL surface binds the database from the connection string, so every
+* explicit namespace block is invalid, including `namespace unbound { … }`.
+*/
+function validateNamespaceBlocksForMongoTarget(input) {
+	for (const namespace of input.namespaces) input.diagnostics.push({
+		code: "PSL_UNSUPPORTED_NAMESPACE_BLOCK",
+		message: `Mongo does not support \`namespace ${namespace.name} { … }\` blocks (the database is bound by the connection string; declare models at the document top level instead).`,
+		sourceId: input.sourceId,
+		span: nodePslSpan(namespace.node.syntax, input.sourceFile)
+	});
+}
+function fkRelationPairKey(declaringModel, targetModel) {
+	return `${declaringModel}::${targetModel}`;
+}
+function resolveFieldMappings(model) {
+	const pslNameToMapped = /* @__PURE__ */ new Map();
+	for (const field of Object.values(model.fields)) {
+		const mapped = getMapName(field.attributes) ?? field.name;
+		pslNameToMapped.set(field.name, mapped);
+	}
+	return { pslNameToMapped };
+}
+function resolveCollectionName(model) {
+	return getMapName(model.attributes) ?? lowerFirst(model.name);
+}
+function mongoCrossRef(modelName) {
+	return crossRef(modelName, UNBOUND_NAMESPACE_ID);
+}
+function collectPolymorphismDeclarations(models, sourceId, diagnostics) {
+	const discriminatorDeclarations = /* @__PURE__ */ new Map();
+	const baseDeclarations = /* @__PURE__ */ new Map();
+	for (const model of models) for (const attr of model.attributes) {
+		if (attr.name === "discriminator") {
+			const fieldName = getPositionalArgument(attr);
+			if (!fieldName) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" @@discriminator requires a field name argument`,
+					sourceId,
+					span: attr.span
+				});
+				continue;
+			}
+			const discField = model.fields[fieldName];
+			if (discField && discField.typeName !== "String") {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Discriminator field "${fieldName}" on model "${model.name}" must be of type String, but is "${discField.typeName}"`,
+					sourceId,
+					span: attr.span
+				});
+				continue;
+			}
+			discriminatorDeclarations.set(model.name, {
+				fieldName,
+				span: attr.span
+			});
+		}
+		if (attr.name === "base") {
+			const baseName = getPositionalArgument(attr, 0);
+			const rawValue = getPositionalArgument(attr, 1);
+			if (!baseName || !rawValue) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" @@base requires two arguments: base model name and discriminator value`,
+					sourceId,
+					span: attr.span
+				});
+				continue;
+			}
+			const value = parseQuotedStringLiteral(rawValue);
+			if (value === void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" @@base discriminator value must be a quoted string literal`,
+					sourceId,
+					span: attr.span
+				});
+				continue;
+			}
+			const collectionName = resolveCollectionName(model);
+			baseDeclarations.set(model.name, {
+				baseName,
+				value,
+				collectionName,
+				span: attr.span
+			});
+		}
+	}
+	return {
+		discriminatorDeclarations,
+		baseDeclarations
+	};
+}
+function resolvePolymorphism(input) {
+	const { discriminatorDeclarations, baseDeclarations, modelNames, sourceId, allModels: allModelViews, indexSpans, modelIndexesByName } = input;
+	let patched = input.models;
+	let roots = input.roots;
+	let collections = input.collections;
+	const diagnostics = [];
+	for (const [modelName, decl] of discriminatorDeclarations) {
+		if (baseDeclarations.has(modelName)) {
+			diagnostics.push({
+				code: "PSL_DISCRIMINATOR_AND_BASE",
+				message: `Model "${modelName}" cannot have both @@discriminator and @@base`,
+				sourceId,
+				span: decl.span
+			});
+			continue;
+		}
+		const model = patched[modelName];
+		if (!model) continue;
+		const modelView = allModelViews.find((m) => m.name === modelName);
+		const mappedDiscriminatorField = modelView ? resolveFieldMappings(modelView).pslNameToMapped.get(decl.fieldName) ?? decl.fieldName : decl.fieldName;
+		if (!Object.hasOwn(model.fields, mappedDiscriminatorField)) {
+			diagnostics.push({
+				code: "PSL_DISCRIMINATOR_FIELD_NOT_FOUND",
+				message: `Discriminator field "${decl.fieldName}" is not a field on model "${modelName}"`,
+				sourceId,
+				span: decl.span
+			});
+			continue;
+		}
+		const variants = {};
+		for (const [variantName, baseDecl] of baseDeclarations) {
+			if (baseDecl.baseName !== modelName) continue;
+			variants[variantName] = { value: baseDecl.value };
+		}
+		if (Object.keys(variants).length === 0) {
+			diagnostics.push({
+				code: "PSL_ORPHANED_DISCRIMINATOR",
+				message: `Model "${modelName}" has @@discriminator but no variant models declare @@base(${modelName}, ...)`,
+				sourceId,
+				span: decl.span
+			});
+			continue;
+		}
+		patched = {
+			...patched,
+			[modelName]: {
+				...model,
+				discriminator: { field: mappedDiscriminatorField },
+				variants
+			}
+		};
+	}
+	for (const [variantName, baseDecl] of baseDeclarations) {
+		if (!modelNames.has(baseDecl.baseName)) {
+			diagnostics.push({
+				code: "PSL_BASE_TARGET_NOT_FOUND",
+				message: `Model "${variantName}" @@base references non-existent model "${baseDecl.baseName}"`,
+				sourceId,
+				span: baseDecl.span
+			});
+			continue;
+		}
+		if (!discriminatorDeclarations.has(baseDecl.baseName)) {
+			diagnostics.push({
+				code: "PSL_ORPHANED_BASE",
+				message: `Model "${variantName}" declares @@base(${baseDecl.baseName}, ...) but "${baseDecl.baseName}" has no @@discriminator`,
+				sourceId,
+				span: baseDecl.span
+			});
+			continue;
+		}
+		if (discriminatorDeclarations.has(variantName)) continue;
+		const baseModel = patched[baseDecl.baseName];
+		const variantModelView = allModelViews.find((m) => m.name === variantName);
+		if (!variantModelView) continue;
+		if (getMapName(variantModelView.attributes) !== void 0 && baseModel && baseDecl.collectionName !== baseModel.storage.collection) {
+			diagnostics.push({
+				code: "PSL_MONGO_VARIANT_SEPARATE_COLLECTION",
+				message: `Mongo variant "${variantName}" cannot use a different collection than its base "${baseDecl.baseName}". Mongo only supports single-collection polymorphism.`,
+				sourceId,
+				span: baseDecl.span
+			});
+			continue;
+		}
+		const baseCollection = baseModel?.storage.collection ?? baseDecl.collectionName;
+		const variantModel = patched[variantName];
+		if (variantModel) patched = {
+			...patched,
+			[variantName]: {
+				...variantModel,
+				base: mongoCrossRef(baseDecl.baseName),
+				storage: { collection: baseCollection }
+			}
+		};
+		const variantCollectionName = resolveCollectionName(variantModelView);
+		if (roots[variantCollectionName]?.model === variantName) if (variantCollectionName === baseCollection && baseModel) roots = {
+			...roots,
+			[variantCollectionName]: mongoCrossRef(baseDecl.baseName)
+		};
+		else roots = Object.fromEntries(Object.entries(roots).filter(([key]) => key !== variantCollectionName));
+		const variantOwnIndexes = modelIndexesByName.get(variantName) ?? [];
+		const baseColl = collections[baseCollection];
+		const discriminatorField = patched[baseDecl.baseName]?.discriminator?.field;
+		const scopedVariantIndexes = [];
+		if (discriminatorField) for (const idx of variantOwnIndexes) {
+			const result = applyPolymorphicScopeToMongoIndex(idx, {
+				discriminatorField,
+				discriminatorValue: baseDecl.value
+			});
+			if (result.kind === "conflict") {
+				const span = indexSpans.get(idx) ?? baseDecl.span;
+				diagnostics.push({
+					code: "PSL_INVALID_INDEX",
+					message: `Variant "${variantName}" index conflicts with discriminator scope: ${result.reason}`,
+					sourceId,
+					span
+				});
+				continue;
+			}
+			if (result.index !== idx) indexSpans.set(result.index, indexSpans.get(idx) ?? baseDecl.span);
+			scopedVariantIndexes.push(result.index);
+		}
+		else scopedVariantIndexes.push(...variantOwnIndexes);
+		if (variantCollectionName !== baseCollection) {
+			const filtered = Object.fromEntries(Object.entries(collections).filter(([key]) => key !== variantCollectionName));
+			if (scopedVariantIndexes.length > 0 && baseColl) {
+				const baseIndexes = baseColl["indexes"] ?? [];
+				collections = {
+					...filtered,
+					[baseCollection]: {
+						...baseColl,
+						indexes: [...baseIndexes, ...scopedVariantIndexes]
+					}
+				};
+			} else collections = filtered;
+		} else if (baseColl) {
+			const existingIndexes = baseColl["indexes"] ?? [];
+			const variantIndexSet = new Set(variantOwnIndexes);
+			const withoutUnscopedVariants = existingIndexes.filter((idx) => !variantIndexSet.has(idx));
+			const mergedIndexes = [...withoutUnscopedVariants];
+			for (const idx of scopedVariantIndexes) {
+				const idxKey = canonicalJson(idx);
+				if (!withoutUnscopedVariants.some((existing) => canonicalJson(existing) === idxKey)) mergedIndexes.push(idx);
+			}
+			if (mergedIndexes.length !== existingIndexes.length || mergedIndexes.some((idx, i) => idx !== existingIndexes[i])) {
+				const next = { ...baseColl };
+				if (mergedIndexes.length > 0) next["indexes"] = mergedIndexes;
+				else delete next["indexes"];
+				collections = {
+					...collections,
+					[baseCollection]: next
+				};
+			}
+		}
+	}
+	return {
+		models: patched,
+		roots,
+		collections,
+		diagnostics
+	};
+}
+function canonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+function parseIndexDirection(raw) {
+	if (!raw) return 1;
+	const stripped = raw.replace(/^["']/, "").replace(/["']$/, "");
+	const num = Number(stripped);
+	if (num === 1 || num === -1) return num;
+	if ([
+		"text",
+		"2dsphere",
+		"2d",
+		"hashed"
+	].includes(stripped)) return stripped;
+	return 1;
+}
+function parseNumericArg(raw) {
+	if (!raw) return void 0;
+	const n = Number(raw);
+	return Number.isFinite(n) ? n : void 0;
+}
+function parseBooleanArg(raw) {
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+}
+function parseJsonArg(raw) {
+	if (!raw) return void 0;
+	const stripped = raw.replace(/^["']/, "").replace(/["']$/, "").replace(/\\"/g, "\"");
+	try {
+		const parsed = JSON.parse(stripped);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+	} catch {}
+}
+function parseCollation(attr) {
+	const locale = stripQuotesHelper(getNamedArgument(attr, "collationLocale"));
+	if (!locale) return getNamedArgument(attr, "collationStrength") != null || getNamedArgument(attr, "collationCaseLevel") != null || getNamedArgument(attr, "collationCaseFirst") != null || getNamedArgument(attr, "collationNumericOrdering") != null || getNamedArgument(attr, "collationAlternate") != null || getNamedArgument(attr, "collationMaxVariable") != null || getNamedArgument(attr, "collationBackwards") != null || getNamedArgument(attr, "collationNormalization") != null ? null : void 0;
+	const collation = { locale };
+	const strength = parseNumericArg(getNamedArgument(attr, "collationStrength"));
+	if (strength != null) collation.strength = strength;
+	const caseLevel = parseBooleanArg(getNamedArgument(attr, "collationCaseLevel"));
+	if (caseLevel != null) collation.caseLevel = caseLevel;
+	const caseFirst = stripQuotesHelper(getNamedArgument(attr, "collationCaseFirst"));
+	if (caseFirst != null) collation.caseFirst = caseFirst;
+	const numericOrdering = parseBooleanArg(getNamedArgument(attr, "collationNumericOrdering"));
+	if (numericOrdering != null) collation.numericOrdering = numericOrdering;
+	const alternate = stripQuotesHelper(getNamedArgument(attr, "collationAlternate"));
+	if (alternate != null) collation.alternate = alternate;
+	const maxVariable = stripQuotesHelper(getNamedArgument(attr, "collationMaxVariable"));
+	if (maxVariable != null) collation.maxVariable = maxVariable;
+	const backwards = parseBooleanArg(getNamedArgument(attr, "collationBackwards"));
+	if (backwards != null) collation.backwards = backwards;
+	const normalization = parseBooleanArg(getNamedArgument(attr, "collationNormalization"));
+	if (normalization != null) collation.normalization = normalization;
+	return collation;
+}
+function stripQuotesHelper(raw) {
+	if (!raw) return void 0;
+	return raw.replace(/^["']/, "").replace(/["']$/, "");
+}
+function parseProjectionList(raw, value) {
+	if (!raw) return void 0;
+	const inner = raw.replace(/^["']/, "").replace(/["']$/, "").replace(/^\[/, "").replace(/\]$/, "").trim();
+	if (inner.length === 0) return void 0;
+	const fields = inner.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+	const result = {};
+	for (const f of fields) result[f] = value;
+	return result;
+}
+function collectIndexes(pslModel, fieldMappings, modelNames, sourceId, diagnostics, indexSpans) {
+	const indexes = [];
+	let textIndexCount = 0;
+	const indexableFieldNames = /* @__PURE__ */ new Set();
+	for (const f of Object.values(pslModel.fields)) {
+		if (modelNames.has(f.typeName)) continue;
+		indexableFieldNames.add(f.name);
+	}
+	for (const field of Object.values(pslModel.fields)) {
+		if (modelNames.has(field.typeName)) continue;
+		const uniqueAttr = getAttribute(field.attributes, "unique");
+		if (!uniqueAttr) continue;
+		const fieldUniqueIndex = new MongoIndex({
+			keys: [{
+				field: fieldMappings.pslNameToMapped.get(field.name) ?? field.name,
+				direction: 1
+			}],
+			unique: true
+		});
+		indexes.push(fieldUniqueIndex);
+		indexSpans.set(fieldUniqueIndex, uniqueAttr.span);
+	}
+	for (const attr of pslModel.attributes) {
+		const isIndex = attr.name === "index";
+		const isUnique = attr.name === "unique";
+		const isTextIndex = attr.name === "textIndex";
+		if (!isIndex && !isUnique && !isTextIndex) continue;
+		const fieldsArg = getPositionalArgument(attr, 0);
+		if (!fieldsArg) continue;
+		const parsedFields = parseIndexFieldList(fieldsArg);
+		if (parsedFields.length === 0) continue;
+		const hasWildcard = parsedFields.some((f) => f.isWildcard);
+		if (parsedFields.filter((f) => f.isWildcard).length > 1) {
+			diagnostics.push({
+				code: "PSL_INVALID_INDEX",
+				message: "An index can contain at most one wildcard() field",
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		if (isUnique && hasWildcard) {
+			diagnostics.push({
+				code: "PSL_INVALID_INDEX",
+				message: "Unique indexes cannot use wildcard() fields",
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		if (isTextIndex) {
+			textIndexCount++;
+			if (textIndexCount > 1) {
+				diagnostics.push({
+					code: "PSL_INVALID_INDEX",
+					message: `Only one @@textIndex is allowed per collection (model "${pslModel.name}")`,
+					sourceId,
+					span: attr.span
+				});
+				continue;
+			}
+			if (hasWildcard) {
+				diagnostics.push({
+					code: "PSL_INVALID_INDEX",
+					message: "wildcard() fields cannot be combined with type: hashed/2dsphere/2d or @@textIndex",
+					sourceId,
+					span: attr.span
+				});
+				continue;
+			}
+		}
+		const typeArg = getNamedArgument(attr, "type");
+		const defaultDirection = isTextIndex ? "text" : parseIndexDirection(typeArg);
+		if (hasWildcard && typeof defaultDirection === "string" && [
+			"hashed",
+			"2dsphere",
+			"2d"
+		].includes(defaultDirection)) {
+			diagnostics.push({
+				code: "PSL_INVALID_INDEX",
+				message: `wildcard() fields cannot be combined with type: ${defaultDirection}`,
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		if (defaultDirection === "hashed" && parsedFields.length > 1) {
+			diagnostics.push({
+				code: "PSL_INVALID_INDEX",
+				message: "Hashed indexes must have exactly one field",
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		let missingField;
+		for (const pf of parsedFields) {
+			let fieldNameForLookup;
+			if (pf.isWildcard) {
+				const wildcardMatch = pf.name.match(/^(.+)\.\$\*\*$/);
+				fieldNameForLookup = wildcardMatch ? wildcardMatch[1] : void 0;
+			} else fieldNameForLookup = pf.name;
+			if (fieldNameForLookup === void 0 || fieldNameForLookup.length === 0) continue;
+			if (!indexableFieldNames.has(fieldNameForLookup)) {
+				missingField = fieldNameForLookup;
+				break;
+			}
+		}
+		if (missingField !== void 0) {
+			diagnostics.push({
+				code: "PSL_INDEX_FIELD_NOT_FOUND",
+				message: `Index on model "${pslModel.name}" references unknown field "${missingField}"`,
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		const keys = parsedFields.map((pf) => {
+			return {
+				field: pf.isWildcard ? pf.name.replace(/^(.+)\.\$\*\*$/, (_, prefix) => {
+					const mapped = fieldMappings.pslNameToMapped.get(prefix);
+					return mapped ? `${mapped}.$**` : `${prefix}.$**`;
+				}) : fieldMappings.pslNameToMapped.get(pf.name) ?? pf.name,
+				direction: pf.direction != null ? pf.direction : defaultDirection
+			};
+		});
+		const unique = isUnique ? true : void 0;
+		const sparse = isTextIndex ? void 0 : parseBooleanArg(getNamedArgument(attr, "sparse"));
+		const expireAfterSeconds = isTextIndex ? void 0 : parseNumericArg(getNamedArgument(attr, "expireAfterSeconds"));
+		if (hasWildcard && expireAfterSeconds != null) {
+			diagnostics.push({
+				code: "PSL_INVALID_INDEX",
+				message: "expireAfterSeconds cannot be combined with wildcard() fields",
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		const partialFilterExpression = parseJsonArg(getNamedArgument(attr, "filter"));
+		const includeArg = getNamedArgument(attr, "include");
+		const excludeArg = getNamedArgument(attr, "exclude");
+		if (includeArg != null && excludeArg != null) {
+			diagnostics.push({
+				code: "PSL_INVALID_INDEX",
+				message: "Cannot specify both include and exclude on the same index",
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		if ((includeArg != null || excludeArg != null) && !hasWildcard) {
+			diagnostics.push({
+				code: "PSL_INVALID_INDEX",
+				message: "include/exclude options are only valid when the index contains a wildcard() field",
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		const wildcardProjection = includeArg != null ? parseProjectionList(includeArg, 1) : excludeArg != null ? parseProjectionList(excludeArg, 0) : void 0;
+		const collation = parseCollation(attr);
+		if (collation === null) {
+			diagnostics.push({
+				code: "PSL_INVALID_INDEX",
+				message: "collationLocale is required when using collation options",
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		const rawWeights = parseJsonArg(getNamedArgument(attr, "weights"));
+		let weights;
+		if (rawWeights) {
+			weights = {};
+			for (const [k, v] of Object.entries(rawWeights)) if (typeof v === "number") weights[k] = v;
+		}
+		const default_language = stripQuotesHelper(isTextIndex ? getNamedArgument(attr, "language") : getNamedArgument(attr, "default_language"));
+		const language_override = stripQuotesHelper(getNamedArgument(attr, "languageOverride"));
+		const index = new MongoIndex({
+			keys,
+			...unique != null && { unique },
+			...sparse != null && { sparse },
+			...expireAfterSeconds != null && { expireAfterSeconds },
+			...partialFilterExpression != null && { partialFilterExpression },
+			...wildcardProjection != null && { wildcardProjection },
+			...collation != null && { collation },
+			...weights != null && { weights },
+			...default_language != null && { default_language },
+			...language_override != null && { language_override }
+		});
+		indexes.push(index);
+		indexSpans.set(index, attr.span);
+	}
+	return indexes;
+}
+function isRelationField(field, modelNames) {
+	return modelNames.has(field.typeName);
+}
+const MONGO_OBJECT_ID_PSL_TYPE = "ObjectId";
+function resolveFieldCodecId(field, scalarTypeCodecIds) {
+	return scalarTypeCodecIds.get(field.typeName);
+}
+function resolveNonRelationField(field, ownerName, compositeTypeNames, scalarTypeCodecIds, codecIdByEnumName, sourceId, diagnostics) {
+	if (compositeTypeNames.has(field.typeName)) {
+		const result = {
+			type: {
+				kind: "valueObject",
+				name: field.typeName
+			},
+			nullable: field.optional
+		};
+		return field.list ? {
+			...result,
+			many: true
+		} : result;
+	}
+	const enumCodecId = codecIdByEnumName.get(field.typeName);
+	if (enumCodecId !== void 0) {
+		const valueSet = {
+			plane: "domain",
+			entityKind: "enum",
+			namespaceId: UNBOUND_NAMESPACE_ID,
+			entityName: field.typeName
+		};
+		const result = {
+			type: {
+				kind: "scalar",
+				codecId: enumCodecId
+			},
+			nullable: field.optional,
+			valueSet
+		};
+		return field.list ? {
+			...result,
+			many: true
+		} : result;
+	}
+	if (field.malformedType) return;
+	const codecId = resolveFieldCodecId(field, scalarTypeCodecIds);
+	if (!codecId) {
+		diagnostics.push({
+			code: "PSL_UNSUPPORTED_FIELD_TYPE",
+			message: `Field "${ownerName}.${field.name}" type "${field.typeName}" is not supported in Mongo PSL interpreter`,
+			sourceId,
+			span: field.span
+		});
+		return;
+	}
+	const result = {
+		type: {
+			kind: "scalar",
+			codecId
+		},
+		nullable: field.optional
+	};
+	return field.list ? {
+		...result,
+		many: true
+	} : result;
+}
+function processEnumDeclarations(input) {
+	const builtEnums = {};
+	if (input.enumBlocks.length === 0) return builtEnums;
+	const enumDescriptor = input.authoringContributions?.entityTypes?.["enum"] !== void 0 && isAuthoringEntityTypeDescriptor(input.authoringContributions.entityTypes["enum"]) ? input.authoringContributions.entityTypes["enum"] : void 0;
+	if (!enumDescriptor) {
+		for (const decl of input.enumBlocks) input.diagnostics.push({
+			code: "PSL_ENUM_MISSING_FACTORY",
+			message: `enum "${decl.name}" requires an "enum" entityType factory in the active authoring contributions`,
+			sourceId: input.sourceId,
+			span: decl.span
+		});
+		return builtEnums;
+	}
+	for (const decl of input.enumBlocks) {
+		const handle = instantiateAuthoringEntityType("enum", enumDescriptor, [decl], input.entityContext);
+		if (handle === void 0 || handle === null) continue;
+		builtEnums[decl.name] = {
+			codecId: handle.codecId,
+			members: handle.enumMembers.map((m) => ({
+				name: m.name,
+				value: blindCast(m.value)
+			}))
+		};
+	}
+	return builtEnums;
+}
+function interpretPslDocumentToMongoContract(input) {
+	const { symbolTable, sourceFile, scalarTypeCodecIds, codecLookup } = input;
+	const sourceId = input.sourceId;
+	const diagnostics = [...input.seedDiagnostics ?? []];
+	const topLevel = symbolTable.topLevel;
+	validateNamespaceBlocksForMongoTarget({
+		namespaces: Object.values(topLevel.namespaces),
+		sourceId,
+		sourceFile,
+		diagnostics
+	});
+	const allModels = Object.values(topLevel.models);
+	const allCompositeTypes = Object.values(topLevel.compositeTypes);
+	const modelNames = new Set(allModels.map((m) => m.name));
+	const compositeTypeNames = new Set(allCompositeTypes.map((ct) => ct.name));
+	const builtEnums = processEnumDeclarations({
+		enumBlocks: Object.values(topLevel.blocks).filter((b) => b.keyword === "enum").map((b) => b.block),
+		sourceId,
+		authoringContributions: input.authoringContributions,
+		entityContext: {
+			family: "mongo",
+			target: "mongo",
+			...ifDefined("enumInferenceCodecs", input.enumInferenceCodecs),
+			...ifDefined("codecLookup", codecLookup),
+			sourceId,
+			diagnostics: { push: (d) => {
+				diagnostics.push(blindCast(d));
+			} }
+		},
+		diagnostics
+	});
+	const codecIdByEnumName = new Map(Object.entries(builtEnums).map(([name, e]) => [name, e.codecId]));
+	const models = {};
+	const collections = {};
+	const roots = {};
+	const allFkRelations = [];
+	const indexSpans = /* @__PURE__ */ new Map();
+	const modelIndexesByName = /* @__PURE__ */ new Map();
+	const backrelationCandidates = [];
+	for (const pslModel of allModels) {
+		const collectionName = resolveCollectionName(pslModel);
+		const fieldMappings = resolveFieldMappings(pslModel);
+		const fields = {};
+		const relations = {};
+		for (const field of Object.values(pslModel.fields)) {
+			if (isRelationField(field, modelNames)) {
+				const relation = parseRelationAttribute(field.attributes);
+				if (field.list || !(relation?.fields && relation?.references)) {
+					backrelationCandidates.push({
+						modelName: pslModel.name,
+						fieldName: field.name,
+						targetModelName: field.typeName,
+						...ifDefined("relationName", relation?.relationName),
+						cardinality: field.list ? "1:N" : "1:1",
+						field
+					});
+					continue;
+				}
+				if (relation?.fields && relation?.references) {
+					const localMapped = relation.fields.map((f) => fieldMappings.pslNameToMapped.get(f) ?? f);
+					const targetModel = allModels.find((m) => m.name === field.typeName);
+					const targetFieldMappings = targetModel ? resolveFieldMappings(targetModel) : void 0;
+					const targetMapped = relation.references.map((f) => targetFieldMappings?.pslNameToMapped.get(f) ?? f);
+					relations[field.name] = {
+						to: mongoCrossRef(field.typeName),
+						cardinality: "N:1",
+						on: {
+							localFields: localMapped,
+							targetFields: targetMapped
+						}
+					};
+					allFkRelations.push({
+						declaringModel: pslModel.name,
+						fieldName: field.name,
+						targetModel: field.typeName,
+						...ifDefined("relationName", relation.relationName),
+						localFields: localMapped,
+						targetFields: targetMapped
+					});
+				}
+				continue;
+			}
+			const resolved = resolveNonRelationField(field, pslModel.name, compositeTypeNames, scalarTypeCodecIds, codecIdByEnumName, sourceId, diagnostics);
+			if (!resolved) continue;
+			const mappedName = fieldMappings.pslNameToMapped.get(field.name) ?? field.name;
+			fields[mappedName] = resolved;
+		}
+		const isVariantModel = pslModel.attributes.some((attr) => attr.name === "base");
+		const hasIdField = Object.values(pslModel.fields).some((f) => getAttribute(f.attributes, "id") !== void 0);
+		if (!isVariantModel) if (!hasIdField) diagnostics.push({
+			code: "PSL_MISSING_ID_FIELD",
+			message: `Model "${pslModel.name}" has no field with @id attribute. Every model must have exactly one @id field.`,
+			sourceId
+		});
+		else {
+			const objectIdCodecId = scalarTypeCodecIds.get(MONGO_OBJECT_ID_PSL_TYPE);
+			const idField = fields["_id"];
+			if (!(idField !== void 0 && idField.type.kind === "scalar" && objectIdCodecId !== void 0 && idField.type.codecId === objectIdCodecId)) diagnostics.push({
+				code: "PSL_MONGO_ID_REQUIRED",
+				message: `Model "${pslModel.name}" must declare an _id field of type ObjectId (e.g. \`id ObjectId @id @map("_id")\`).`,
+				sourceId
+			});
+		}
+		models[pslModel.name] = {
+			fields,
+			relations,
+			storage: { collection: collectionName }
+		};
+		const modelIndexes = collectIndexes(pslModel, fieldMappings, modelNames, sourceId, diagnostics, indexSpans);
+		modelIndexesByName.set(pslModel.name, modelIndexes);
+		const existingColl = collections[collectionName];
+		if (existingColl && modelIndexes.length > 0) collections[collectionName] = { indexes: [...existingColl["indexes"] ?? [], ...modelIndexes] };
+		else if (!existingColl) collections[collectionName] = modelIndexes.length > 0 ? { indexes: modelIndexes } : {};
+		roots[collectionName] = mongoCrossRef(pslModel.name);
+	}
+	const valueObjects = {};
+	for (const compositeType of allCompositeTypes) {
+		const fields = {};
+		for (const field of Object.values(compositeType.fields)) {
+			const resolved = resolveNonRelationField(field, compositeType.name, compositeTypeNames, scalarTypeCodecIds, codecIdByEnumName, sourceId, diagnostics);
+			if (!resolved) continue;
+			fields[field.name] = resolved;
+		}
+		valueObjects[compositeType.name] = { fields };
+	}
+	const fkRelationsByPair = /* @__PURE__ */ new Map();
+	for (const fk of allFkRelations) {
+		const key = fkRelationPairKey(fk.declaringModel, fk.targetModel);
+		const existing = fkRelationsByPair.get(key);
+		if (existing) existing.push(fk);
+		else fkRelationsByPair.set(key, [fk]);
+	}
+	for (const candidate of backrelationCandidates) {
+		const pairKey = fkRelationPairKey(candidate.targetModelName, candidate.modelName);
+		const pairMatches = fkRelationsByPair.get(pairKey) ?? [];
+		const matches = candidate.relationName ? pairMatches.filter((r) => r.relationName === candidate.relationName) : [...pairMatches];
+		if (matches.length === 0) {
+			diagnostics.push({
+				code: "PSL_ORPHANED_BACKRELATION",
+				message: `Backrelation list field "${candidate.modelName}.${candidate.fieldName}" has no matching FK-side relation on model "${candidate.targetModelName}". Add @relation(fields: [...], references: [...]) on the FK-side relation or use an explicit join model for many-to-many.`,
+				sourceId,
+				span: candidate.field.span
+			});
+			continue;
+		}
+		if (matches.length > 1) {
+			diagnostics.push({
+				code: "PSL_AMBIGUOUS_BACKRELATION",
+				message: `Backrelation list field "${candidate.modelName}.${candidate.fieldName}" matches multiple FK-side relations on model "${candidate.targetModelName}". Add @relation("...") to both sides to disambiguate.`,
+				sourceId,
+				span: candidate.field.span
+			});
+			continue;
+		}
+		const fk = matches[0];
+		if (!fk) continue;
+		const modelEntry = models[candidate.modelName];
+		if (!modelEntry) continue;
+		modelEntry.relations[candidate.fieldName] = {
+			to: mongoCrossRef(candidate.targetModelName),
+			cardinality: candidate.cardinality,
+			on: {
+				localFields: fk.targetFields,
+				targetFields: fk.localFields
+			}
+		};
+	}
+	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(allModels, sourceId, diagnostics);
+	const polyResult = resolvePolymorphism({
+		models,
+		roots,
+		collections,
+		allModels,
+		discriminatorDeclarations,
+		baseDeclarations,
+		modelNames,
+		indexSpans,
+		modelIndexesByName,
+		sourceId
+	});
+	if (diagnostics.length > 0 || polyResult.diagnostics.length > 0) return notOk({
+		summary: "PSL to Mongo contract interpretation failed",
+		diagnostics: [...diagnostics, ...polyResult.diagnostics]
+	});
+	const resolvedModels = polyResult.models;
+	const resolvedCollections = polyResult.collections;
+	const storageValueSets = {};
+	const enumEntries = Object.entries(builtEnums);
+	if (enumEntries.length > 0) {
+		assertDefined(codecLookup, "Mongo PSL interpretation requires a codec lookup to encode enum values");
+		for (const [enumName, builtEnum] of enumEntries) storageValueSets[enumName] = {
+			kind: "valueSet",
+			values: builtEnum.members.map((m) => encodeEnumValue(m.value, builtEnum.codecId, codecLookup))
+		};
+	}
+	for (const [, modelEntry] of Object.entries(resolvedModels)) {
+		if (modelEntry.base) continue;
+		const coll = resolvedCollections[modelEntry.storage.collection];
+		if (!coll) continue;
+		if (modelEntry.discriminator && modelEntry.variants) {
+			const variantEntries = Object.entries(modelEntry.variants).map(([variantName, { value }]) => ({
+				discriminatorValue: value,
+				fields: resolvedModels[variantName]?.fields ?? {}
+			}));
+			coll["validator"] = derivePolymorphicJsonSchema(modelEntry.fields, modelEntry.discriminator.field, variantEntries, valueObjects, codecLookup, storageValueSets);
+		} else coll["validator"] = deriveJsonSchema(modelEntry.fields, valueObjects, codecLookup, storageValueSets);
+	}
+	const target = "mongo";
+	const targetFamily = "mongo";
+	const collectionInputs = {};
+	for (const [name, coll] of Object.entries(resolvedCollections)) {
+		const raw = {};
+		if (coll["indexes"] != null) raw["indexes"] = coll["indexes"];
+		if (coll["validator"] != null) raw["validator"] = coll["validator"];
+		if (coll["options"] != null) raw["options"] = coll["options"];
+		collectionInputs[name] = blindCast(raw);
+	}
+	const unboundNamespace = buildMongoNamespace({
+		id: UNBOUND_NAMESPACE_ID,
+		entries: {
+			collection: collectionInputs,
+			...Object.keys(storageValueSets).length > 0 ? { valueSet: storageValueSets } : {}
+		}
+	});
+	const storage = new MongoStorage({
+		storageHash: computeStorageHash({
+			target,
+			targetFamily,
+			storage: { namespaces: { [UNBOUND_NAMESPACE_ID]: {
+				id: UNBOUND_NAMESPACE_ID,
+				entries: {
+					collection: unboundNamespace.entries.collection,
+					...unboundNamespace.entries.valueSet !== void 0 ? { valueSet: unboundNamespace.entries.valueSet } : {}
+				}
+			} } },
+			...mongoContractCanonicalizationHooks
+		}),
+		namespaces: { [UNBOUND_NAMESPACE_ID]: unboundNamespace }
+	});
+	const capabilities = {};
+	const hasEnums = Object.keys(builtEnums).length > 0;
+	return ok({
+		targetFamily,
+		target,
+		roots: polyResult.roots,
+		domain: { namespaces: { [UNBOUND_NAMESPACE_ID]: {
+			models: polyResult.models,
+			...Object.keys(valueObjects).length > 0 ? { valueObjects } : {},
+			...hasEnums ? { enum: builtEnums } : {}
+		} } },
+		storage,
+		extensions: {},
+		capabilities,
+		profileHash: computeProfileHash({
+			target,
+			targetFamily,
+			capabilities
+		}),
+		meta: {}
+	});
+}
+//#endregion
+export { derivePolymorphicJsonSchema as n, interpretPslDocumentToMongoContract as r, deriveJsonSchema as t };
+
+//# sourceMappingURL=interpreter-BxbUTQ3k-ClR98Ned.mjs.map