Issue generating nested interface object

[patpatpat123]

Hello team,

This is my first issue in this repo.

If nothing else, big thanks for this project. It is easy to understand, easy to use.

I wanted to reach out highlighting an issue generating a nested interface object please.

Please allow me to show a simple concrete example.

I have a class Farm which contains one (it is an example) Animal (interface).

The concrete Animal would be a Cow, Sheep, whatever.

public class Farm {

    private String name;
    private int capacity;
    private Animal animal;

//getters and setters

public interface Animal {

}

public class Cow implements Animal {

    private String name;
    private int age;

//getters and setters

public class Sheep implements Animal {

    private String name;
    private String color;

//getters and setters

I am using this code in order to generate the schema:

public class GenerateSchemaTest {

    public static void main(String[] args) throws JsonProcessingException {
         SchemaGeneratorConfigBuilder configBuilder = new SchemaGeneratorConfigBuilder(SchemaVersion.DRAFT_2020_12, OptionPreset.PLAIN_JSON);
        SchemaGeneratorConfig config = configBuilder.build();
        SchemaGenerator generator = new SchemaGenerator(config);
        JsonNode jsonSchema = generator.generateSchema(Farm.class);

        System.out.println(jsonSchema.toPrettyString());
    }

}

And I was hoping to get something like this: (Expected result)

{
  "type" : "object",
  "id" : "urn:jsonschema:com:schema:Farm",
  "properties" : {
    "name" : {
      "type" : "string"
    },
    "capacity" : {
      "type" : "integer"
    },
    "animal" : {
      "type" : "object",
     "id" : "urn:jsonschema:com:schema:Cow",
  "properties" : {
    "name" : {
      "type" : "string"
    },
    "age" : {
      "type" : "integer"
    }
  }
    }
  }
}

or the similar with the sheep, basically, the concrete class of Animal

However, I am getting this: (Actual result)

{
  "type" : "object",
  "id" : "urn:jsonschema:com:schema:Farm",
  "properties" : {
    "name" : {
      "type" : "string"
    },
    "capacity" : {
      "type" : "integer"
    },
    "animal" : {
      "type" : "object",
      "id" : "urn:jsonschema:com:schema:Animal"
    }
  }
}

Could you please help on this issue to generate the schema for a nested class please?

Thank you

[CarstenWickner]

Hi @patpatpat123,

Thank you for the kind praise. 😄

On the matter of handling subtypes, there are a couple of ways to go about it.

Main Options

Target Type Override

If you want to explicitly replace the Animal interface with a single subtype and effectively hide the fact that in your code it is declared just as Animal, then you can use a "Target Type Override".

configBuilder.forFields()
    .withTargetTypeOverridesResolver(field -> field.getType().getErasedType() == Animal.class
            ? List.of(field.getContext().resolve(Cow.class)) : null);

Subtype Resolver

You can configure a "Subtype Resolver", which identifies all the subtypes of a given interface/superclass.
As it so happens, the example in the documentation is also for animals. 😉

configBuilder.forTypesInGeneral()
    .withSubtypeResolver((declaredType, generationContext) -> {
        if (declaredType.getErasedType() == Animal.class) {
            TypeContext typeContext = generationContext.getTypeContext();
            return List.of(
                    typeContext.resolveSubtype(declaredType, Cow.class),
                    typeContext.resolveSubtype(declaredType, Sheep.class)
            );
        }
        return null;
    });

You can also use a library like "classgraph" to automatically find all eligible subtypes instead of explicitly mentioning them like this.

Jackson Module

Yet another option would be to leverage existing annotations that indicate what the relevant subtypes are. In case you were using the Jackson libraries for serializing your data to JSON, you might already have @JsonSubTypes and/or @JsonTypeInfo annotations on such interfaces/classes.
Then, it might be convenient to utilize the standard JacksonModule.

configBuilder.with(new JacksonModule());

Comparison

The aforementioned options are not the only ones available, but they are intended to be the most convenient ways to go about this. There are slight differences though:

Option	Declared Type	Subtypes	Prerequisite
Target Type Override	The originally declared type being replaced does not have to be a supertype/interface and will not be mentioned in the produced schema.	The referenced subtypes (can be multiple), are shown as if they were directly declared on the respective field/method.	Either you hard-code the replacements directly in the configuration, derive it from some annotation, or use reflection to look-up the subtypes dynamically.
Subtype Resolver	When the originally declared type appears multiple times or you explicitly enabled the dedicated schema for supertypes, then it (in your case Animal) will be listed as a separate definition.	The subtypes are listed in an anyOf within their supertype's definition.	Same as above: hard-coded in configuration or somehow dynamically determined.
Jackson Module	Behaviour as per the Subtype Resolver, which is used internally.	As per the Subtype Resolver. Potentially even with additional properties or wrapping elements, that indicate in a serialized JSON which subtype it is.	The presence of @JsonSubTypes annotations is expected.

Summary

You have various ways to tackle this. It all depends on what information (e.g. in annotations) is already present in your code and how flexible it needs to be.
If you have more specific questions, don't hesitate to ask. 😃