@zenstackhq/language 3.7.0 → 3.7.1

package/dist/index.mjs

@@ -4577,6 +4577,7 @@ var DataModelValidator = class {
 		this.validateFields(dm, accept);
 		if (dm.mixins.length > 0) this.validateMixins(dm, accept);
 		this.validateInherits(dm, accept);
+		this.validateDelegateMap(dm, accept);
 	}
 	validateFields(dm, accept) {
 		const allFields = getAllFields(dm);
@@ -4807,6 +4808,57 @@ var DataModelValidator = class {
 			todo.push(...current.mixins.map((mixin) => mixin.ref));
 		}
 	}
+	validateDelegateMap(dm, accept) {
+		const delegateMapAttrs = dm.attributes.filter((attr) => attr.decl.$refText === "@@delegateMap");
+		if (delegateMapAttrs.length > 1) accept("error", "Model can include at most one @@delegateMap attribute", { node: delegateMapAttrs[1] });
+		const delegateMapAttr = delegateMapAttrs[0];
+		if (delegateMapAttr) {
+			if (!dm.baseModel) accept("error", "`@@delegateMap` can only be used on models that extend a delegate base model", { node: delegateMapAttr });
+			else if (dm.baseModel.ref) this.validateDelegateMapValue(dm.baseModel.ref, delegateMapAttr, accept);
+		}
+		if (!hasAttribute(dm, "@@delegate")) return;
+		const subModels = dm.$container.declarations.filter(isDataModel).filter((model) => model.baseModel?.ref === dm);
+		if (subModels.length === 0) return;
+		const seen = /* @__PURE__ */ new Map();
+		subModels.forEach((model) => {
+			const value = this.getDelegateMapRawValue(model) ?? model.name;
+			const existing = seen.get(value);
+			if (existing) accept("error", `Duplicate @@delegateMap value "${value}" on models "${existing.name}" and "${model.name}"`, { node: model });
+			else seen.set(value, model);
+		});
+	}
+	getDelegateMapRawValue(dm) {
+		const valueExpr = dm.attributes.find((attr) => attr.decl.$refText === "@@delegateMap")?.args[0]?.value;
+		if (!valueExpr) return;
+		if (isStringLiteral(valueExpr)) return valueExpr.value;
+		if (isEnumFieldReference(valueExpr)) return valueExpr.target.ref?.name;
+	}
+	validateDelegateMapValue(baseModel, attr, accept) {
+		const delegateMapValueExpr = attr.args[0]?.value;
+		if (!delegateMapValueExpr) {
+			accept("error", "`@@delegateMap` expects a value", { node: attr });
+			return;
+		}
+		const delegateAttr = getAttribute(baseModel, "@@delegate");
+		const discriminatorArg = delegateAttr && getAttributeArg(delegateAttr, "discriminator");
+		const discriminatorRef = discriminatorArg && isReferenceExpr(discriminatorArg) ? discriminatorArg.target.ref : void 0;
+		if (!discriminatorRef || !isDataField(discriminatorRef)) return;
+		const discriminatorType = discriminatorRef.type;
+		const discriminatorEnum = discriminatorType.reference?.ref;
+		if (isEnumFieldReference(delegateMapValueExpr)) {
+			if (!isEnum(discriminatorEnum)) {
+				accept("error", "`@@delegateMap` enum value cannot be used when the discriminator field is String", { node: delegateMapValueExpr });
+				return;
+			}
+			if (delegateMapValueExpr.target.ref?.$container !== discriminatorEnum) accept("error", "`@@delegateMap` enum value must come from the discriminator enum type", { node: delegateMapValueExpr });
+			return;
+		}
+		if (isStringLiteral(delegateMapValueExpr)) {
+			if (discriminatorType.type !== "String") accept("error", "`@@delegateMap` string value must match a String discriminator field", { node: delegateMapValueExpr });
+			return;
+		}
+		accept("error", "`@@delegateMap` expects a string literal or enum value", { node: delegateMapValueExpr });
+	}
 };
 //#endregion
 //#region src/validators/datasource-validator.ts