[Fix #634] Setting up maven plugin

Signed-off-by: fjtirado <[email protected]>

Author: fjtirado

api/pom.xml

@@ -18,6 +18,11 @@
             <artifactId>serverlessworkflow-types</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>io.serverlessworkflow</groupId>
+            <artifactId>serverlessworkflow-serialization</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
@@ -73,4 +78,46 @@
             <scope>test</scope>
         </dependency>
     </dependencies>
+    <build>
+    <plugins>
+    
+        <plugin>
+            <groupId>io.serverlessworkflow</groupId>
+            <artifactId>jackson-generator</artifactId>
+            <version>${project.version}</version>
+            <dependencies/>
+            <configuration>
+              <targetPackage>io.serverlessworkflow.api.types</targetPackage>
+            </configuration>
+            <executions>
+                <execution>
+                    <goals>
+                        <goal>generate</goal>
+                    </goals>
+                    <phase>generate-sources</phase>
+                </execution>
+            </executions>
+        </plugin>
+        <plugin>
+        <!-- a hint for IDE's to add the java sources to the classpath -->
+            <groupId>org.codehaus.mojo</groupId>
+            <artifactId>build-helper-maven-plugin</artifactId>
+            <version>3.3.0</version>
+            <executions>
+              <execution>
+                <id>add-mixin</id>
+                <phase>generate-sources</phase>
+                <goals>
+                  <goal>add-source</goal>
+                </goals>
+                <configuration>
+                  <sources>
+                    <source>${project.build.directory}/generated-sources/jacksonmixinpojo</source>
+                  </sources>
+                </configuration>
+              </execution>
+            </executions>
+        </plugin>
+    </plugins>
+  </build>
  </project>

api/src/main/java/io/serverlessworkflow/api/ObjectMapperFactory.java

@@ -15,11 +15,13 @@
  */
 package io.serverlessworkflow.api;
 
+import com.fasterxml.jackson.annotation.JsonInclude.Include;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.databind.module.SimpleModule;
 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
 import com.fasterxml.jackson.dataformat.yaml.YAMLGenerator.Feature;
+import io.serverlessworkflow.api.types.JacksonMixInModule;
 import io.serverlessworkflow.serialization.BeanDeserializerModifierWithValidation;
 import io.serverlessworkflow.serialization.URIDeserializer;
 import io.serverlessworkflow.serialization.URISerializer;
@@ -47,10 +49,12 @@ private static ObjectMapper configure(ObjectMapper mapper) {
     validationModule.setDeserializerModifier(new BeanDeserializerModifierWithValidation());
 
     return mapper
+        .setSerializationInclusion(Include.NON_NULL)
         .configure(SerializationFeature.INDENT_OUTPUT, true)
         .configure(SerializationFeature.WRITE_EMPTY_JSON_ARRAYS, false)
         .configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false)
-        .registerModule(validationModule);
+        .registerModule(validationModule)
+        .registerModule(new JacksonMixInModule());
   }
 
   private ObjectMapperFactory() {}

custom-generator/src/main/java/io/serverlessworkflow/generator/AllAnyOneOfSchemaRule.java

@@ -16,8 +16,6 @@
 package io.serverlessworkflow.generator;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
-import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.sun.codemodel.JBlock;
 import com.sun.codemodel.JClass;
@@ -35,8 +33,7 @@
 import com.sun.codemodel.JVar;
 import io.serverlessworkflow.annotations.OneOfSetter;
 import io.serverlessworkflow.annotations.OneOfValueProvider;
-import io.serverlessworkflow.serialization.DeserializeHelper;
-import io.serverlessworkflow.serialization.SerializeHelper;
+import io.serverlessworkflow.annotations.Union;
 import jakarta.validation.ConstraintViolationException;
 import java.io.UnsupportedEncodingException;
 import java.net.URI;
@@ -324,21 +321,7 @@ private JDefinedClass populateOneOf(
     definedClass._implements(
         definedClass.owner().ref(OneOfValueProvider.class).narrow(valueField.type()));
     GeneratorUtils.implementInterface(definedClass, valueField);
-    try {
-      JDefinedClass serializer = generateSerializer(definedClass);
-      definedClass.annotate(JsonSerialize.class).param("using", serializer);
-    } catch (JClassAlreadyExistsException ex) {
-      // already serialized aware
-    }
-
-    try {
-      JDefinedClass deserializer =
-          generateDeserializer(definedClass, oneOfTypes, "deserializeOneOf");
-      definedClass.annotate(JsonDeserialize.class).param("using", deserializer);
-    } catch (JClassAlreadyExistsException ex) {
-      // already deserialized aware
-    }
-
+    definedClass.annotate(Union.class);
     return wrapAll(parentSchema, definedClass, commonType, oneOfTypes, Optional.of(valueField));
   }
 
@@ -389,49 +372,6 @@ private static boolean isStringType(JType type) {
     return type.name().equals("String");
   }
 
