EnumSet Use and Configuration

[dalucasPeraton]

I am having an issue with jsonschema output when using an enumset and its unclear if its an Option Setting or something else.

e.g.,

MyEnum = {"OPTION1","OPTION2","OPTION3"}

private final EnumSet myProperty = EnumSet.of(MyEnum.OPTION1, MyEnum.OPTION3);

"my_property" : { "description" : "Options for the selectable item", "type" : "array", "items" : { "type" : "string", "enum" : [ "Option1", "Option2", "Option3" ] } },

The expectation would only contain Option 1 and Option 3.

[CarstenWickner]

Hi @dalucasPeraton,

There are a couple of configuration options for enums in general.

But you're expecting instance data to be considered, which is not supported out of the box for this kind of non-static variable.
The only feature in that direction (Option.VALUES_FROM_CONSTANT_FIELDS) is limited to static final fields. You may want to have a look at it's implementation for reference, when you create the custom configuration of your own.

[CarstenWickner]

For completeness' sake, this is what it could look like:

public class EnumSetExample303 {

    public static void main(String[] args) throws JsonProcessingException {
        SchemaGeneratorConfigBuilder builder = new SchemaGeneratorConfigBuilder(SchemaVersion.DRAFT_2020_12, OptionPreset.PLAIN_JSON);
        builder.forFields()
                .withCustomDefinitionProvider(new EnumSetFieldDefinitionProvider());
        JsonNode jsonSchema = new SchemaGenerator(builder.build()).generateSchema(SchemaTarget.class);
        System.out.println(jsonSchema.toPrettyString());
    }

    static class SchemaTarget {
        private final EnumSet<MyEnum> enumSet = EnumSet.of(MyEnum.ONE, MyEnum.THREE);

        public EnumSet<MyEnum> getEnumSet() {
            return this.enumSet;
        }
    }

    private static enum MyEnum {
        ONE, TWO, THREE;
    }

    private static class EnumSetFieldDefinitionProvider implements CustomPropertyDefinitionProvider<FieldScope> {

        @Override
        public CustomPropertyDefinition provideCustomSchemaDefinition(FieldScope scope, SchemaGenerationContext context) {
            if (!scope.isFinal() || scope.getType().getErasedType() != EnumSet.class
                    || (scope.isPrivate() && (!scope.hasGetter() || scope.findGetter().isPrivate()))) {
                return null;
            }
            ResolvedType declaringType = scope.getDeclaringType();
            Optional<RawConstructor> paramLessConstructor = declaringType.getConstructors().stream()
                    .filter(constructor -> constructor.getRawMember().getParameterCount() == 0)
                    .findFirst();
            if (!paramLessConstructor.isPresent()) {
                return null;
            }
            try {
                Object declaringInstance = paramLessConstructor.get().getRawMember().newInstance();
                Object enumSetInstance = scope.isPrivate()
                        ? scope.findGetter().getRawMember().invoke(declaringInstance)
                        : scope.getMember().getRawMember().get(declaringInstance);
                ObjectNode fieldSchema = context.createStandardDefinition(scope, this);
                ObjectNode setItemSchema = fieldSchema.with(context.getKeyword(SchemaKeyword.TAG_ITEMS));
                setItemSchema.remove(context.getKeyword(SchemaKeyword.TAG_CONST));
                ArrayNode enumPropertyArray = setItemSchema.withArray(context.getKeyword(SchemaKeyword.TAG_ENUM));
                enumPropertyArray.removeAll();
                ((EnumSet<?>) enumSetInstance).forEach(enumValue -> enumPropertyArray.add(enumValue.toString()));
                return new CustomPropertyDefinition(fieldSchema);
            } catch (Exception ex) {
                // inaccessible constructor (e.g. a private one)
                ex.printStackTrace();
                return null;
            }
        }
    }
}

This produces:

{
  "$schema" : "https://json-schema.org/draft/2020-12/schema",
  "type" : "object",
  "properties" : {
    "enumSet" : {
      "type" : "array",
      "items" : {
        "enum" : [ "ONE", "THREE" ],
        "type" : "string"
      }
    }
  }
}

That begs the question though, why you'd have a private final EnumSet in the first place.
That could just as well be a private static final constant, which the Option.VALUES_FROM_CONSTANT_FIELDS should pick up for you.