- support for OAS 3.0 nullable

- better error messages for duplicated schemas - improved support for in-schema target definitions

Author: bartoszm

src/main/java/com/amartus/sonata/blender/cmd/AbstractBlend.java

@@ -19,13 +19,15 @@
 package com.amartus.sonata.blender.cmd;
 
 import com.amartus.sonata.blender.impl.ProductSpecReader;
-import com.amartus.sonata.blender.impl.util.Pair;
 import com.amartus.sonata.blender.impl.util.PathResolver;
 import com.amartus.sonata.blender.parser.DeserializerProvider;
 import com..rvesse.airline.annotations.Option;
 import com..rvesse.airline.annotations.restrictions.MutuallyExclusiveWith;
 import com..rvesse.airline.annotations.restrictions.Once;
 import io.swagger.v3.oas.models.media.Schema;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.commons.lang3.tuple.Triple;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -34,6 +36,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -95,14 +98,78 @@ public abstract class AbstractBlend {
 protected Map<String, Schema> toProductSpecifications() {
 var config = new ProductSpecReader.Options(modelToAugment, autodiscover);
 
-return toSchemaPaths(blendingSchemas())
-.flatMap(schema -> new ProductSpecReader(config, schema.first(), schema.second(), new DeserializerProvider(), ProductSpecReader.defaultOptions()).readSchemas().entrySet().stream())
+var foundSchemas = toSchemaPaths(blendingSchemas())
+.map(schema -> {
+var resolved = new ProductSpecReader(config,
+schema.getLeft(), schema.getRight(),
+new DeserializerProvider(), ProductSpecReader.defaultOptions())
+.readSchemas();
+return Pair.of(schema, resolved);
+})
+.collect(Collectors.toList());
+
+validateResolvedSchemas(foundSchemas);
+
+var allSchemas = foundSchemas.stream().flatMap(it -> it.getRight().entrySet().stream());
+
+return allSchemas
 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> {
 if (a.equals(b)) return a;
 throw new IllegalArgumentException(String.format("Object for the same key does not match %s %s", a, b));
 }));
 }
 
+Function<Pair<Path, String>, String> toPointer = it -> {
+var path = it.getLeft().toAbsolutePath().toString();
+var schema = it.getRight();
+return StringUtils.isBlank(schema) ? path : path + "#" + schema;
+};
+
+private void validateResolvedSchemas(List<Pair<Pair<Path, String>, Map<String, Schema<?>>>> foundSchemas) {
+var byKeys = foundSchemas.stream()
+.flatMap(it -> {
+var key = it.getLeft();
+return it.getRight().entrySet().stream()
+.map(e -> Triple.of(e.getKey(), e.getValue(), key));
+}).collect(Collectors.groupingBy(Triple::getLeft));
+
+List<String> messages = byKeys.entrySet().stream()
+.filter(it -> it.getValue().size() > 1)
+.map(it -> {
+var groups = it.getValue().stream().collect(Collectors.groupingBy(
+Triple::getMiddle,
+Collectors.mapping(t -> toPointer.apply((Pair<Path, String>) t.getRight()), Collectors.toList())
+));
+
+var strings = groups.values().stream().map(list -> String.join("\n", list)).collect(Collectors.toList());
+return Pair.of(it.getKey(), strings);
+})
+.peek(this::logReferencingFiles)
+.filter(it -> ((List<String>)it.getValue()).size() > 1)
+.map(it -> {
+var groupsCount = it.getValue().size();
+StringBuilder sb = new StringBuilder();
+var idx = 1;
+
+for(var group : it.getValue()) {
+sb.append(String.format("Group %d:\n%s\n", idx++, group));
+}
+
+return String.format("Schema %s defined %d times and referenced from files groups:\n%s",
+it.getKey(), groupsCount,
+sb);
+})
+.collect(Collectors.toList());
+if(messages.isEmpty()) return;
+
+throw new IllegalArgumentException(String.format("Found conflicting schema definitions\n %s", String.join("\n", messages)));
+}
+
+private void logReferencingFiles(Pair<String, List<String>> it) {
+var files = String.join("\n", ((List<String>) it.getValue()));
+log.debug("Schema {} found in files:\n{}", it.getKey(), files);
+}
+
 protected Stream<Pair<Path, String>> toSchemaPaths(Stream<String> path) {
 return new PathResolver(specificationsRootDir).toSchemaPaths(path);
 }
