@prisma/orm-family-mongo 8.0.0-rc.8-dev.2 → 8.0.0-rc.8-dev.3

package/dist/{interpreter-BxbUTQ3k-ClR98Ned.mjs → interpreter-O09WlHk7-BiV9gBae.mjs}

@@ -7,11 +7,11 @@ 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 { bool, entityRef, fieldAttribute, fieldRef, funcCall, identifier, int, interpretAttribute, json, list, modelAttribute, nodePslSpan, num, oneOf, optional, record, str } 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
+//#region ../../../2-mongo-family/2-authoring/contract-psl/dist/interpreter-O09WlHk7.mjs
 function resolveBsonType(codecId, codecLookup) {
 	return codecLookup?.targetTypesFor(codecId)?.[0];
 }
@@ -113,91 +113,166 @@ function derivePolymorphicJsonSchema(baseFields, discriminatorField, variants, v
 		validationAction: "error"
 	});
 }
-function getPositionalArgument(attr, index = 0) {
-	return attr.args.filter((arg) => arg.kind === "positional")[index]?.value;
+function findModelAttributeNode(model, name) {
+	for (const attribute of model.node.attributes()) if (attribute.name()?.isSimpleName(name) === true) return attribute;
 }
-function getNamedArgument(attr, name) {
-	return attr.args.find((a) => a.kind === "named" && a.name === name)?.value;
+function findFieldAttributeNode(field, name) {
+	for (const attribute of field.node.attributes()) if (attribute.name()?.isSimpleName(name) === true) return attribute;
 }
-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
+function buildModelInterpretCtx(input) {
+	return {
+		level: "model",
+		sourceId: input.sourceId,
+		sourceFile: input.sourceFile,
+		selfModel: input.selfModel,
+		resolveReferencedModel: () => void 0
 	};
+}
+function buildFieldInterpretCtx(input) {
 	return {
-		name: segment,
-		isWildcard: false
+		level: "field",
+		sourceId: input.sourceId,
+		sourceFile: input.sourceFile,
+		selfModel: input.selfModel,
+		resolveReferencedModel: input.resolveReferencedModel ?? (() => void 0),
+		field: input.field
 	};
 }
-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;
-		}
+function interpretModelAttribute(input) {
+	const result = interpretAttribute(input.node, input.spec, buildModelInterpretCtx({
+		selfModel: input.model,
+		sourceFile: input.sourceFile,
+		sourceId: input.sourceId
+	}));
+	if (!result.ok) {
+		for (const failure of result.failure) input.diagnostics.push(failure);
+		return;
 	}
-	parts.push(input.slice(start));
-	return parts;
+	return result.value;
 }
-function lowerFirst(value) {
-	if (value.length === 0) return value;
-	return value[0]?.toLowerCase() + value.slice(1);
+function interpretFieldAttribute(input) {
+	const result = interpretAttribute(input.node, input.spec, buildFieldInterpretCtx({
+		selfModel: input.model,
+		field: input.field,
+		sourceFile: input.sourceFile,
+		sourceId: input.sourceId,
+		resolveReferencedModel: input.resolveReferencedModel
+	}));
+	if (!result.ok) {
+		for (const failure of result.failure) input.diagnostics.push(failure);
+		return;
+	}
+	return result.value;
 }
-function getAttribute(attributes, name) {
-	return attributes.find((attr) => attr.name === name);
+const mapModelSpec = modelAttribute("map", { positional: [{
+	key: "name",
+	type: str()
+}] });
+const mapFieldSpec = fieldAttribute("map", { positional: [{
+	key: "name",
+	type: str()
+}] });
+const relationFieldSpec = fieldAttribute("relation", {
+	positional: [{
+		key: "name",
+		type: optional(str())
+	}],
+	named: {
+		name: optional(str()),
+		fields: optional(list(fieldRef("self"), {
+			nonEmpty: true,
+			unique: true
+		})),
+		references: optional(list(fieldRef("referenced"), {
+			nonEmpty: true,
+			unique: true
+		}))
+	}
+});
+const discriminatorModelSpec = modelAttribute("discriminator", { positional: [{
+	key: "field",
+	type: fieldRef("self")
+}] });
+const baseModelSpec = modelAttribute("base", { positional: [{
+	key: "base",
+	type: entityRef()
+}, {
+	key: "value",
+	type: str()
+}] });
+const sortSig = { named: { sort: oneOf(identifier("Asc"), identifier("Desc")) } };
+function indexFieldElement(fieldNames) {
+	return oneOf(...[
+		fieldRef("self"),
+		funcCall("wildcard", { positional: [{
+			key: "scope",
+			type: optional(entityRef())
+		}] }),
+		...fieldNames.map((name) => funcCall(name, sortSig))
+	]);
 }
-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);
+const collationNamedArgs = {
+	collationLocale: optional(str()),
+	collationStrength: optional(oneOf(num(1), num(2), num(3), num(4), num(5))),
+	collationCaseLevel: optional(bool()),
+	collationCaseFirst: optional(oneOf(str("upper"), str("lower"), str("off"))),
+	collationNumericOrdering: optional(bool()),
+	collationAlternate: optional(oneOf(str("non-ignorable"), str("shifted"))),
+	collationMaxVariable: optional(oneOf(str("punct"), str("space"))),
+	collationBackwards: optional(bool()),
+	collationNormalization: optional(bool())
+};
+function buildIndexModelSpec(name, fieldElement) {
+	return modelAttribute(name, {
+		positional: [{
+			key: "fields",
+			type: list(fieldElement, { nonEmpty: true })
+		}],
+		named: {
+			type: optional(oneOf(num(1), num(-1), str("text"), str("2dsphere"), str("2d"), str("hashed"))),
+			sparse: optional(bool()),
+			expireAfterSeconds: optional(int()),
+			filter: optional(json()),
+			include: optional(list(str())),
+			exclude: optional(list(str())),
+			default_language: optional(str()),
+			languageOverride: optional(str()),
+			...collationNamedArgs
+		}
+	});
 }
-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;
+function buildTextIndexModelSpec(fieldElement) {
+	return modelAttribute("textIndex", {
+		positional: [{
+			key: "fields",
+			type: list(fieldElement, { nonEmpty: true })
+		}],
+		named: {
+			filter: optional(json()),
+			weights: optional(record(int({
+				min: 1,
+				max: 99999
+			}))),
+			language: optional(str()),
+			languageOverride: optional(str()),
+			...collationNamedArgs
+		}
+	});
+}
+function buildIndexModelSpecs(fieldNames) {
+	const fieldElement = indexFieldElement(fieldNames);
 	return {
-		...ifDefined("relationName", relationName),
-		...ifDefined("fields", fields),
-		...ifDefined("references", references)
+		index: buildIndexModelSpec("index", fieldElement),
+		unique: buildIndexModelSpec("unique", fieldElement),
+		textIndex: buildTextIndexModelSpec(fieldElement)
 	};
 }
-function stripQuotes(value) {
-	if (value.startsWith("\"") && value.endsWith("\"")) return value.slice(1, -1);
-	return value;
+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);
 }
 /**
 * Encode an authored enum value to its codec-encoded JSON form via the codec resolved by id from the
@@ -226,79 +301,87 @@ function validateNamespaceBlocksForMongoTarget(input) {
 function fkRelationPairKey(declaringModel, targetModel) {
 	return `${declaringModel}::${targetModel}`;
 }
-function resolveFieldMappings(model) {
+function resolveFieldMappings(input) {
+	const { model, sourceFile, sourceId, diagnostics } = input;
 	const pslNameToMapped = /* @__PURE__ */ new Map();
 	for (const field of Object.values(model.fields)) {
-		const mapped = getMapName(field.attributes) ?? field.name;
+		const mapNode = findFieldAttributeNode(field, "map");
+		const mapped = (mapNode ? interpretFieldAttribute({
+			node: mapNode,
+			spec: mapFieldSpec,
+			model,
+			field,
+			sourceFile,
+			sourceId,
+			diagnostics
+		})?.name : void 0) ?? field.name;
 		pslNameToMapped.set(field.name, mapped);
 	}
 	return { pslNameToMapped };
 }
