Resolve subtypes for self referencing classes

[hhuber1]

Hi,
I am quite new in using Victools, and I have a problem which shows in an error message like

java.lang.IllegalStateException: SchemaDefinitionNamingStrategy of type CleanSchemaDefinitionNamingStrategy produced duplicate keys: ILogicOperator

Here is what I try to do:
I have an interface ILogicOperator

@JsonInclude(JsonInclude.Include.NON_EMPTY)
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "operator", defaultImpl = UnknownOperator.class)
public interface ILogicOperator {
	@JsonIgnore default String getOperator() {
		return this.getClass().getAnnotation(QueryOperator.class).value();
	}
}

which is implemented by many classes, e.g. the HasOperator:

@JsonInclude(JsonInclude.Include.NON_EMPTY)
@QueryOperator("has") public class HasOperator implements ILogicOperator {

   private String relationshipModel;
   /**
    * Target document role.
    */
   private String targetRole;
   /**
    * Constraint applied on target document.
    */
   private ILogicOperator constraint;
}

Please note, that the HasOperator references another ILogigOperator in its constraint property.

Because other projects that use our framework are allowed to extend the system by implementing their own operators, I cannot annotate ILogicOperator staticly with @JsonSubtypes.

Therefore, in the schema generator I try to resolve the subtype structure dynamically:

		ObjectMapper mapper = new ObjectMapper();
		JacksonModule module = new JacksonModule(
			JacksonOption.FLATTENED_ENUMS_FROM_JSONVALUE,
			JacksonOption.RESPECT_JSONPROPERTY_REQUIRED
		);
		SchemaGeneratorConfigBuilder configBuilder = new SchemaGeneratorConfigBuilder(mapper, SchemaVersion.DRAFT_2020_12, OptionPreset.PLAIN_JSON)
			.with(module)
			.with(Option.DEFINITIONS_FOR_MEMBER_SUPERTYPES);

		Reflections reflections = new Reflections("some.package");
		Set<Class<?>> queryOperators = reflections.getTypesAnnotatedWith(QueryOperator.class);
		configBuilder.forTypesInGeneral()
			.withSubtypeResolver((declaredType, generationContext) -> {
				if (declaredType.getErasedType() == ILogicOperator.class) {
					TypeContext typeContext = generationContext.getTypeContext();
					return queryOperators.stream()
						.map(c -> typeContext.resolveSubtype(declaredType, c))
						.toList();
				}
				return null;
			});
		SchemaGeneratorConfig config = configBuilder.build();
		SchemaGenerator jsonSchemaGenerator = new SchemaGenerator(config);

The Problem also arises if I try to resolve the hierarchy of th HasOperator only, like

configBuilder.forTypesInGeneral()
        .withSubtypeResolver((declaredType, generationContext) -> {
            TypeContext typeContext = generationContext.getTypeContext();
            if (declaredType.getErasedType() == ILogicOperator.class) {
                return Arrays.asList(
                    typeContext.resolveSubtype(declaredType, HasOperator.class)
                );
            }
            return null;
        });

My suspicion is that the problem is something to do with the self referencing classes that I pointed out above.

Is there a way to achieve a dynamic subtype resolution in my case?

[CarstenWickner]

Hi @hhuber1,

Sure, a dynamic lookup of subtypes is possible, and I tried to illustrate that in the SubtypeLookUpExample as well.
It is very similar to your Reflections approach (just using the ClassGraph library instead, since org.reflections is no longer maintained, I believe).

I reckon your issue is merely in this part of your SubtypeResolver:

return queryOperators.stream()
        .map(c -> typeContext.resolveSubtype(declaredType, c))
        .toList();

Is it possible that the annotation you're looking for here is on another type besides the ILogicOperator?

Set<Class<?>> queryOperators = reflections.getTypesAnnotatedWith(QueryOperator.class);

That could lead to typeContext.resolveSubtype(declaredType, c) returning ILogicOperator (and not a particular subtype) multiple times.
I'd recommend actually looking for subtypes (and potentially filtering them by having the annotation) instead of assuming that all types with that annotation are also subtypes of the ILogicOperator interface.