@@ -112,7 +179,7 @@ protected Stream<String> blendingSchemas() {
 
 protected void validateProductSpecs() {
 var incorrectFilesExists = toSchemaPaths(blendingSchemas())
-.map(Pair::first)
+.map(Pair::getLeft)
 .filter(p -> !Files.isRegularFile(p))
 .peek(p -> log.warn("{} is not a file", p))
 .count() > 0;

src/main/java/com/amartus/sonata/blender/cmd/Merge.java

@@ -171,7 +171,7 @@ protected Map<String, Schema> toProductSpecifications() {
 var config = new ProductSpecReader.Options(modelToAugment, autodiscover);
 
 return paths
-.flatMap(schema -> new ProductSpecReader(config, schema.first(), schema.second(), new DeserializerProvider(), ProductSpecReader.defaultOptions()).readSchemas().entrySet().stream())
+.flatMap(schema -> new ProductSpecReader(config, schema.getLeft(), schema.getRight(), new DeserializerProvider(), ProductSpecReader.defaultOptions()).readSchemas().entrySet().stream())
 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> {
 if (a.equals(b)) return a;
 throw new IllegalArgumentException(String.format("Object for the same key does not match %s %s", a, b));

src/main/java/com/amartus/sonata/blender/impl/MergeSchemasAction.java

@@ -118,11 +118,21 @@ public void execute() {
 
 private Set<String> findTargets() {
 Set<String> targets = schemasToInject.values().stream()
-.map(s -> Optional.ofNullable(s.getExtensions())
-.map(em -> (String) em.get(ProductSpecReader.TARGET_NAME)).orElse(null))
-.filter(Objects::nonNull)
+.flatMap(s -> OasUtils.extensionByName(ProductSpecReader.TARGET_NAME, s).stream())
 .collect(Collectors.toSet());
-targets.add(modelToAugment);
+var noRootSchemaWithDefinedTarget = schemasToInject.values().stream()
+.filter(s -> OasUtils.extensionByName(ProductSpecReader.DISCRIMINATOR_VALUE, s).isPresent())
+.anyMatch(s -> OasUtils.extensionByName(ProductSpecReader.TARGET_NAME, s).isEmpty());
+
+if(noRootSchemaWithDefinedTarget) {
+targets = new HashSet<>(targets);
+targets.add(modelToAugment);
+}
+
+if(targets.isEmpty() && ! schemasToInject.isEmpty()) {
+throw new IllegalStateException("No targets identified for schemas to inject");
+}
+
 return targets;
 }
 

src/main/java/com/amartus/sonata/blender/impl/postprocess/RemoveDefaultParameterValues.java

@@ -83,6 +83,6 @@ private void process(Parameter parameter) {
 }
 
 private boolean defaultExplode(Parameter.StyleEnum defStyle, Boolean explode) {
-return (defStyle == Parameter.StyleEnum.FORM) == explode;
+return Boolean.valueOf(defStyle == Parameter.StyleEnum.FORM) == explode;
 }
 }

src/main/java/com/amartus/sonata/blender/impl/postprocess/RenameTypesPostprocessor.java

@@ -2,7 +2,6 @@
 
 import com.amartus.sonata.blender.impl.util.OasUtils;
 import com.amartus.sonata.blender.impl.util.OasWrapper;
-import com.amartus.sonata.blender.impl.util.Pair;
 import io.swagger.v3.oas.models.OpenAPI;
 import io.swagger.v3.oas.models.Operation;
 import io.swagger.v3.oas.models.media.ArraySchema;
@@ -12,6 +11,7 @@
 import io.swagger.v3.oas.models.parameters.RequestBody;
 import io.swagger.v3.oas.models.responses.ApiResponse;
 import io.swagger.v3.oas.models.responses.ApiResponses;
+import org.apache.commons.lang3.tuple.Pair;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -64,7 +64,7 @@ public void accept(OpenAPI openAPI) {
 private void renameSchemas(OpenAPI oas) {
 var schemas = new OasWrapper(oas).schemas().entrySet().stream()
 .map(e -> Pair.of(substitutions.getOrDefault(e.getKey(), e.getKey()), e.getValue()))
-.collect(Collectors.toMap(Pair::first, Pair::second));
+.collect(Collectors.toMap(Pair::getLeft, Pair::getRight));
 oas.getComponents().setSchemas(schemas);
 }
 

src/main/java/com/amartus/sonata/blender/impl/postprocess/SecureEndpointsWithOAuth2.java

@@ -18,10 +18,10 @@
 
 package com.amartus.sonata.blender.impl.postprocess;
 
-import com.amartus.sonata.blender.impl.util.Pair;
 import io.swagger.v3.oas.models.OpenAPI;
 import io.swagger.v3.oas.models.Operation;
 import io.swagger.v3.oas.models.security.*;
+import org.apache.commons.lang3.tuple.Pair;
 
 import java.nio.charset.StandardCharsets;
 import java.util.Base64;
@@ -92,10 +92,10 @@ private PerOperationSecurityModifier(OpenAPI oas) {
 @Override
 protected void addRequirements(List<Pair<Operation, String>> operations) {
 operations.forEach(e -> {
-var operation = e.first();
+var operation = e.getLeft();
 operation.addSecurityItem(
 new SecurityRequirement()
-.addList(schemeName, e.second())
+.addList(schemeName, e.getRight())
 );
 });
 }
@@ -105,7 +105,7 @@ protected Scopes toScopes(List<Pair<Operation, String>> operations) {
 var scopes = new Scopes();
 
 operations.stream()
-.map(Pair::second)
+.map(Pair::getRight)
 .forEach(name -> scopes.addString(name, String.format("Scope for operation %s", name)));
 return scopes;
 }

src/main/java/com/amartus/sonata/blender/impl/util/FileWalker.java

@@ -1,5 +1,7 @@
 package com.amartus.sonata.blender.impl.util;
 
+import org.apache.commons.lang3.tuple.Pair;
+
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;

src/main/java/com/amartus/sonata/blender/impl/util/IdSchemaResolver.java

@@ -21,6 +21,7 @@
 import com.amartus.sonata.blender.impl.specifications.UrnBasedNamingStrategy;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.commons.lang3.tuple.Pair;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -52,8 +53,8 @@ public List<Path> findProductSpecifications(Path rootPath) {
 
 try (Stream<Pair<Path, Boolean>> allFiles = walker.walk(rootPath)) {
 return allFiles
-.filter(Pair::second)
-.map(Pair::first)
+.filter(Pair::getRight)
+.map(Pair::getLeft)
 .map(Path::toAbsolutePath)
 .collect(Collectors.toList());
 } catch (IOException e) {

src/main/java/com/amartus/sonata/blender/impl/util/OasUtils.java

@@ -103,6 +103,11 @@ static long countReferences(Schema<?> schema) {
 return 0;
 }
 
+
+static Optional<String> extensionByName(String name, Schema schema) {
+return Optional.ofNullable(schema.getExtensions())
+.flatMap(ex -> Optional.ofNullable((String) ex.get(name)));
+}
 static Stream<Schema> allSchemas(ComposedSchema cs) {
 return Stream.of(
 cs.getAllOf(),

src/main/java/com/amartus/sonata/blender/impl/util/Pair.java

@@ -18,6 +18,8 @@
 
 package com.amartus.sonata.blender.impl.util;
 
+import org.apache.commons.lang3.tuple.Pair;
+
 import java.nio.file.Path;
 import java.util.Collection;
 import java.util.stream.Stream;
@@ -37,7 +39,7 @@ public Stream<Pair<Path, String>> toSchemaPaths(Stream<String> paths) {
 final var rootPath = Path.of(root).toAbsolutePath();
 return paths
 .map(this::pathWithFragment)
-.map(p -> Pair.of(toPath(p.first(), rootPath), p.second()));
+.map(p -> Pair.of(toPath(p.getLeft(), rootPath), p.getRight()));
 }
 
 private Path toPath(String path, Path root) {

src/main/java/com/amartus/sonata/blender/impl/util/PathResolver.java

@@ -24,8 +24,10 @@
 import com.fasterxml.jackson.databind.MapperFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.module.SimpleModule;
+import io.swagger.v3.core.jackson.mixin.SchemaMixin;
 import io.swagger.v3.core.util.Json31;
 import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.media.Schema;
 import org.openapitools.codegen.serializer.OpenAPISerializer;
 
 public abstract class SerializationUtils {
@@ -43,6 +45,7 @@ private static ObjectMapper enhance(ObjectMapper mapper) {
 module.addSerializer(OpenAPI.class, new OpenAPISerializer());
 mapper.registerModule(module)
 .addMixIn(Object.class, IgnorePropertyMixin.class)
+.addMixIn(Schema.class, SchemaMixin.class)
 .setSerializationInclusion(JsonInclude.Include.NON_EMPTY)
 .configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, true);
 return mapper;

src/main/java/com/amartus/sonata/blender/impl/util/SerializationUtils.java

@@ -102,8 +102,10 @@ private MergeSchemasAction action(String modelToAugment, OpenAPI oas, MergeSchem
 }
 
 private Map<String, Schema> schemas() {
+var schema = new ObjectSchema();
+schema.addExtension(ProductSpecReader.DISCRIMINATOR_VALUE, "some-discriminator");
 return Map.of(
-"foo", new ObjectSchema()
+"foo", schema
 );
 }
 }