-function resolveCollectionName(model) {
-	return getMapName(model.attributes) ?? lowerFirst(model.name);
+function resolveCollectionName(input) {
+	const { model, sourceFile, sourceId, diagnostics } = input;
+	const mapNode = findModelAttributeNode(model, "map");
+	return (mapNode ? interpretModelAttribute({
+		node: mapNode,
+		spec: mapModelSpec,
+		model,
+		sourceFile,
+		sourceId,
+		diagnostics
+	})?.name : void 0) ?? lowerFirst(model.name);
 }
 function mongoCrossRef(modelName) {
 	return crossRef(modelName, UNBOUND_NAMESPACE_ID);
 }
-function collectPolymorphismDeclarations(models, sourceId, diagnostics) {
+function collectPolymorphismDeclarations(models, modelMetadataByName, sourceFile, 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({
+	for (const model of models) {
+		const discNode = findModelAttributeNode(model, "discriminator");
+		if (discNode) {
+			const parsed = interpretModelAttribute({
+				node: discNode,
+				spec: discriminatorModelSpec,
+				model,
+				sourceFile,
+				sourceId,
+				diagnostics
+			});
+			if (parsed) {
+				const fieldName = parsed.field;
+				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
+					span: nodePslSpan(discNode.syntax, sourceFile)
 				});
-				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
+				else discriminatorDeclarations.set(model.name, {
+					fieldName,
+					span: nodePslSpan(discNode.syntax, sourceFile)
 				});
-				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
+		}
+		const baseNode = findModelAttributeNode(model, "base");
+		if (baseNode) {
+			const parsed = interpretModelAttribute({
+				node: baseNode,
+				spec: baseModelSpec,
+				model,
+				sourceFile,
+				sourceId,
+				diagnostics
+			});
+			if (parsed) {
+				const collectionName = modelMetadataByName.get(model.name)?.collectionName ?? lowerFirst(model.name);
+				baseDeclarations.set(model.name, {
+					baseName: parsed.base,
+					value: parsed.value,
+					collectionName,
+					span: nodePslSpan(baseNode.syntax, sourceFile)
 				});
-				continue;
 			}
-			const collectionName = resolveCollectionName(model);
-			baseDeclarations.set(model.name, {
-				baseName,
-				value,
-				collectionName,
-				span: attr.span
-			});
 		}
 	}
 	return {
@@ -307,7 +390,7 @@ function collectPolymorphismDeclarations(models, sourceId, diagnostics) {
 	};
 }
 function resolvePolymorphism(input) {
-	const { discriminatorDeclarations, baseDeclarations, modelNames, sourceId, allModels: allModelViews, indexSpans, modelIndexesByName } = input;
+	const { discriminatorDeclarations, baseDeclarations, modelNames, modelMetadataByName, sourceId, allModels: allModelViews, indexSpans, modelIndexesByName } = input;
 	let patched = input.models;
 	let roots = input.roots;
 	let collections = input.collections;
@@ -324,8 +407,7 @@ function resolvePolymorphism(input) {
 		}
 		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;
+		const mappedDiscriminatorField = modelMetadataByName.get(modelName)?.fieldMappings.pslNameToMapped.get(decl.fieldName) ?? decl.fieldName;
 		if (!Object.hasOwn(model.fields, mappedDiscriminatorField)) {
 			diagnostics.push({
 				code: "PSL_DISCRIMINATOR_FIELD_NOT_FOUND",
@@ -381,7 +463,7 @@ function resolvePolymorphism(input) {
 		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) {
+		if (getAttribute(variantModelView.attributes, "map") !== 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.`,
@@ -400,7 +482,7 @@ function resolvePolymorphism(input) {
 				storage: { collection: baseCollection }
 			}
 		};
-		const variantCollectionName = resolveCollectionName(variantModelView);
+		const variantCollectionName = modelMetadataByName.get(variantName)?.collectionName ?? lowerFirst(variantName);
 		if (roots[variantCollectionName]?.model === variantName) if (variantCollectionName === baseCollection && baseModel) roots = {
 			...roots,
 			[variantCollectionName]: mongoCrossRef(baseDecl.baseName)
@@ -432,7 +514,7 @@ function resolvePolymorphism(input) {
 		if (variantCollectionName !== baseCollection) {
 			const filtered = Object.fromEntries(Object.entries(collections).filter(([key]) => key !== variantCollectionName));
 			if (scopedVariantIndexes.length > 0 && baseColl) {
-				const baseIndexes = baseColl["indexes"] ?? [];
+				const baseIndexes = collectionIndexes(baseColl);
 				collections = {
 					...filtered,
 					[baseCollection]: {
@@ -442,7 +524,7 @@ function resolvePolymorphism(input) {
 				};
 			} else collections = filtered;
 		} else if (baseColl) {
-			const existingIndexes = baseColl["indexes"] ?? [];
+			const existingIndexes = collectionIndexes(baseColl);
 			const variantIndexSet = new Set(variantOwnIndexes);
 			const withoutUnscopedVariants = existingIndexes.filter((idx) => !variantIndexSet.has(idx));
 			const mergedIndexes = [...withoutUnscopedVariants];
@@ -468,84 +550,225 @@ function resolvePolymorphism(input) {
 		diagnostics
 	};
 }
+function collectionIndexes(collection) {
+	return blindCast(collection["indexes"] ?? []);
+}
 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 normalizeIndexField(element) {
+	if (typeof element === "string") return {
+		kind: "field",
+		name: element
+	};
+	if (element.fn === "wildcard" && element.args["sort"] === void 0) {
+		const scope = element.args["scope"];
+		return typeof scope === "string" ? {
+			kind: "wildcard",
+			scope
+		} : { kind: "wildcard" };
+	}
+	const sort = element.args["sort"];
+	return {
+		kind: "field",
+		name: element.fn,
+		direction: sort === "Desc" ? -1 : 1
+	};
 }
-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;
+function buildCollationFromSpec(args) {
+	const locale = args.collationLocale;
+	if (locale === void 0) return args.collationStrength !== void 0 || args.collationCaseLevel !== void 0 || args.collationCaseFirst !== void 0 || args.collationNumericOrdering !== void 0 || args.collationAlternate !== void 0 || args.collationMaxVariable !== void 0 || args.collationBackwards !== void 0 || args.collationNormalization !== void 0 ? 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;
+	if (args.collationStrength !== void 0) collation.strength = args.collationStrength;
+	if (args.collationCaseLevel !== void 0) collation.caseLevel = args.collationCaseLevel;
+	if (args.collationCaseFirst !== void 0) collation.caseFirst = args.collationCaseFirst;
+	if (args.collationNumericOrdering !== void 0) collation.numericOrdering = args.collationNumericOrdering;
+	if (args.collationAlternate !== void 0) collation.alternate = args.collationAlternate;
+	if (args.collationMaxVariable !== void 0) collation.maxVariable = args.collationMaxVariable;
+	if (args.collationBackwards !== void 0) collation.backwards = args.collationBackwards;
+	if (args.collationNormalization !== void 0) collation.normalization = args.collationNormalization;
 	return collation;
 }
-function stripQuotesHelper(raw) {
-	if (!raw) return void 0;
-	return raw.replace(/^["']/, "").replace(/["']$/, "");
+function resolveIndexKeys(parsedFields, defaultDirection, ctx) {
+	const wildcardCount = parsedFields.filter((field) => field.kind === "wildcard").length;
+	if (wildcardCount > 1) {
+		ctx.diagnostics.push({
+			code: "PSL_INVALID_INDEX",
+			message: "An index can contain at most one wildcard() field",
+			sourceId: ctx.sourceId,
+			span: ctx.span
+		});
+		return;
+	}
+	for (const field of parsedFields) {
+		const fieldName = field.kind === "wildcard" ? field.scope : field.name;
+		if (fieldName !== void 0 && !ctx.indexableFieldNames.has(fieldName)) {
+			ctx.diagnostics.push({
+				code: "PSL_INDEX_FIELD_NOT_FOUND",
+				message: `Index on model "${ctx.pslModel.name}" references unknown field "${fieldName}"`,
+				sourceId: ctx.sourceId,
+				span: ctx.span
+			});
+			return;
+		}
+	}
+	return {
+		keys: parsedFields.map((field) => {
+			if (field.kind === "wildcard") {
+				if (field.scope === void 0) return {
+					field: "$**",
+					direction: defaultDirection
+				};
+				return {
+					field: `${ctx.fieldMappings.pslNameToMapped.get(field.scope) ?? field.scope}.$**`,
+					direction: defaultDirection
+				};
+			}
+			return {
+				field: ctx.fieldMappings.pslNameToMapped.get(field.name) ?? field.name,
+				direction: field.direction ?? defaultDirection
+			};
+		}),
+		hasWildcard: wildcardCount === 1
+	};
 }
-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 buildProjection(include, exclude, hasWildcard, ctx) {
+	if (include !== void 0 && exclude !== void 0) {
+		ctx.diagnostics.push({
+			code: "PSL_INVALID_INDEX",
+			message: "Cannot specify both include and exclude on the same index",
+			sourceId: ctx.sourceId,
+			span: ctx.span
+		});
+		return null;
+	}
+	const fields = include ?? exclude;
+	if (fields === void 0) return void 0;
+	if (!hasWildcard) {
+		ctx.diagnostics.push({
+			code: "PSL_INVALID_INDEX",
+			message: "include/exclude options are only valid when the index contains a wildcard() field",
+			sourceId: ctx.sourceId,
+			span: ctx.span
+		});
+		return null;
+	}
+	if (fields.length === 0) return void 0;
+	const value = include === void 0 ? 0 : 1;
+	const projection = {};
+	for (const field of fields) projection[field] = value;
+	return projection;
+}
+function buildNormalIndex(parsed, unique, ctx) {
+	const parsedFields = parsed.fields.map(normalizeIndexField);
+	if (parsedFields.length === 0) return void 0;
+	const defaultDirection = parsed.type ?? 1;
+	const resolved = resolveIndexKeys(parsedFields, defaultDirection, ctx);
+	if (!resolved) return void 0;
+	if (unique && resolved.hasWildcard) {
+		ctx.diagnostics.push({
+			code: "PSL_INVALID_INDEX",
+			message: "Unique indexes cannot use wildcard() fields",
+			sourceId: ctx.sourceId,
+			span: ctx.span
+		});
+		return;
+	}
+	if (resolved.hasWildcard && typeof defaultDirection === "string" && [
+		"hashed",
+		"2dsphere",
+		"2d"
+	].includes(defaultDirection)) {
+		ctx.diagnostics.push({
+			code: "PSL_INVALID_INDEX",
+			message: `wildcard() fields cannot be combined with type: ${defaultDirection}`,
+			sourceId: ctx.sourceId,
+			span: ctx.span
+		});
+		return;
+	}
+	if (defaultDirection === "hashed" && parsedFields.length > 1) {
+		ctx.diagnostics.push({
+			code: "PSL_INVALID_INDEX",
+			message: "Hashed indexes must have exactly one field",
+			sourceId: ctx.sourceId,
+			span: ctx.span
+		});
+		return;
+	}
+	if (resolved.hasWildcard && parsed.expireAfterSeconds !== void 0) {
+		ctx.diagnostics.push({
+			code: "PSL_INVALID_INDEX",
+			message: "expireAfterSeconds cannot be combined with wildcard() fields",
+			sourceId: ctx.sourceId,
+			span: ctx.span
+		});
+		return;
+	}
+	const wildcardProjection = buildProjection(parsed.include, parsed.exclude, resolved.hasWildcard, ctx);
+	if (wildcardProjection === null) return void 0;
+	const collation = buildCollationFromSpec(parsed);
+	if (collation === null) {
+		ctx.diagnostics.push({
+			code: "PSL_INVALID_INDEX",
+			message: "collationLocale is required when using collation options",
+			sourceId: ctx.sourceId,
+			span: ctx.span
+		});
+		return;
+	}
+	return new MongoIndex({
+		keys: resolved.keys,
+		...unique && { unique: true },
+		...parsed.sparse !== void 0 && { sparse: parsed.sparse },
+		...parsed.expireAfterSeconds !== void 0 && { expireAfterSeconds: parsed.expireAfterSeconds },
+		...parsed.filter !== void 0 && { partialFilterExpression: parsed.filter },
+		...wildcardProjection !== void 0 && { wildcardProjection },
+		...collation !== void 0 && { collation },
+		...parsed.default_language !== void 0 && { default_language: parsed.default_language },
+		...parsed.languageOverride !== void 0 && { language_override: parsed.languageOverride }
+	});
+}
+function buildTextIndex(parsed, ctx) {
+	const parsedFields = parsed.fields.map(normalizeIndexField);
+	if (parsedFields.length === 0) return void 0;
+	const resolved = resolveIndexKeys(parsedFields, "text", ctx);
+	if (!resolved) return void 0;
+	if (resolved.hasWildcard) {
+		ctx.diagnostics.push({
+			code: "PSL_INVALID_INDEX",
+			message: "wildcard() fields cannot be combined with type: hashed/2dsphere/2d or @@textIndex",
+			sourceId: ctx.sourceId,
+			span: ctx.span
+		});
+		return;
+	}
+	const collation = buildCollationFromSpec(parsed);
+	if (collation === null) {
+		ctx.diagnostics.push({
+			code: "PSL_INVALID_INDEX",
+			message: "collationLocale is required when using collation options",
+			sourceId: ctx.sourceId,
+			span: ctx.span
+		});
+		return;
+	}
+	return new MongoIndex({
+		keys: resolved.keys,
+		...parsed.filter !== void 0 && { partialFilterExpression: parsed.filter },
+		...collation !== void 0 && { collation },
+		...ifDefined("weights", parsed.weights),
+		...parsed.language !== void 0 && { default_language: parsed.language },
+		...parsed.languageOverride !== void 0 && { language_override: parsed.languageOverride }
+	});
 }
-function collectIndexes(pslModel, fieldMappings, modelNames, sourceId, diagnostics, indexSpans) {
+function collectIndexes(pslModel, fieldMappings, modelNames, sourceId, sourceFile, 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)) indexableFieldNames.add(field.name);
 	for (const field of Object.values(pslModel.fields)) {
 		if (modelNames.has(field.typeName)) continue;
 		const uniqueAttr = getAttribute(field.attributes, "unique");
@@ -560,35 +783,31 @@ function collectIndexes(pslModel, fieldMappings, modelNames, sourceId, diagnosti
 		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",
+	const specs = buildIndexModelSpecs(Object.keys(pslModel.fields));
+	const attributeNodes = Array.from(pslModel.node.attributes());
+	for (const [attrIndex, attr] of pslModel.attributes.entries()) {
+		if (attr.name !== "index" && attr.name !== "unique" && attr.name !== "textIndex") continue;
+		const node = attributeNodes[attrIndex];
+		if (!node) continue;
+		const ctx = {
+			pslModel,
+			fieldMappings,
+			indexableFieldNames,
+			sourceId,
+			span: attr.span,
+			diagnostics
+		};
+		let index;
+		if (attr.name === "textIndex") {
+			const parsed = interpretModelAttribute({
+				node,
+				spec: specs.textIndex,
+				model: pslModel,
+				sourceFile,
 				sourceId,
-				span: attr.span
+				diagnostics
 			});
-			continue;
-		}
-		if (isTextIndex) {
+			if (!parsed || parsed.fields.length === 0) continue;
 			textIndexCount++;
 			if (textIndexCount > 1) {
 				diagnostics.push({
@@ -599,135 +818,21 @@ function collectIndexes(pslModel, fieldMappings, modelNames, sourceId, diagnosti
 				});
 				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",
+			index = buildTextIndex(parsed, ctx);
+		} else {
+			const unique = attr.name === "unique";
+			const parsed = interpretModelAttribute({
+				node,
+				spec: unique ? specs.unique : specs.index,
+				model: pslModel,
+				sourceFile,
 				sourceId,
-				span: attr.span
+				diagnostics
 			});
-			continue;
+			if (!parsed) continue;
+			index = buildNormalIndex(parsed, unique, ctx);
 		}
-		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 }
-		});
+		if (!index) continue;
 		indexes.push(index);
 		indexSpans.set(index, attr.span);
 	}
@@ -839,6 +944,21 @@ function interpretPslDocumentToMongoContract(input) {
 	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 modelMetadataByName = /* @__PURE__ */ new Map();
+	for (const model of allModels) modelMetadataByName.set(model.name, {
+		collectionName: resolveCollectionName({
+			model,
+			sourceFile,
+			sourceId,
+			diagnostics
+		}),
+		fieldMappings: resolveFieldMappings({
+			model,
+			sourceFile,
+			sourceId,
+			diagnostics
+		})
+	});
 	const builtEnums = processEnumDeclarations({
 		enumBlocks: Object.values(topLevel.blocks).filter((b) => b.keyword === "enum").map((b) => b.block),
 		sourceId,
@@ -864,19 +984,30 @@ function interpretPslDocumentToMongoContract(input) {
 	const modelIndexesByName = /* @__PURE__ */ new Map();
 	const backrelationCandidates = [];
 	for (const pslModel of allModels) {
-		const collectionName = resolveCollectionName(pslModel);
-		const fieldMappings = resolveFieldMappings(pslModel);
+		const metadata = modelMetadataByName.get(pslModel.name);
+		if (!metadata) continue;
+		const { collectionName, fieldMappings } = metadata;
 		const fields = {};
 		const relations = {};
 		for (const field of Object.values(pslModel.fields)) {
 			if (isRelationField(field, modelNames)) {
-				const relation = parseRelationAttribute(field.attributes);
+				const relationNode = findFieldAttributeNode(field, "relation");
+				const relation = relationNode ? interpretFieldAttribute({
+					node: relationNode,
+					spec: relationFieldSpec,
+					model: pslModel,
+					field,
+					sourceFile,
+					sourceId,
+					diagnostics,
+					resolveReferencedModel: () => allModels.find((m) => m.name === field.typeName)
+				}) : void 0;
 				if (field.list || !(relation?.fields && relation?.references)) {
 					backrelationCandidates.push({
 						modelName: pslModel.name,
 						fieldName: field.name,
 						targetModelName: field.typeName,
-						...ifDefined("relationName", relation?.relationName),
+						...ifDefined("relationName", relation?.name),
 						cardinality: field.list ? "1:N" : "1:1",
 						field
 					});
@@ -884,8 +1015,7 @@ function interpretPslDocumentToMongoContract(input) {
 				}
 				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 targetFieldMappings = modelMetadataByName.get(field.typeName)?.fieldMappings;
 					const targetMapped = relation.references.map((f) => targetFieldMappings?.pslNameToMapped.get(f) ?? f);
 					relations[field.name] = {
 						to: mongoCrossRef(field.typeName),
@@ -899,7 +1029,7 @@ function interpretPslDocumentToMongoContract(input) {
 						declaringModel: pslModel.name,
 						fieldName: field.name,
 						targetModel: field.typeName,
-						...ifDefined("relationName", relation.relationName),
+						...ifDefined("relationName", relation.name),
 						localFields: localMapped,
 						targetFields: targetMapped
 					});
@@ -932,10 +1062,10 @@ function interpretPslDocumentToMongoContract(input) {
 			relations,
 			storage: { collection: collectionName }
 		};
-		const modelIndexes = collectIndexes(pslModel, fieldMappings, modelNames, sourceId, diagnostics, indexSpans);
+		const modelIndexes = collectIndexes(pslModel, fieldMappings, modelNames, sourceId, sourceFile, diagnostics, indexSpans);
 		modelIndexesByName.set(pslModel.name, modelIndexes);
 		const existingColl = collections[collectionName];
-		if (existingColl && modelIndexes.length > 0) collections[collectionName] = { indexes: [...existingColl["indexes"] ?? [], ...modelIndexes] };
+		if (existingColl && modelIndexes.length > 0) collections[collectionName] = { indexes: [...collectionIndexes(existingColl), ...modelIndexes] };
 		else if (!existingColl) collections[collectionName] = modelIndexes.length > 0 ? { indexes: modelIndexes } : {};
 		roots[collectionName] = mongoCrossRef(pslModel.name);
 	}
@@ -991,7 +1121,7 @@ function interpretPslDocumentToMongoContract(input) {
 			}
 		};
 	}
-	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(allModels, sourceId, diagnostics);
+	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(allModels, modelMetadataByName, sourceFile, sourceId, diagnostics);
 	const polyResult = resolvePolymorphism({
 		models,
 		roots,
@@ -1002,6 +1132,7 @@ function interpretPslDocumentToMongoContract(input) {
 		modelNames,
 		indexSpans,
 		modelIndexesByName,
+		modelMetadataByName,
 		sourceId
 	});
 	if (diagnostics.length > 0 || polyResult.diagnostics.length > 0) return notOk({
@@ -1048,7 +1179,7 @@ function interpretPslDocumentToMongoContract(input) {
 			...Object.keys(storageValueSets).length > 0 ? { valueSet: storageValueSets } : {}
 		}
 	});
-	const storage = new MongoStorage({
+	const storage = blindCast(new MongoStorage({
 		storageHash: computeStorageHash({
 			target,
 			targetFamily,
@@ -1062,7 +1193,7 @@ function interpretPslDocumentToMongoContract(input) {
 			...mongoContractCanonicalizationHooks
 		}),
 		namespaces: { [UNBOUND_NAMESPACE_ID]: unboundNamespace }
-	});
+	}));
 	const capabilities = {};
 	const hasEnums = Object.keys(builtEnums).length > 0;
 	return ok({
@@ -1088,4 +1219,4 @@ function interpretPslDocumentToMongoContract(input) {
 //#endregion
 export { derivePolymorphicJsonSchema as n, interpretPslDocumentToMongoContract as r, deriveJsonSchema as t };
 
-//# sourceMappingURL=interpreter-BxbUTQ3k-ClR98Ned.mjs.map
+//# sourceMappingURL=interpreter-O09WlHk7-BiV9gBae.mjs.map