JSON

<dependency>
  <groupId>io.yupiik.fusion</groupId>
  <artifactId>fusion-json</artifactId>
  <version>${fusion.version}</version>
</dependency>

@JsonModel
public record MyModel(
    @JsonProperty("boolean") boolean aBool,
    BigDecimal bigDecimal,
    int integer,
    Integer nullableInt,
    long lg,
    double more,
    String simplest,
    LocalDate date,
    LocalDateTime dateTime,
    OffsetDateTime offset,
    ZonedDateTime zoned,
    Object generic,
    AnotherModel nested,
    List<Boolean> booleanList,
    List<BigDecimal> bigDecimalList,
    List<Integer> intList,
    Collection<Long> longList,
    List<Double> doubleList,
    Set<String> stringList,
    List<LocalDate> dateList,
    List<LocalDateTime> dateTimeList,
    List<OffsetDateTime> offsetList,
    List<ZonedDateTime> zonedList,
    List<Object> genericList,
    List<AnotherModel> nestedList,
    Map<String, String> mapStringString,
    Map<String, Integer> mapStringInt,
    Map<String, AnotherModel> mapNested) {
}

@ApplicationScoped
public class MyService extends HttpServlet {
    @Injection
    JsonMapper mapper;

    @Override
    public void doGet(final HttpServletRequest req, final HttpServletResponse resp) throws IOException {
        try (final var out = resp.getWriter()) {
            mapper.write(createMyModelInstance(req), out);
        }
    }
}

@JsonModel
public record MyModel(
    String name,
    @JsonIgnore String internalSecret) { (1)
}

public enum MyEnum {
    A, B;

    public String toJsonString() { (1)
        return this == A ? "first" : "second";
    }

    public static MyEnum fromJsonString(final String v) { (2)
        return switch (v) {
            case "first" -> MyEnum.A;
            case "second" -> MyEnum.B;
            default -> throw new IllegalArgumentException("Unsupported '" + v + "'");
        };
    }
}

// is reusable
final var patch = new GenericJsonPatch(List.of(new JsonPatchOperation(add, "/baz", null, "qux")));

// "runtime"
final var object = Map.of("foo", "bar");
final var patched = patch.apply(object);
// patched={"foo":"bar","baz":"qux"}

@ApplicationScoped
public class MyService {

    @Injection
    JsonMapper mapper;

    public boolean validate(final MyModel myModel) throws IOException {
        final var schema = mapper.fromString(Object.class,
                """
                        {
                          "$id": "https://spec.openapis.org/oas/3.1/schema/2022-10-07",
                          "$schema": "https://json-schema.org/draft/2020-12/schema",
                          "description": "The description of OpenAPI v3.1.x documents without schema validation, as defined by https://spec.openapis.org/oas/v3.1.0",
                          "type": "object"
                          ...
                        }
                      """); (1)
        final JsonSchemaValidatorFactory factory = new JsonSchemaValidatorFactory(); (2)
        final JsonSchemaValidator validator = factory.newInstance((Map<String, Object>) schema); (3)
        final var result = validator.apply(myModel); (4)
        validator.close();
        return result.isSuccess(); (5)
    }
}

final var result = validator.apply(myModel);
final var error = result.errors().iterator().next();
logger.info("Error on field '" + error.field() + "' " + error.message());

final JsonSchemaService service = new JsonSchemaService(); // or @Injection

// convert a single generic schema
final Map<String, Object> converted = service.toJsonSchema202012(rawSchemaMap); // (1)

// convert the whole "schemas.json" bundle {"schemas": {...}} into a document with a root $defs
final var bundle = mapper.fromString(Object.class, json);
final Map<String, Object> document = service.to2020Bundle((Map<String, Object>) bundle); // (2)

// read one schema-json payload into the typed model with the standard mapper
final RawBuildJsonSchema schema = mapper.read(RawBuildJsonSchema.class, reader);
final Map<String, Object> converted = service.toJsonSchema202012(schema); // -> Draft 2020-12

import io.yupiik.fusion.framework.build.api.scanning.Injection;
import io.yupiik.fusion.json.JsonMapper;
import io.yupiik.fusion.json.pretty.PrettyJsonMapper;

@ApplicationScoped
public class MyClass {

    @Injection
    JsonMapper jsonMapper;

    public void printJson() {
        final JsonMapper prettyJsonMapper = new PrettyJsonMapper(jsonMapper); (1)
        logger.info(prettyJsonMapper.toString(instance)); (2)
    }
}