-  private JDefinedClass generateSerializer(JDefinedClass relatedClass)
-      throws JClassAlreadyExistsException {
-    JDefinedClass definedClass = GeneratorUtils.serializerClass(relatedClass);
-    GeneratorUtils.fillSerializer(
-        definedClass,
-        relatedClass,
-        (method, valueParam, genParam) ->
-            method
-                .body()
-                .staticInvoke(definedClass.owner().ref(SerializeHelper.class), "serializeOneOf")
-                .arg(genParam)
-                .arg(valueParam));
-    return definedClass;
-  }
-
-  private JDefinedClass generateDeserializer(
-      JDefinedClass relatedClass, Collection<JTypeWrapper> oneOfTypes, String methodName)
-      throws JClassAlreadyExistsException {
-    JDefinedClass definedClass = GeneratorUtils.deserializerClass(relatedClass);
-    GeneratorUtils.fillDeserializer(
-        definedClass,
-        relatedClass,
-        (method, parserParam) -> {
-          JBlock body = method.body();
-
-          body._return(
-              definedClass
-                  .owner()
-                  .ref(DeserializeHelper.class)
-                  .staticInvoke(methodName)
-                  .arg(parserParam)
-                  .arg(relatedClass.dotclass())
-                  .arg(list(definedClass, oneOfTypes)));
-        });
-    return definedClass;
-  }
-
-  private JInvocation list(JDefinedClass definedClass, Collection<JTypeWrapper> list) {
-    JInvocation result = definedClass.owner().ref(List.class).staticInvoke("of");
-    list.forEach(c -> result.arg(((JClass) c.getType()).dotclass()));
-    return result;
-  }
-
   private void wrapIt(
       Schema parentSchema,
       JDefinedClass definedClass,

custom-generator/src/main/java/io/serverlessworkflow/generator/ConstAnnotator.java renamed to custom-generator/src/main/java/io/serverlessworkflow/generator/CustomAnnotator.java

@@ -18,18 +18,24 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.sun.codemodel.JDefinedClass;
 import com.sun.codemodel.JFieldVar;
+import io.serverlessworkflow.annotations.AdditionalProperties;
 import jakarta.validation.constraints.Pattern;
 import org.jsonschema2pojo.AbstractAnnotator;
 import org.jsonschema2pojo.GenerationConfig;
 
-public class ConstAnnotator extends AbstractAnnotator {
+public class CustomAnnotator extends AbstractAnnotator {
 
   private static final String CONST = "const";
 
-  public ConstAnnotator(GenerationConfig generationConfig) {
+  public CustomAnnotator(GenerationConfig generationConfig) {
     super(generationConfig);
   }
 
+  @Override
+  public void additionalPropertiesField(JFieldVar field, JDefinedClass clazz, String propertyName) {
+    clazz.annotate(AdditionalProperties.class);
+  }
+
   @Override
   public void propertyField(
       JFieldVar field, JDefinedClass clazz, String propertyName, JsonNode propertyNode) {

custom-generator/src/main/java/io/serverlessworkflow/generator/GeneratorUtils.java

@@ -15,43 +15,15 @@
  */
 package io.serverlessworkflow.generator;
 
-import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.databind.DeserializationContext;
-import com.fasterxml.jackson.databind.JsonDeserializer;
-import com.fasterxml.jackson.databind.JsonSerializer;
-import com.fasterxml.jackson.databind.SerializerProvider;
-import com.sun.codemodel.JClassAlreadyExistsException;
 import com.sun.codemodel.JDefinedClass;
 import com.sun.codemodel.JFieldVar;
 import com.sun.codemodel.JMethod;
 import com.sun.codemodel.JMod;
-import com.sun.codemodel.JVar;
-import java.io.IOException;
+import io.serverlessworkflow.annotations.GetterMethod;
 import org.jsonschema2pojo.util.NameHelper;
 
 public class GeneratorUtils {
 
-  @FunctionalInterface
-  public interface SerializerFiller {
-    void accept(JMethod method, JVar valueParam, JVar genParam);
-  }
-
-  @FunctionalInterface
-  public interface DeserializerFiller {
-    void accept(JMethod method, JVar parserParam);
-  }
-
-  public static JDefinedClass serializerClass(JDefinedClass relatedClass)
-      throws JClassAlreadyExistsException {
-    return createClass(relatedClass, JsonSerializer.class, "Serializer");
-  }
-
-  public static JDefinedClass deserializerClass(JDefinedClass relatedClass)
-      throws JClassAlreadyExistsException {
-    return createClass(relatedClass, JsonDeserializer.class, "Deserializer");
-  }
-
   public static JMethod implementInterface(JDefinedClass definedClass, JFieldVar valueField) {
     JMethod method = definedClass.method(JMod.PUBLIC, valueField.type(), "get");
     method.annotate(Override.class);
@@ -67,38 +39,9 @@ public static JMethod getterMethod(
             instanceField.type(),
             nameHelper.getGetterName(name, instanceField.type(), null));
     method.body()._return(instanceField);
+    method.annotate(GetterMethod.class);
     return method;
   }
 
-  public static void fillSerializer(
-      JDefinedClass definedClass, JDefinedClass relatedClass, SerializerFiller filler) {
-    JMethod method = definedClass.method(JMod.PUBLIC, void.class, "serialize");
-    method.annotate(Override.class);
-    method._throws(IOException.class);
-    JVar valueParam = method.param(relatedClass, "value");
-    JVar genParam = method.param(JsonGenerator.class, "gen");
-    method.param(SerializerProvider.class, "serializers");
-    filler.accept(method, valueParam, genParam);
-  }
-
-  public static void fillDeserializer(
-      JDefinedClass definedClass, JDefinedClass relatedClass, DeserializerFiller filler) {
-    JMethod method = definedClass.method(JMod.PUBLIC, relatedClass, "deserialize");
-    method.annotate(Override.class);
-    method._throws(IOException.class);
-    JVar parserParam = method.param(JsonParser.class, "parser");
-    method.param(DeserializationContext.class, "dctx");
-    filler.accept(method, parserParam);
-  }
-
-  private static JDefinedClass createClass(
-      JDefinedClass relatedClass, Class<?> serializerClass, String suffix)
-      throws JClassAlreadyExistsException {
-    JDefinedClass definedClass =
-        relatedClass._package()._class(JMod.NONE, relatedClass.name() + suffix);
-    definedClass._extends(definedClass.owner().ref(serializerClass).narrow(relatedClass));
-    return definedClass;
-  }
-
   private GeneratorUtils() {}
 }

custom-generator/src/main/java/io/serverlessworkflow/generator/UnevaluatedPropertiesRule.java

@@ -16,18 +16,16 @@
 package io.serverlessworkflow.generator;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
-import com.fasterxml.jackson.databind.annotation.JsonSerialize;
-import com.sun.codemodel.JBlock;
-import com.sun.codemodel.JClass;
 import com.sun.codemodel.JClassAlreadyExistsException;
 import com.sun.codemodel.JDefinedClass;
 import com.sun.codemodel.JExpr;
 import com.sun.codemodel.JFieldVar;
 import com.sun.codemodel.JMethod;
 import com.sun.codemodel.JMod;
 import com.sun.codemodel.JType;
-import io.serverlessworkflow.serialization.DeserializeHelper;
+import io.serverlessworkflow.annotations.Item;
+import io.serverlessworkflow.annotations.ItemKey;
+import io.serverlessworkflow.annotations.ItemValue;
 import org.jsonschema2pojo.Schema;
 import org.jsonschema2pojo.rules.AdditionalPropertiesRule;
 import org.jsonschema2pojo.rules.Rule;
@@ -100,12 +98,10 @@ private JDefinedClass addKeyValueFields(
             JMod.PRIVATE, propertyType, nameHelper.getPropertyName(propertyType.name(), null));
     JMethod valueMethod =
         GeneratorUtils.getterMethod(jclass, valueField, nameHelper, propertyType.name());
-    jclass
-        .annotate(JsonSerialize.class)
-        .param("using", generateSerializer(jclass, nameMethod, valueMethod));
-    jclass
-        .annotate(JsonDeserialize.class)
-        .param("using", generateDeserializer(jclass, propertyType));
+
+    jclass.annotate(Item.class);
+    nameMethod.annotate(ItemKey.class);
+    valueMethod.annotate(ItemValue.class);
     JMethod constructor = jclass.constructor(JMod.PUBLIC);
     constructor
         .body()
@@ -114,44 +110,6 @@ private JDefinedClass addKeyValueFields(
     return jclass;
   }
 
-  private JDefinedClass generateDeserializer(JDefinedClass relatedClass, JType propertyType)
-      throws JClassAlreadyExistsException {
-    JDefinedClass definedClass = GeneratorUtils.deserializerClass(relatedClass);
-    GeneratorUtils.fillDeserializer(
-        definedClass,
-        relatedClass,
-        (method, parserParam) ->
-            method
-                .body()
-                ._return(
-                    definedClass
-                        .owner()
-                        .ref(DeserializeHelper.class)
-                        .staticInvoke("deserializeItem")
-                        .arg(parserParam)
-                        .arg(relatedClass.dotclass())
-                        .arg(((JClass) propertyType).dotclass())));
-    return definedClass;
-  }
-
-  private JDefinedClass generateSerializer(
-      JDefinedClass relatedClass, JMethod nameMethod, JMethod valueMethod)
-      throws JClassAlreadyExistsException {
-    JDefinedClass definedClass = GeneratorUtils.serializerClass(relatedClass);
-    GeneratorUtils.fillSerializer(
-        definedClass,
-        relatedClass,
-        (method, valueParam, genParam) -> {
-          JBlock body = method.body();
-          body.invoke(genParam, "writeStartObject");
-          body.invoke(genParam, "writeObjectField")
-              .arg(valueParam.invoke(nameMethod))
-              .arg(valueParam.invoke(valueMethod));
-          body.invoke(genParam, "writeEndObject");
-        });
-    return definedClass;
-  }
-
   private boolean checkIntValue(JsonNode node, String propName, int value) {
     return node.has(propName) && node.get(propName).asInt() == value;
   }