feat: add support for object type properties (multiple classes generation)

NachoBrito · NachoBrito · commit d4fd324601ff · 2024-12-31T18:21:48.000+01:00
diff --git a/src/main/java/es/nachobrito/jsonschema/compiler/application/cli/App.java b/src/main/java/es/nachobrito/jsonschema/compiler/application/cli/App.java
@@ -18,12 +18,13 @@
 
 import es.nachobrito.jsonschema.compiler.domain.Compiler;
 import es.nachobrito.jsonschema.compiler.infrastructure.jsonrefparser.JsonSchemaReader;
+import es.nachobrito.jsonschema.compiler.infrastructure.jsonrefparser.JsonSchemaReaderFactory;
 
 public class App {
   public static void main(String[] args) {
     var params = RuntimeConfiguration.of(args);
 
-    var compiler = new Compiler(params, new JsonSchemaReader());
+    var compiler = new Compiler(params, new JsonSchemaReaderFactory());
     var jsonSchemaFile = params.getJsonSchemaFile();
     var jsonSchemaCode = params.getJsonSchemaCode();
     if (jsonSchemaFile.isPresent()) {
diff --git a/src/main/java/es/nachobrito/jsonschema/compiler/domain/Compiler.java b/src/main/java/es/nachobrito/jsonschema/compiler/domain/Compiler.java
@@ -22,21 +22,22 @@
 
 import es.nachobrito.jsonschema.compiler.domain.generator.ModelGenerator;
 import es.nachobrito.jsonschema.compiler.domain.runtimeconfiguration.RuntimeConfiguration;
-import es.nachobrito.jsonschema.compiler.domain.schemareader.SchemaReader;
+import es.nachobrito.jsonschema.compiler.domain.schemareader.SchemaReaderFactory;
 import java.io.IOException;
 import java.lang.classfile.ClassBuilder;
 import java.lang.classfile.ClassFile;
 import java.net.URI;
 import java.nio.file.Path;
+import java.util.List;
 import java.util.SortedMap;
 
 public class Compiler {
   private final RuntimeConfiguration runtimeConfiguration;
-  private final SchemaReader schemaReader;
+  private final SchemaReaderFactory schemaReaderFactory;
 
-  public Compiler(RuntimeConfiguration runtimeConfiguration, SchemaReader schemaReader) {
+  public Compiler(RuntimeConfiguration runtimeConfiguration, SchemaReaderFactory schemaReaderFactory) {
     this.runtimeConfiguration = runtimeConfiguration;
-    this.schemaReader = schemaReader;
+    this.schemaReaderFactory = schemaReaderFactory;
   }
 
   /**
@@ -45,7 +46,7 @@ public Compiler(RuntimeConfiguration runtimeConfiguration, SchemaReader schemaRe
    * @param schemaURI the uri of the file to compile
    */
   public void compile(URI schemaURI) {
-    compile(schemaReader.read(schemaURI));
+    compileAll(schemaReaderFactory.makeSchemaReader().read(schemaURI));
   }
 
   /**
@@ -54,10 +55,15 @@ public void compile(URI schemaURI) {
    * @param jsonSchema the schema definition
    */
   public void compile(String jsonSchema) {
-    compile(schemaReader.read(jsonSchema));
+    compileAll(schemaReaderFactory.makeSchemaReader().read(jsonSchema));
   }
 
-  private void compile(Schema schema) {
+
+  private void compileAll(List<Schema> schemas) {
+    schemas.forEach(this::compileSchema);
+  }
+
+  private void compileSchema(Schema schema) {
     var className =
         runtimeConfiguration
             .getPackageName()
diff --git a/src/main/java/es/nachobrito/jsonschema/compiler/domain/JavaName.java b/src/main/java/es/nachobrito/jsonschema/compiler/domain/JavaName.java
@@ -0,0 +1,28 @@
+/*
+ *    Copyright 2024 Nacho Brito
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package es.nachobrito.jsonschema.compiler.domain;
+
+import java.util.regex.Pattern;
+
+public class JavaName {
+  private static final Pattern jsonIdPattern = Pattern.compile("[\\W_]([a-z])");
+
+  public static String fromJsonIdentifier(String identifier) {
+    var formatted = jsonIdPattern.matcher(identifier).replaceAll(m -> m.group(1).toUpperCase());
+    return formatted;
+  }
+}
diff --git a/src/main/java/es/nachobrito/jsonschema/compiler/domain/Property.java b/src/main/java/es/nachobrito/jsonschema/compiler/domain/Property.java
@@ -19,10 +19,10 @@
 import java.lang.constant.ClassDesc;
 import java.util.regex.Pattern;
 
-public record Property(String key, ClassDesc type) {
-  private static final Pattern jsonIdPattern = Pattern.compile("[_\\-]([a-z])");
+public record Property(String key, ClassDesc type, String formattedName) {
 
-  public String formattedName() {
-    return jsonIdPattern.matcher(key).replaceAll(m -> m.group(1).toUpperCase());
+  public Property(String key, ClassDesc type){
+    this(key, type, JavaName.fromJsonIdentifier(key));
   }
+
 }
diff --git a/src/main/java/es/nachobrito/jsonschema/compiler/domain/schemareader/AbstractSchemaReader.java b/src/main/java/es/nachobrito/jsonschema/compiler/domain/schemareader/AbstractSchemaReader.java
@@ -21,6 +21,7 @@
 import static java.util.stream.Collectors.toMap;
 
 import es.nachobrito.jsonschema.compiler.domain.CompilerException;
+import es.nachobrito.jsonschema.compiler.domain.JavaName;
 import es.nachobrito.jsonschema.compiler.domain.Property;
 import es.nachobrito.jsonschema.compiler.domain.Schema;
 import java.io.IOException;
@@ -34,56 +35,101 @@
 import java.util.*;
 
 public abstract class AbstractSchemaReader implements SchemaReader {
+  private Map<String, Object> models;
+  private Map<String, Schema> schemas = new HashMap<>();
+
   @Override
-  public Schema read(URI uri) {
-    var models = loadModels(uri);
-    return new Schema(getClassName(models), getProperties(models));
+  public List<Schema> read(URI uri) {
+    this.models = loadModels(uri);
+    return createSchemas();
   }
 
   @Override
-  public Schema read(String jsonSchema) {
-    var models = loadModels(jsonSchema);
-    return new Schema(getClassName(models), getProperties(models));
+  public List<Schema> read(String jsonSchema) {
+    this.models = loadModels(jsonSchema);
+    return createSchemas();
+  }
+
+  private List<Schema> createSchemas() {
+    schemas.clear();
+    registerSchema(new Schema(getRootClassName(), processProperties(getRootProperties())));
+    return schemas.values().stream().toList();
+  }
+
+  private void registerSchema(Schema schema) {
+    schemas.put(schema.className(), schema);
   }
 
-  public String getClassName(Map<String, Object> models) {
+  private String getRootClassName() {
     return String.valueOf(models.getOrDefault("title", "UnknownClassName"));
   }
 
-  public SortedMap<String, Property> getProperties(Map<String, Object> models) {
-    var definitions =
-        ((Map<String, Map<String, ?>>) models.getOrDefault("properties", Collections.emptyMap()));
+  private SortedMap<String, Property> processProperties(Map<String, Map<String, ?>> definitions) {
     return definitions.entrySet().stream()
         .collect(
             toMap(
                 Map.Entry::getKey,
-                entry ->
-                    createProperty(
-                        entry.getKey(),
-                        (String) entry.getValue().get("type"),
-                        (String) entry.getValue().get("format")),
+                entry -> createProperty(entry.getKey(), definitions),
                 (v1, v2) -> {
                   throw new CompilerException("Duplicate property found!");
                 },
                 TreeMap::new));
   }
 
-  protected Property createProperty(String key, String type, String format) {
-    return new Property(key, getJavaType(type, format));
+  private Property createProperty(String key, Map<String, Map<String, ?>> propertyDefinitions) {
+    return new Property(key, getJavaType(key, propertyDefinitions));
   }
 
-  protected ClassDesc getJavaType(String jsonSchemaType, String jsonSchemaFormat) {
+  private ClassDesc getJavaType(
+      String propertyKey, Map<String, Map<String, ?>> propertyDefinitions) {
+    var property = getModelPropertyDefinition(propertyKey, propertyDefinitions);
+    var jsonSchemaType = (String) property.get("type");
+    var jsonSchemaFormat = (String) property.get("format");
     return switch (jsonSchemaType) {
       case "string" -> getJavaStringType(jsonSchemaFormat);
       case "integer" -> CD_Integer;
       case "number" -> CD_Double;
       case "boolean" -> CD_Boolean;
       //      case "array" -> ?;
-      //      case "object" -> ?;
+      case "object" -> getJavaObjectType(propertyKey);
       default -> CD_Object;
     };
   }
 
+  private ClassDesc getJavaObjectType(String propertyKey) {
+    var definition = getModelPropertyDefinition(propertyKey, getRootProperties());
+    var properties = definition.get("properties");
+    var name = getPropertyName(propertyKey, definition);
+    var schema =
+        schemas.computeIfAbsent(
+            name,
+            it -> new Schema(it, processProperties((Map<String, Map<String, ?>>) properties)));
+    return ClassDesc.of(schema.className());
+  }
+
+  private String getPropertyName(String propertyKey, Map<String, ?> definition) {
+    if (definition.containsKey("title")) {
+      return (String) definition.get("title");
+    }
+
+    return JavaName.fromJsonIdentifier("%s_%s".formatted(getRootClassName(), propertyKey));
+  }
+
+  private Map<String, ?> getModelPropertyDefinition(
+      String propertyKey, Map<String, Map<String, ?>> properties) {
+    var definition = properties.get(propertyKey);
+    if (definition == null) {
+      throw new CompilerException("Cannot load property %s".formatted(propertyKey));
+    }
+    return definition;
+  }
+
+  private Map<String, Map<String, ?>> getRootProperties() {
+    //noinspection unchecked
+    return ((Map<String, Map<String, ?>>)
+        models.getOrDefault("properties", Collections.emptyMap()));
+  }
+
   private ClassDesc getJavaStringType(String jsonSchemaFormat) {
     if (jsonSchemaFormat == null) {
       return CD_String;
diff --git a/src/main/java/es/nachobrito/jsonschema/compiler/domain/schemareader/SchemaReader.java b/src/main/java/es/nachobrito/jsonschema/compiler/domain/schemareader/SchemaReader.java
@@ -18,10 +18,11 @@
 
 import es.nachobrito.jsonschema.compiler.domain.Schema;
 import java.net.URI;
+import java.util.List;
 
 public interface SchemaReader {
 
-  Schema read(URI uri);
+  List<Schema> read(URI uri);
 
-  Schema read(String jsonSchema);
+  List<Schema> read(String jsonSchema);
 }
diff --git a/src/main/java/es/nachobrito/jsonschema/compiler/domain/schemareader/SchemaReaderFactory.java b/src/main/java/es/nachobrito/jsonschema/compiler/domain/schemareader/SchemaReaderFactory.java
@@ -0,0 +1,21 @@
+/*
+ *    Copyright 2024 Nacho Brito
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package es.nachobrito.jsonschema.compiler.domain.schemareader;
+
+public interface SchemaReaderFactory {
+    SchemaReader makeSchemaReader();
+}
diff --git a/src/main/java/es/nachobrito/jsonschema/compiler/infrastructure/jsonrefparser/JsonSchemaReaderFactory.java b/src/main/java/es/nachobrito/jsonschema/compiler/infrastructure/jsonrefparser/JsonSchemaReaderFactory.java
@@ -0,0 +1,27 @@
+/*
+ *    Copyright 2024 Nacho Brito
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package es.nachobrito.jsonschema.compiler.infrastructure.jsonrefparser;
+
+import es.nachobrito.jsonschema.compiler.domain.schemareader.SchemaReader;
+import es.nachobrito.jsonschema.compiler.domain.schemareader.SchemaReaderFactory;
+
+public class JsonSchemaReaderFactory implements SchemaReaderFactory {
+    @Override
+    public SchemaReader makeSchemaReader() {
+        return new JsonSchemaReader();
+    }
+}
diff --git a/src/test/java/es/nachobrito/jsonschema/compiler/CompilerTest.java b/src/test/java/es/nachobrito/jsonschema/compiler/CompilerTest.java
@@ -17,6 +17,8 @@
 
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
 import es.nachobrito.jsonschema.compiler.domain.Compiler;
 import es.nachobrito.jsonschema.compiler.domain.runtimeconfiguration.RuntimeConfigurationRecord;
 import es.nachobrito.jsonschema.compiler.infrastructure.jsonrefparser.JsonSchemaReader;
@@ -29,6 +31,8 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Comparator;
+
+import es.nachobrito.jsonschema.compiler.infrastructure.jsonrefparser.JsonSchemaReaderFactory;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 
@@ -51,7 +55,8 @@ protected static Class<?> compileSampleSchemaFromFile(String filePath, String ex
     var uri = URI.create(filePath);
     Path destPath = Path.of(CompilerSmokeTest.TARGET_GENERATED_CLASSES);
     var destURL = destPath.toAbsolutePath().toFile().toURI().toURL();
-    var compiler = new Compiler(new RuntimeConfigurationRecord(destPath, ""), new JsonSchemaReader());
+    var compiler =
+        new Compiler(new RuntimeConfigurationRecord(destPath, ""), new JsonSchemaReaderFactory());
     compiler.compile(uri);
     assertTrue(destPath.toFile().exists());
 
@@ -62,7 +67,8 @@ protected static Class<?> compileSampleSchemaFromString(String jsonSchema, Strin
       throws IOException, ClassNotFoundException {
     Path destPath = Path.of(CompilerSmokeTest.TARGET_GENERATED_CLASSES);
     var destURL = destPath.toAbsolutePath().toFile().toURI().toURL();
-    var compiler = new Compiler(new RuntimeConfigurationRecord(destPath, ""), new JsonSchemaReader());
+    var compiler =
+        new Compiler(new RuntimeConfigurationRecord(destPath, ""), new JsonSchemaReaderFactory());
     compiler.compile(jsonSchema);
     assertTrue(destPath.toFile().exists());
 
@@ -82,4 +88,8 @@ void afterAll() throws IOException {
         .map(Path::toFile)
         .forEach(File::delete);
   }
+
+  protected ObjectMapper createObjectMapper() {
+    return new ObjectMapper().registerModule(new JavaTimeModule());
+  }
 }
diff --git a/src/test/java/es/nachobrito/jsonschema/compiler/DeserializationTest.java b/src/test/java/es/nachobrito/jsonschema/compiler/DeserializationTest.java
@@ -20,8 +20,7 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.time.LocalDate;
@@ -71,7 +70,7 @@ void expectJsonDocumentsDeserializable()
         }
 """
             .formatted(theUUID.toString());
-    var mapper = new ObjectMapper().registerModule(new JavaTimeModule());
+    var mapper = createObjectMapper();
 
     //First, verify deserialization works for the equivalent manually generated record:
     record User2(
@@ -90,4 +89,5 @@ record User2(
     assertEquals(LocalDate.parse("1970-04-01"), cls.getDeclaredMethod("dateOfBirth").invoke(user));
     assertEquals(theUUID, cls.getDeclaredMethod("uuid").invoke(user));
   }
+
 }
diff --git a/src/test/java/es/nachobrito/jsonschema/compiler/NestedTest.java b/src/test/java/es/nachobrito/jsonschema/compiler/NestedTest.java
diff --git a/src/test/resources/test-schemas/Nested.json b/src/test/resources/test-schemas/Nested.json

Original file line number	Diff line number	Diff line change
`@@ -19,10 +19,10 @@`
`19`	`19`	`import java.lang.constant.ClassDesc;`
`20`	`20`	`import java.util.regex.Pattern;`
`21`	`21`
`22`		`-public record Property(String key, ClassDesc type) {`
`23`		`- private static final Pattern jsonIdPattern = Pattern.compile("[_\\-]([a-z])");`
	`22`	`+public record Property(String key, ClassDesc type, String formattedName) {`
`24`	`23`
`25`		`- public String formattedName() {`
`26`		`- return jsonIdPattern.matcher(key).replaceAll(m -> m.group(1).toUpperCase());`
	`24`	`+ public Property(String key, ClassDesc type){`
	`25`	`+ this(key, type, JavaName.fromJsonIdentifier(key));`
`27`	`26`	`}`
	`27`	`+`
`28`	`28`	`}`