Skip to content

Commit a7efd23

Browse files
fjtiradofjtirado
committed
[Fix #634] Setting up maven plugin
Signed-off-by: fjtirado <ftirados@redhat.com>
1 parent f6caef4 commit a7efd23

21 files changed

Lines changed: 754 additions & 185 deletions

File tree

‎api/pom.xml‎

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,11 @@
1818
<artifactId>serverlessworkflow-types</artifactId>
1919
<version>${project.version}</version>
2020
</dependency>
21+
<dependency>
22+
<groupId>io.serverlessworkflow</groupId>
23+
<artifactId>serverlessworkflow-serialization</artifactId>
24+
<version>${project.version}</version>
25+
</dependency>
2126
<dependency>
2227
<groupId>org.slf4j</groupId>
2328
<artifactId>slf4j-api</artifactId>
@@ -73,4 +78,46 @@
7378
<scope>test</scope>
7479
</dependency>
7580
</dependencies>
81+
<build>
82+
<plugins>
83+
84+
<plugin>
85+
<groupId>io.serverlessworkflow</groupId>
86+
<artifactId>jackson-generator</artifactId>
87+
<version>${project.version}</version>
88+
<dependencies/>
89+
<configuration>
90+
<targetPackage>io.serverlessworkflow.api.types</targetPackage>
91+
</configuration>
92+
<executions>
93+
<execution>
94+
<goals>
95+
<goal>generate</goal>
96+
</goals>
97+
<phase>generate-sources</phase>
98+
</execution>
99+
</executions>
100+
</plugin>
101+
<plugin>
102+
<!-- a hint for IDE's to add the java sources to the classpath -->
103+
<groupId>org.codehaus.mojo</groupId>
104+
<artifactId>build-helper-maven-plugin</artifactId>
105+
<version>3.3.0</version>
106+
<executions>
107+
<execution>
108+
<id>add-mixin</id>
109+
<phase>generate-sources</phase>
110+
<goals>
111+
<goal>add-source</goal>
112+
</goals>
113+
<configuration>
114+
<sources>
115+
<source>${project.build.directory}/generated-sources/jacksonmixinpojo</source>
116+
</sources>
117+
</configuration>
118+
</execution>
119+
</executions>
120+
</plugin>
121+
</plugins>
122+
</build>
76123
</project>

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

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,11 +15,13 @@
1515
*/
1616
package io.serverlessworkflow.api;
1717

18+
import com.fasterxml.jackson.annotation.JsonInclude.Include;
1819
import com.fasterxml.jackson.databind.ObjectMapper;
1920
import com.fasterxml.jackson.databind.SerializationFeature;
2021
import com.fasterxml.jackson.databind.module.SimpleModule;
2122
import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
2223
import com.fasterxml.jackson.dataformat.yaml.YAMLGenerator.Feature;
24+
import io.serverlessworkflow.api.types.JacksonMixInModule;
2325
import io.serverlessworkflow.serialization.BeanDeserializerModifierWithValidation;
2426
import io.serverlessworkflow.serialization.URIDeserializer;
2527
import io.serverlessworkflow.serialization.URISerializer;
@@ -47,10 +49,12 @@ private static ObjectMapper configure(ObjectMapper mapper) {
4749
validationModule.setDeserializerModifier(new BeanDeserializerModifierWithValidation());
4850

4951
return mapper
52+
.setSerializationInclusion(Include.NON_NULL)
5053
.configure(SerializationFeature.INDENT_OUTPUT, true)
5154
.configure(SerializationFeature.WRITE_EMPTY_JSON_ARRAYS, false)
5255
.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false)
53-
.registerModule(validationModule);
56+
.registerModule(validationModule)
57+
.registerModule(new JacksonMixInModule());
5458
}
5559

5660
private ObjectMapperFactory() {}

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

Lines changed: 2 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -16,8 +16,6 @@
1616
package io.serverlessworkflow.generator;
1717

