feat: add Jackson serializers for Component and Node types (#22400)

- Add custom Jackson serializers to handle @v-node serialization for Components and Nodes in collections
- Remove duplicate component handling from JacksonCodec.encodeWithTypeInfo()
- ComponentSerializer delegates to NodeSerializer to eliminate code duplication
- NodeSerializer handles all Node types (Element, ShadowRoot) with consistent @v-node logic
- Prevents infinite recursion when serializing Components in collections
- Maintains existing @v-node serialization format for client compatibility

Author: Artur-

flow-server/src/main/java/com/vaadin/flow/internal/JacksonCodec.java

@@ -28,7 +28,6 @@
 
 import com.vaadin.flow.component.Component;
 import com.vaadin.flow.dom.Element;
-import com.vaadin.flow.dom.Node;
 import com.vaadin.flow.internal.nodefeature.ReturnChannelRegistration;
 
 /**
@@ -63,8 +62,9 @@ private JacksonCodec() {
      * JSON. Such types are encoded as an JSON array starting with an id
      * defining the actual type and followed by the actual data. Supported value
      * types are any native JSON type supported by
-     * {@link #encodeWithoutTypeInfo(Object)}, {@link Element} and
-     * {@link Component} (encoded as its root element).
+     * {@link #encodeWithoutTypeInfo(Object)}, and all other types are handled
+     * by Jackson serialization with custom serializers for {@link Component}
+     * and Node types.
      *
      * @param value
      *            the value to encode
@@ -74,18 +74,15 @@ public static JsonNode encodeWithTypeInfo(Object value) {
 
         if (value == null) {
             return encodeWithoutTypeInfo(value);
-        } else if (value instanceof Component) {
-            return encodeNode(((Component) value).getElement());
-        } else if (value instanceof Node<?>) {
-            return encodeNode((Node<?>) value);
         } else if (value instanceof ReturnChannelRegistration) {
             return encodeReturnChannel((ReturnChannelRegistration) value);
         } else if (canEncodeWithoutTypeInfo(value.getClass())) {
             // Native JSON types - no wrapping needed
             return encodeWithoutTypeInfo(value);
         } else {
-            // All other types (including arrays and beans) use standard Jackson
-            // serialization
+            // All other types (including Components, Nodes, arrays and beans)
+            // use standard Jackson
+            // serialization with custom serializers for Components and Nodes
             return JacksonUtils.getMapper().valueToTree(value);
         }
     }
@@ -101,18 +98,6 @@ private static JsonNode encodeReturnChannel(
         return obj;
     }
 
-    private static JsonNode encodeNode(Node<?> node) {
-        StateNode stateNode = node.getNode();
-        if (stateNode.isAttached()) {
-            ObjectMapper mapper = JacksonUtils.getMapper();
-            ObjectNode obj = mapper.createObjectNode();
-            obj.put("@v-node", stateNode.getId());
-            return obj;
-        } else {
-            return JacksonUtils.getMapper().nullNode();
-        }
-    }
-
     /**
      * Helper for checking whether the type is supported by
      * {@link #encodeWithoutTypeInfo(Object)}. Supported value types are

flow-server/src/main/java/com/vaadin/flow/internal/JacksonUtils.java

@@ -33,6 +33,7 @@
 import java.util.stream.Stream;
 
 import tools.jackson.core.JacksonException;
+import tools.jackson.core.JsonGenerator;
 import tools.jackson.core.json.JsonReadFeature;
 import tools.jackson.core.type.TypeReference;
 import tools.jackson.core.util.DefaultPrettyPrinter;
@@ -41,14 +42,21 @@
 import tools.jackson.databind.DeserializationFeature;
 import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.ObjectMapper;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
 import tools.jackson.databind.json.JsonMapper;
+import tools.jackson.databind.module.SimpleModule;
 import tools.jackson.databind.node.ArrayNode;
 import tools.jackson.databind.node.BaseJsonNode;
 import tools.jackson.databind.node.DoubleNode;
 import tools.jackson.databind.node.JsonNodeType;
 import tools.jackson.databind.node.ObjectNode;
 import tools.jackson.databind.node.ValueNode;
 
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.dom.Element;
+import com.vaadin.flow.dom.Node;
+
 import elemental.json.Json;
 import elemental.json.JsonArray;
 import elemental.json.JsonBoolean;
@@ -71,10 +79,17 @@ public final class JacksonUtils {
 
     private static final String CANNOT_CONVERT_NULL_TO_OBJECT = "Cannot convert null to Java object";
 
-    private static final ObjectMapper objectMapper = JsonMapper.builder()
-            .enable(JsonReadFeature.ALLOW_SINGLE_QUOTES)
-            .disable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES)
-            .build();
+    private static final ObjectMapper objectMapper = createConfiguredMapper();
+
+    private static ObjectMapper createConfiguredMapper() {
+        SimpleModule module = new SimpleModule();
+        module.addSerializer(Component.class, new ComponentSerializer());
+        module.addSerializer(Node.class, new NodeSerializer());
+
+        return JsonMapper.builder().enable(JsonReadFeature.ALLOW_SINGLE_QUOTES)
+                .disable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES)
+                .addModule(module).build();
+    }
 
     public static ObjectMapper getMapper() {
         return objectMapper;
@@ -632,4 +647,63 @@ public static String toFileJson(JsonNode node) throws JacksonException {
                         .withObjectNameValueSpacing(Spacing.AFTER));
         return objectMapper.writer().with(filePrinter).writeValueAsString(node);
     }
+
+    /**
+     * Custom Jackson serializer for Component that delegates to NodeSerializer.
+     */
+    public static class ComponentSerializer extends ValueSerializer<Component> {
+        private final NodeSerializer nodeSerializer = new NodeSerializer();
+
+        @Override
+        public void serialize(Component component, JsonGenerator gen,
+                SerializationContext serializers) {
+            try {
+                if (component != null) {
+                    // Delegate to NodeSerializer using the component's element
+                    nodeSerializer.serialize(component.getElement(), gen,
+                            serializers);
+                } else {
+                    gen.writeNull();
+                }
+            } catch (Exception e) {
+                throw new RuntimeException("Failed to serialize Component", e);
+            }
+        }
+    }
+
+    /**
+     * Custom Jackson serializer for Node types (Element, ShadowRoot) that
+     * serializes attached nodes as @v-node references for client-side DOM
+     * manipulation.
+     */
+    @SuppressWarnings("rawtypes")
+    public static class NodeSerializer extends ValueSerializer<Node> {
+        @Override
+        @SuppressWarnings("unchecked")
+        public void serialize(Node node, JsonGenerator gen,
+                SerializationContext serializers) {
+            try {
+                if (node != null) {
+                    // Serialize attached nodes as @v-node references containing
+                    // the StateNode ID
+                    // This allows the client to identify and manipulate the
+                    // corresponding DOM element
+                    if (node.getNode().isAttached()) {
+                        gen.writeStartObject();
+                        gen.writeNumberProperty("@v-node",
+                                node.getNode().getId());
+                        gen.writeEndObject();
+                    } else {
+                        // Detached nodes cannot be referenced on the client, so
+                        // serialize as null
+                        gen.writeNull();
+                    }
+                } else {
+                    gen.writeNull();
+                }
+            } catch (Exception e) {
+                throw new RuntimeException("Failed to serialize Node", e);
+            }
+        }
+    }
 }