Module for gson

[marcelrv]

First of all, thank you for your generator.. It saves me from maintaining documentation by hand.

I was looking for module based on GSON as my project uses that instead of Jackson.
The property name with gson is defined with the @SerializedName("jsonProperty") annotation.

Is there such a module already available to your knowledge (my google search did not result in any..)

If not, any hint on how to get access to this annotation and update the proprty in the schema. Was trying to use
.withTypeAttributeOverride((collectedTypeAttributes, scope, context) but sofar without success.

[CarstenWickner]

Hi @marcelrv,

there's no standard module for gson yet to my knowledge.
However, it should be straightforward to achieve what you want with a "Property Name Override", documented here:
https://victools.github.io/jsonschema-generator/#names-of-fields-methods-in-an-object-39-s-properties
You can easily adapt the given jackson example to your gson use-case, like this:

configBuilder.forFields()
    .withPropertyNameOverrideResolver(field -> Optional
            .ofNullable(field.getAnnotationConsideringFieldAndGetter(SerializedName.class))
            .map(SerializedName::value).orElse(null));

The "Type Attribute Override" is more powerful but also way more complicated if you only want to change the name of a given property. 😉

[marcelrv]

Thanks, works like a charm!

maybe one more question in this area.
I was hoping to be able to do something similar with org.eclipse.jdt.annotation.Nullable but somehow it does not 'see' the annotation

e.g. my class has some members as nullable, some as NonNull. I would like the Nullable ones as not required.

    @SerializedName("friendlyName")
    @Expose
    @Schema(description = "Friendly channel name as seen in the UI")
    private @Nullable String friendlyName;
    @SerializedName("channel")
    @Expose
    private @NonNull String channel;

Following the examples I assumed this would work well. But even for friendlyName which has @Nullable it returns null

configBuilder.forFields()
    .withRequiredCheck(field -> field.getAnnotationConsideringFieldAndGetter(Nullable.class) == null);

[marcelrv]

Deepdiving a bit I now understand org.eclipse.jdt.annotation.Nullable is not available because it is a Retention.CLASS annotated class, not a RetentionPolicy.RUNTIME hence not available at runtime.
Dunno if there is a way to still be able to access it... googling does not give clear way

[CarstenWickner]

Hi @marcelrv,

Do you need to support three states here?

1. with @Nullable annotation = not "required"
2. with @NotNull annotation = "required"
3. without @Nullable or @NotNull annotation = ?

If the third case doesn't exist or also means the property is not "required", then you can simply invert the check:

configBuilder.forFields()
    .withRequiredCheck(field -> field.getAnnotationConsideringFieldAndGetter(NotNull.class) != null);

Side note: the above would also be part of the JavaxValidationModule/JakartaValidationModule respectively.
That can be enabled via the respective NOT_NULLABLE_FIELD_IS_REQUIRED option.

[CarstenWickner]

Closing this then as I currently don't intend to create a gson module.

That being said, I'd be open for a pull request adding such a module and would then be willing to maintain it afterwards – same as for the Maven plugin and Jakarta module, which were also contributions from others.

[marcelrv]

Sure. Thanks for your help! My GSON issue is resolved indeed. I'll check if I can create a PR for it.
Note: The Nullable annotation issue org.eclipse.jdt.annotation.Nullable not available due to it being a Retention.CLASS annotated class, is something very seprate.. but not yet resolved for me. The issue is not the 3 states, but instead that field.getAnnotationConsideringFieldAndGetter(NotNull.class) always returns null indifferent if the annotation is there or not.

Documenting for anyone searching for the same GSON question:

The key GSON functionality indeed is mainly resolved by adding these lines:

//if the field should be included yes/no based on GSON Expose declaration
       configBuilder.forFields().withIgnoreCheck(field -> {
            Expose b = field.getAnnotationConsideringFieldAndGetter(Expose.class);
            return b != null && !b.serialize();
        });

//Take the property name from the GSON SerializedName declaration
        configBuilder.forFields().withPropertyNameOverrideResolver(
                field -> Optional.ofNullable(field.getAnnotationConsideringFieldAndGetter(SerializedName.class))
                        .map(SerializedName::value).orElse(null));

[torrespro]

I added. PR for this: #448

[matusfaro]

Additional case for when using @SerializedName on an enum such as:

public enum Version {
    @SerializedName("V0.0.0")
    V_0_0_0
}

Here is to cover this case:

import com.fasterxml.classmate.ResolvedType;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.github.victools.jsonschema.generator.CustomDefinition;
import com.github.victools.jsonschema.generator.CustomDefinitionProviderV2;
import com.github.victools.jsonschema.generator.SchemaGenerationContext;
import com.github.victools.jsonschema.generator.SchemaKeyword;
import com.github.victools.jsonschema.generator.impl.AttributeCollector;
import com.google.gson.annotations.SerializedName;

import java.util.ArrayList;
import java.util.List;

public class GsonCustomEnumDefinitionProvider implements CustomDefinitionProviderV2 {

    @Override
    public CustomDefinition provideCustomSchemaDefinition(ResolvedType javaType, SchemaGenerationContext context) {
        Object[] enumConstants = javaType.getErasedType().getEnumConstants();
        if (enumConstants == null || enumConstants.length == 0) {
            return null;
        }
        List<?> serializedJsonValues = this.getSerializedValuesFromSerializedName(javaType, enumConstants);
        if (serializedJsonValues == null) {
            return null;
        }

        ObjectNode customNode = context.getGeneratorConfig().createObjectNode()
                .put(context.getKeyword(SchemaKeyword.TAG_TYPE), context.getKeyword(SchemaKeyword.TAG_TYPE_STRING));
        AttributeCollector standardAttributeCollector = new AttributeCollector(context.getGeneratorConfig().getObjectMapper());
        standardAttributeCollector.setEnum(customNode, serializedJsonValues, context);
        return new CustomDefinition(customNode);
    }


    protected List<String> getSerializedValuesFromSerializedName(ResolvedType javaType, Object[] enumConstants) {
        try {
            boolean anyHasSerializedName = false;
            List<String> serializedJsonValues = new ArrayList<>(enumConstants.length);
            for (Object enumConstant : enumConstants) {
                String enumValueName = ((Enum<?>) enumConstant).name();
                SerializedName annotation = javaType.getErasedType()
                        .getDeclaredField(enumValueName)
                        .getAnnotation(SerializedName.class);
                if (annotation != null) {
                    anyHasSerializedName = true;
                }
                serializedJsonValues.add(annotation == null ? enumValueName : annotation.value());
            }
            return anyHasSerializedName ? serializedJsonValues : null;
        } catch (NoSuchFieldException | SecurityException ex) {
            return null;
        }
    }
}

Extend the config builder:

configBuilder.forTypesInGeneral().withCustomDefinitionProvider(new GsonCustomEnumDefinitionProvider());