1818
import com.fasterxml.jackson.databind.JsonNode;
19-
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
20-
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
2119
import com.fasterxml.jackson.databind.node.ArrayNode;
2220
import com.sun.codemodel.JBlock;
2321
import com.sun.codemodel.JClass;
@@ -35,8 +33,7 @@
3533
import com.sun.codemodel.JVar;
3634
import io.serverlessworkflow.annotations.OneOfSetter;
3735
import io.serverlessworkflow.annotations.OneOfValueProvider;
38-
import io.serverlessworkflow.serialization.DeserializeHelper;
39-
import io.serverlessworkflow.serialization.SerializeHelper;
36+
import io.serverlessworkflow.annotations.Union;
4037
import jakarta.validation.ConstraintViolationException;
4138
import java.io.UnsupportedEncodingException;
4239
import java.net.URI;
@@ -324,21 +321,7 @@ private JDefinedClass populateOneOf(
324321
definedClass._implements(
325322
definedClass.owner().ref(OneOfValueProvider.class).narrow(valueField.type()));
326323
GeneratorUtils.implementInterface(definedClass, valueField);
327-
try {
328-
JDefinedClass serializer = generateSerializer(definedClass);
329-
definedClass.annotate(JsonSerialize.class).param("using", serializer);
330-
} catch (JClassAlreadyExistsException ex) {
331-
// already serialized aware
332-
}
333-
334-
try {
335-
JDefinedClass deserializer =
336-
generateDeserializer(definedClass, oneOfTypes, "deserializeOneOf");
337-
definedClass.annotate(JsonDeserialize.class).param("using", deserializer);
338-
} catch (JClassAlreadyExistsException ex) {
339-
// already deserialized aware
340-
}
341-
324+
definedClass.annotate(Union.class);
342325
return wrapAll(parentSchema, definedClass, commonType, oneOfTypes, Optional.of(valueField));
343326
}
344327

@@ -389,49 +372,6 @@ private static boolean isStringType(JType type) {
389372
return type.name().equals("String");
390373
}
391374

