.github/renovate.json

@@ -1,24 +1,32 @@
 {
   "extends": [
-    "config:base"
+    "config:recommended"
+  ],
+  "addLabels": [
+    "type: dependency-upgrade"
   ],
-  "addLabels": ["type: dependency-upgrade"],
   "schedule": [
-    "after 10pm every day"
+    "after 10pm"
   ],
   "prHourlyLimit": 1,
   "prConcurrentLimit": 20,
   "timezone": "Europe/Prague",
   "packageRules": [
     {
-      "matchPackagePatterns": ["actions.*"],
       "dependencyDashboardApproval": true,
-      "matchUpdateTypes": ["patch"],
+      "matchUpdateTypes": [
+        "patch"
+      ],
       "matchCurrentVersion": "!/^0/",
-      "automerge": true
+      "automerge": true,
+      "matchPackageNames": [
+        "/actions.*/"
+      ]
     },
     {
-      "matchUpdateTypes": ["patch"],
+      "matchUpdateTypes": [
+        "patch"
+      ],
       "matchCurrentVersion": "!/^0/",
       "automerge": true
     }

.github/workflows/gradle.yml

@@ -45,7 +45,7 @@ jobs:
           fetch-depth: 0
 
       - name: "🔧 Setup GraalVM CE"
-        uses: graalvm/setup-graalvm@v1.2.5
+        uses: graalvm/setup-graalvm@v1.2.6
         with:
           distribution: 'graalvm'
           java-version: ${{ matrix.java }}
@@ -70,7 +70,7 @@ jobs:
 
       - name: "📊 Publish Test Report"
         if: always()
-        uses: mikepenz/action-junit-report@v4
+        uses: mikepenz/action-junit-report@v5
         with:
           check_name: Java CI / Test Report (${{ matrix.java }})
           report_paths: '**/build/test-results/test/TEST-*.xml'

.github/workflows/release.yml

@@ -160,6 +160,6 @@ jobs:
       - name: Upload assets
         # Upload the artifacts to the existing release. Note that the SLSA provenance will
         # attest to each artifact file and not the aggregated ZIP file.
-        uses: softprops/action-gh-release@c062e08bd532815e2082a85e87e3ef29c3e6d191 # v2.0.8
+        uses: softprops/action-gh-release@01570a1f39cb168c169c802c3bceb9e93fb10974 # v2.1.0
         with:
           files: artifacts.zip

gradle.properties

@@ -1,4 +1,4 @@
-projectVersion=2.12.0
+projectVersion=2.13.0
 projectGroup=io.micronaut.serde
 
 jsonbApi=https://jakarta.ee/specifications/jsonb/2.0/apidocs/jakarta/json/bind/annotation

gradle/libs.versions.toml

@@ -1,5 +1,5 @@
 [versions]
-managed-bson = "4.11.4"
+managed-bson = "4.11.5"
 managed-jakarta-json-api = "2.1.3"
 managed-jakarta-json-bindApi = "3.0.1"
 managed-eclipse-parsson = "1.1.7"
@@ -10,21 +10,21 @@ graal-svm = "23.1.5"
 aws-lambda-events = "3.14.0"
 aws-lambda-serialization = "1.1.5"
 microstream-storage-restclient = "08.01.02-MS-GA"
-oracle-jdbc-driver = "23.5.0.24.07"
+oracle-jdbc-driver = "23.6.0.24.10"
 jetbrains-annotations = "24.1.0"
 jmh = "1.37"
 groovy = "4.0.22"
 
-micronaut = "4.7.1"
-micronaut-platform = "4.6.3"
+micronaut = "4.7.6"
+micronaut-platform = "4.7.1"
 micronaut-docs = "2.0.0"
-micronaut-test = "4.5.0"
-micronaut-discovery = "4.4.0"
+micronaut-test = "4.6.0"
+micronaut-discovery = "4.5.0"
 micronaut-logging = "1.5.0"
-micronaut-oracle-cloud = "4.2.1"
+micronaut-oracle-cloud = "4.3.1"
 micronaut-reactor = "3.6.0"
 micronaut-validation = "4.8.0"
-micronaut-gradle-plugin = "4.4.3"
+micronaut-gradle-plugin = "4.4.4"
 
 [libraries]
 # Micronaut

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

serde-jackson-tck/src/main/java/io/micronaut/serde/jackson/builder/introspected/Address.java

@@ -1,3 +1,18 @@
+/*
+ * Copyright 2017-2024 original authors
+ *
+ * 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
+ *
+ * https://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 io.micronaut.serde.jackson.builder.introspected;
 
 import io.micronaut.core.annotation.Introspected;

serde-jackson/src/test/groovy/io/micronaut/serde/jackson/JacksonJsonNodeSerdeSpec.groovy

@@ -0,0 +1,45 @@
+package io.micronaut.serde.jackson
+
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.node.JsonNodeFactory
+import com.fasterxml.jackson.databind.node.ObjectNode
+import io.micronaut.serde.ObjectMapper
+import io.micronaut.test.extensions.spock.annotation.MicronautTest
+import jakarta.inject.Inject
+import spock.lang.Specification
+
+@MicronautTest(startApplication = false)
+class JacksonJsonNodeSerdeSpec extends Specification {
+    @Inject
+    ObjectMapper objectMapper
+
+    def 'back and forth'(JsonNode node) {
+        when:
+        def json = objectMapper.writeValueAsString(node)
+        def back = objectMapper.readValue(json, JsonNode)
+        then:
+        back == node
+
+        where:
+        // commented nodes have ambiguous encoding with other nodes
+        node << [
+                JsonNodeFactory.instance.nullNode(),
+                JsonNodeFactory.instance.booleanNode(true),
+                JsonNodeFactory.instance.booleanNode(false),
+                JsonNodeFactory.instance.textNode("foo"),
+                JsonNodeFactory.instance.numberNode((byte) 1),
+                //JsonNodeFactory.instance.numberNode((short) 1),
+                JsonNodeFactory.instance.numberNode((int) 1),
+                JsonNodeFactory.instance.numberNode(Long.MAX_VALUE),
+                //JsonNodeFactory.instance.numberNode((float) 1),
+                JsonNodeFactory.instance.numberNode((double) 1),
+                JsonNodeFactory.instance.numberNode(BigInteger.valueOf(Long.MAX_VALUE) + 1),
+                //JsonNodeFactory.instance.numberNode(BigDecimal.valueOf(Double.MAX_VALUE) + 1.5),
+                //JsonNodeFactory.instance.binaryNode("foo".bytes),
+                JsonNodeFactory.instance.objectNode()
+                        .<ObjectNode> set("p1", JsonNodeFactory.instance.numberNode(1))
+                        .<ObjectNode> set("p2", JsonNodeFactory.instance.numberNode(2)),
+                JsonNodeFactory.instance.arrayNode().add(1).add(2),
+        ]
+    }
+}

serde-support/build.gradle.kts

@@ -16,6 +16,7 @@ dependencies {
 
     compileOnly(mn.micronaut.management)
     compileOnly(libs.jetbrains.annotations)
+    compileOnly(mn.jackson.databind)
 
     api(projects.micronautSerdeApi)
 

serde-support/src/main/java/io/micronaut/serde/support/serdes/JacksonJsonNodeSerde.java

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2017-2024 original authors
+ *
+ * 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
+ *
+ * https://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 io.micronaut.serde.support.serdes;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import io.micronaut.core.annotation.NonNull;
+import io.micronaut.core.annotation.Nullable;
+import io.micronaut.core.type.Argument;
+import io.micronaut.serde.Decoder;
+import io.micronaut.serde.Encoder;
+import io.micronaut.serde.support.SerdeRegistrar;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Map;
+
+/**
+ * Serde for jackson-databind {@link JsonNode}.
+ *
+ * @since 2.13.0
+ * @author Jonas Konrad
+ * @implNote Recursive implementation. Recursion depth is limited by decoder/encoder constraints ({@link io.micronaut.serde.LimitingStream}) for security.
+ */
+final class JacksonJsonNodeSerde implements SerdeRegistrar<JsonNode> {
+    private static final @NonNull Argument<JsonNode> JSON_NODE_ARGUMENT = Argument.of(JsonNode.class);
+
+    @Override
+    public @NonNull Argument<JsonNode> getType() {
+        return JSON_NODE_ARGUMENT;
+    }
+
+    @Override
+    public JsonNode deserializeNullable(@NonNull Decoder decoder, @NonNull DecoderContext context, @NonNull Argument<? super JsonNode> type) throws IOException {
+        return deserialize(decoder, context, type);
+    }
+
+    @Override
+    public @Nullable JsonNode deserialize(@NonNull Decoder decoder, @NonNull DecoderContext context, @NonNull Argument<? super JsonNode> type) throws IOException {
+        return toJacksonNode(JsonNodeFactory.instance, decoder.decodeNode());
+    }
+
+    private static JsonNode toJacksonNode(JsonNodeFactory factory, io.micronaut.json.tree.JsonNode mnNode) {
+        if (mnNode.isArray()) {
+            ArrayNode n = factory.arrayNode(mnNode.size());
+            for (io.micronaut.json.tree.JsonNode value : mnNode.values()) {
+                n.add(toJacksonNode(factory, value));
+            }
+            return n;
+        } else if (mnNode.isObject()) {
+            ObjectNode n = factory.objectNode();
+            for (Map.Entry<String, io.micronaut.json.tree.JsonNode> entry : mnNode.entries()) {
+                n.set(entry.getKey(), toJacksonNode(factory, entry.getValue()));
+            }
+            return n;
+        } else if (mnNode.isNull()) {
+            return factory.nullNode();
+        } else if (mnNode.isBoolean()) {
+            return factory.booleanNode(mnNode.getBooleanValue());
+        } else if (mnNode.isString()) {
+            return factory.textNode(mnNode.getStringValue());
+        } else {
+            Number numberValue = mnNode.getNumberValue();
+            if (numberValue instanceof Integer) {
+                return factory.numberNode(numberValue.intValue());
+            } else if (numberValue instanceof Long) {
+                return factory.numberNode(numberValue.longValue());
+            } else if (numberValue instanceof Short) {
+                return factory.numberNode(numberValue.shortValue());
+            } else if (numberValue instanceof Byte) {
+                return factory.numberNode(numberValue.byteValue());
+            } else if (numberValue instanceof Float) {
+                return factory.numberNode(numberValue.floatValue());
+            } else if (numberValue instanceof BigInteger bi) {
+                return factory.numberNode(bi);
+            } else if (numberValue instanceof BigDecimal bd) {
+                return factory.numberNode(bd);
+            } else {
+                // double, other number types
+                return factory.numberNode(numberValue.doubleValue());
+            }
+        }
+    }
+
+    @Override
+    public void serialize(@NonNull Encoder encoder, @NonNull EncoderContext context, @NonNull Argument<? extends JsonNode> type, @NonNull JsonNode node) throws IOException {
+        switch (node.getNodeType()) {
+            case BOOLEAN -> encoder.encodeBoolean(node.booleanValue());
+            case NULL -> encoder.encodeNull();
+            case NUMBER -> JsonNodeSerde.encodeNumber(encoder, node.numberValue());
+            case STRING -> encoder.encodeString(node.textValue());
+            case BINARY -> encoder.encodeBinary(node.binaryValue());
+            case ARRAY -> {
+                try (Encoder array = encoder.encodeArray(JSON_NODE_ARGUMENT)) {
+                    for (JsonNode member : node) {
+                        serialize(array, context, type, member);
+                    }
+                }
+            }
+            case OBJECT -> {
+                try (Encoder obj = encoder.encodeObject(JSON_NODE_ARGUMENT)) {
+                    for (String k : (Iterable<String>) node::fieldNames) {
+                        obj.encodeKey(k);
+                        serialize(encoder, context, type, node.get(k));
+                    }
+                }
+            }
+            default -> throw new IllegalArgumentException("Cannot serialize jackson-databind JsonNode of type " + node.getNodeType());
+        }
+    }
+}

serde-support/src/main/java/io/micronaut/serde/support/serdes/JsonNodeSerde.java

@@ -29,7 +29,6 @@
 
 @Internal
 final class JsonNodeSerde implements SerdeRegistrar<JsonNode> {
-
     @Override
     public void serialize(Encoder encoder, EncoderContext context, Argument<? extends JsonNode> type, JsonNode value)
         throws IOException {
@@ -47,23 +46,7 @@ private void serialize0(Encoder encoder, JsonNode value) throws IOException {
         } else if (value.isString()) {
             encoder.encodeString(value.getStringValue());
         } else if (value.isNumber()) {
-            Number numberValue = value.getNumberValue();
-            if (numberValue instanceof Integer) {
-                encoder.encodeInt(numberValue.intValue());
-            } else if (numberValue instanceof Long) {
-                encoder.encodeLong(numberValue.longValue());
-            } else if (numberValue instanceof Short) {
-                encoder.encodeShort(numberValue.shortValue());
-            } else if (numberValue instanceof Byte) {
-                encoder.encodeByte(numberValue.byteValue());
-            } else if (numberValue instanceof BigInteger bi) {
-                encoder.encodeBigInteger(bi);
-            } else if (numberValue instanceof BigDecimal bd) {
-                encoder.encodeBigDecimal(bd);
-            } else {
-                // double, float, other number types
-                encoder.encodeDouble(numberValue.doubleValue());
-            }
+            encodeNumber(encoder, value.getNumberValue());
         } else if (value.isObject()) {
             Encoder objectEncoder = encoder.encodeObject(Argument.of(JsonNode.class));
             for (Map.Entry<String, JsonNode> entry : value.entries()) {
@@ -82,6 +65,25 @@ private void serialize0(Encoder encoder, JsonNode value) throws IOException {
         }
     }
 
+    static void encodeNumber(Encoder encoder, Number numberValue) throws IOException {
+        if (numberValue instanceof Integer) {
+            encoder.encodeInt(numberValue.intValue());
+        } else if (numberValue instanceof Long) {
+            encoder.encodeLong(numberValue.longValue());
+        } else if (numberValue instanceof Short) {
+            encoder.encodeShort(numberValue.shortValue());
+        } else if (numberValue instanceof Byte) {
+            encoder.encodeByte(numberValue.byteValue());
+        } else if (numberValue instanceof BigInteger bi) {
+            encoder.encodeBigInteger(bi);
+        } else if (numberValue instanceof BigDecimal bd) {
+            encoder.encodeBigDecimal(bd);
+        } else {
+            // double, float, other number types
+            encoder.encodeDouble(numberValue.doubleValue());
+        }
+    }
+
     @Override
     public JsonNode deserialize(Decoder decoder, DecoderContext decoderContext, Argument<? super JsonNode> type)
         throws IOException {

serde-support/src/main/java/io/micronaut/serde/support/serdes/Serdes.java

@@ -122,6 +122,15 @@ public static void register(SerdeConfiguration serdeConfiguration,
         consumer.accept(new ZonedDateTimeSerde(serdeConfiguration));
         consumer.accept(new EnumSerde<>(introspections));
         consumer.accept(new InetAddressSerde(serdeConfiguration));
+        SerdeRegistrar<?> jacksonJsonNodeSerde;
+        try {
+            jacksonJsonNodeSerde = new JacksonJsonNodeSerde();
+        } catch (LinkageError ignored) {
+            jacksonJsonNodeSerde = null;
+        }
+        if (jacksonJsonNodeSerde != null) {
+            consumer.accept(jacksonJsonNodeSerde);
+        }
     }
 
 }