392-
private JDefinedClass generateSerializer(JDefinedClass relatedClass)
393-
throws JClassAlreadyExistsException {
394-
JDefinedClass definedClass = GeneratorUtils.serializerClass(relatedClass);
395-
GeneratorUtils.fillSerializer(
396-
definedClass,
397-
relatedClass,
398-
(method, valueParam, genParam) ->
399-
method
400-
.body()
401-
.staticInvoke(definedClass.owner().ref(SerializeHelper.class), "serializeOneOf")
402-
.arg(genParam)
403-
.arg(valueParam));
404-
return definedClass;
405-
}
406-
407-
private JDefinedClass generateDeserializer(
408-
JDefinedClass relatedClass, Collection<JTypeWrapper> oneOfTypes, String methodName)
409-
throws JClassAlreadyExistsException {
410-
JDefinedClass definedClass = GeneratorUtils.deserializerClass(relatedClass);
411-
GeneratorUtils.fillDeserializer(
412-
definedClass,
413-
relatedClass,
414-
(method, parserParam) -> {
415-
JBlock body = method.body();
416-
417-
body._return(
418-
definedClass
419-
.owner()
420-
.ref(DeserializeHelper.class)
421-
.staticInvoke(methodName)
422-
.arg(parserParam)
423-
.arg(relatedClass.dotclass())
424-
.arg(list(definedClass, oneOfTypes)));
425-
});
426-
return definedClass;
427-
}
428-
429-
private JInvocation list(JDefinedClass definedClass, Collection<JTypeWrapper> list) {
430-
JInvocation result = definedClass.owner().ref(List.class).staticInvoke("of");
431-
list.forEach(c -> result.arg(((JClass) c.getType()).dotclass()));
432-
return result;
433-
}
434-
435375
private void wrapIt(
436376
Schema parentSchema,
437377
JDefinedClass definedClass,

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

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,18 +18,24 @@
1818
import com.fasterxml.jackson.databind.JsonNode;
1919
import com.sun.codemodel.JDefinedClass;
2020
import com.sun.codemodel.JFieldVar;
21+
import io.serverlessworkflow.annotations.AdditionalProperties;
2122
import jakarta.validation.constraints.Pattern;
2223
import org.jsonschema2pojo.AbstractAnnotator;
2324
import org.jsonschema2pojo.GenerationConfig;
2425

25-
public class ConstAnnotator extends AbstractAnnotator {
26+
public class CustomAnnotator extends AbstractAnnotator {
2627

2728
private static final String CONST = "const";
2829

29-
public ConstAnnotator(GenerationConfig generationConfig) {
30+
public CustomAnnotator(GenerationConfig generationConfig) {
3031
super(generationConfig);
3132
}
3233

34+
@Override
35+
public void additionalPropertiesField(JFieldVar field, JDefinedClass clazz, String propertyName) {
36+
clazz.annotate(AdditionalProperties.class);
37+
}
38+
3339
@Override
3440
public void propertyField(
3541
JFieldVar field, JDefinedClass clazz, String propertyName, JsonNode propertyNode) {

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

Lines changed: 2 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -15,43 +15,15 @@
1515
*/
1616
package io.serverlessworkflow.generator;
1717

18-
import com.fasterxml.jackson.core.JsonGenerator;
19-
import com.fasterxml.jackson.core.JsonParser;
20-
import com.fasterxml.jackson.databind.DeserializationContext;
21-
import com.fasterxml.jackson.databind.JsonDeserializer;
22-
import com.fasterxml.jackson.databind.JsonSerializer;
23-
import com.fasterxml.jackson.databind.SerializerProvider;
24-
import com.sun.codemodel.JClassAlreadyExistsException;
2518
import com.sun.codemodel.JDefinedClass;
2619
import com.sun.codemodel.JFieldVar;
2720
import com.sun.codemodel.JMethod;
2821
import com.sun.codemodel.JMod;
29-
import com.sun.codemodel.JVar;
30-
import java.io.IOException;
22+
import io.serverlessworkflow.annotations.GetterMethod;
3123
import org.jsonschema2pojo.util.NameHelper;
3224

3325
public class GeneratorUtils {
3426

35-
@FunctionalInterface
36-
public interface SerializerFiller {
37-
void accept(JMethod method, JVar valueParam, JVar genParam);
38-
}
39-
40-
@FunctionalInterface
41-
public interface DeserializerFiller {
42-
void accept(JMethod method, JVar parserParam);
43-
}
44-
45-
public static JDefinedClass serializerClass(JDefinedClass relatedClass)
46-
throws JClassAlreadyExistsException {
47-
return createClass(relatedClass, JsonSerializer.class, "Serializer");
48-
}
49-
50-
public static JDefinedClass deserializerClass(JDefinedClass relatedClass)
51-
throws JClassAlreadyExistsException {
52-
return createClass(relatedClass, JsonDeserializer.class, "Deserializer");
53-
}
54-
5527
public static JMethod implementInterface(JDefinedClass definedClass, JFieldVar valueField) {
5628
JMethod method = definedClass.method(JMod.PUBLIC, valueField.type(), "get");
5729
method.annotate(Override.class);
@@ -67,38 +39,9 @@ public static JMethod getterMethod(
6739
instanceField.type(),
6840
nameHelper.getGetterName(name, instanceField.type(), null));
6941
method.body()._return(instanceField);
42+
method.annotate(GetterMethod.class);
7043
return method;
7144
}
7245

73-
public static void fillSerializer(
74-
JDefinedClass definedClass, JDefinedClass relatedClass, SerializerFiller filler) {
75-
JMethod method = definedClass.method(JMod.PUBLIC, void.class, "serialize");
76-
method.annotate(Override.class);
77-
method._throws(IOException.class);
78-
JVar valueParam = method.param(relatedClass, "value");
79-
JVar genParam = method.param(JsonGenerator.class, "gen");
80-
method.param(SerializerProvider.class, "serializers");
81-
filler.accept(method, valueParam, genParam);
82-
}
83-
84-
public static void fillDeserializer(
85-
JDefinedClass definedClass, JDefinedClass relatedClass, DeserializerFiller filler) {
86-
JMethod method = definedClass.method(JMod.PUBLIC, relatedClass, "deserialize");
87-
method.annotate(Override.class);
88-
method._throws(IOException.class);
89-
JVar parserParam = method.param(JsonParser.class, "parser");
90-
method.param(DeserializationContext.class, "dctx");
91-
filler.accept(method, parserParam);
92-
}
93-
94-
private static JDefinedClass createClass(
95-
JDefinedClass relatedClass, Class<?> serializerClass, String suffix)
96-
throws JClassAlreadyExistsException {
97-
JDefinedClass definedClass =
98-
relatedClass._package()._class(JMod.NONE, relatedClass.name() + suffix);
99-
definedClass._extends(definedClass.owner().ref(serializerClass).narrow(relatedClass));
100-
return definedClass;
101-
}
102-
10346
private GeneratorUtils() {}
10447
}

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

Lines changed: 7 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -16,18 +16,16 @@
1616
package io.serverlessworkflow.generator;
1717

1818
import com.fasterxml.jackson.databind.JsonNode;
19-
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
20-
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
21-
import com.sun.codemodel.JBlock;
22-
import com.sun.codemodel.JClass;
2319
import com.sun.codemodel.JClassAlreadyExistsException;
2420
import com.sun.codemodel.JDefinedClass;
2521
import com.sun.codemodel.JExpr;
2622
import com.sun.codemodel.JFieldVar;
2723
import com.sun.codemodel.JMethod;
2824
import com.sun.codemodel.JMod;
2925
import com.sun.codemodel.JType;
30-
import io.serverlessworkflow.serialization.DeserializeHelper;
26+
import io.serverlessworkflow.annotations.Item;
27+
import io.serverlessworkflow.annotations.ItemKey;
28+
import io.serverlessworkflow.annotations.ItemValue;
3129
import org.jsonschema2pojo.Schema;
3230
import org.jsonschema2pojo.rules.AdditionalPropertiesRule;
3331
import org.jsonschema2pojo.rules.Rule;
@@ -100,12 +98,10 @@ private JDefinedClass addKeyValueFields(
10098
JMod.PRIVATE, propertyType, nameHelper.getPropertyName(propertyType.name(), null));
10199
JMethod valueMethod =
102100
GeneratorUtils.getterMethod(jclass, valueField, nameHelper, propertyType.name());
103-
jclass
104-
.annotate(JsonSerialize.class)
105-
.param("using", generateSerializer(jclass, nameMethod, valueMethod));
106-
jclass
107-
.annotate(JsonDeserialize.class)
108-
.param("using", generateDeserializer(jclass, propertyType));
101+
102+
jclass.annotate(Item.class);
103+
nameMethod.annotate(ItemKey.class);
104+
valueMethod.annotate(ItemValue.class);
109105
JMethod constructor = jclass.constructor(JMod.PUBLIC);
110106
constructor
111107
.body()
@@ -114,44 +110,6 @@ private JDefinedClass addKeyValueFields(
114110
return jclass;
115111
}
116112

117-
private JDefinedClass generateDeserializer(JDefinedClass relatedClass, JType propertyType)
118-
throws JClassAlreadyExistsException {
119-
JDefinedClass definedClass = GeneratorUtils.deserializerClass(relatedClass);
120-
GeneratorUtils.fillDeserializer(
121-
definedClass,
122-
relatedClass,
123-
(method, parserParam) ->
124-
method
125-
.body()
126-
._return(
127-
definedClass
128-
.owner()
129-
.ref(DeserializeHelper.class)
130-
.staticInvoke("deserializeItem")
131-
.arg(parserParam)
132-
.arg(relatedClass.dotclass())
133-
.arg(((JClass) propertyType).dotclass())));
134-
return definedClass;
135-
}
136-
137-
private JDefinedClass generateSerializer(
138-
JDefinedClass relatedClass, JMethod nameMethod, JMethod valueMethod)
139-
throws JClassAlreadyExistsException {
140-
JDefinedClass definedClass = GeneratorUtils.serializerClass(relatedClass);
141-
GeneratorUtils.fillSerializer(
142-
definedClass,
143-
relatedClass,
144-
(method, valueParam, genParam) -> {
145-
JBlock body = method.body();
146-
body.invoke(genParam, "writeStartObject");
147-
body.invoke(genParam, "writeObjectField")
148-
.arg(valueParam.invoke(nameMethod))
149-
.arg(valueParam.invoke(valueMethod));
150-
body.invoke(genParam, "writeEndObject");
151-
});
152-
return definedClass;
153-
}
154-
155113
private boolean checkIntValue(JsonNode node, String propName, int value) {
156114
return node.has(propName) && node.get(propName).asInt() == value;
157115
}

0 commit comments

Comments
 (0)