Add Result serializer

Author: RaniAgus

README.md

@@ -665,7 +665,7 @@ public class UserController {
 
 ### JSON Serialization
 
-#### Default Structure
+#### `ValidationErrors` (Default Structure)
 
 ```json
 {
@@ -677,7 +677,7 @@ public class UserController {
 }
 ```
 
-#### Flattened Structure
+#### `ValidationErrors` (Flattened Structure)
 
 Set `io.github.raniagus.javalidation.flatten-errors: true`:
 
@@ -689,6 +689,28 @@ Set `io.github.raniagus.javalidation.flatten-errors: true`:
 }
 ```
 
+#### `Result<T>`
+
+**Ok variant:**
+```java
+Result<String> result = Result.ok("success");
+// Serializes to: {"ok": true, "value": "success"}
+```
+
+**Err variant:**
+```java
+Result<String> result = Result.err("email", "Invalid format");
+// Serializes to: {"ok": false, "errors": {"rootErrors": [], "fieldErrors": {"email": ["Invalid format"]}}}
+```
+
+**Nested in API responses:**
+```java
+record ApiResponse(String id, Result<User> result) {}
+
+ApiResponse response = new ApiResponse("123", Result.ok(new User("Alice", 30)));
+// Serializes to: {"id": "123", "result": {"ok": true, "value": {"name": "Alice", "age": 30}}}
+```
+
 ### Internationalization
 
 Create message files:

javalidation-jackson/src/main/java/io/github/raniagus/javalidation/jackson/FlattenedErrorsSerializer.java

@@ -18,7 +18,7 @@ public void serialize(ValidationErrors value, JsonGenerator gen, SerializationCo
         }
 
         var entries = context.hasSerializationFeatures(ORDER_MAP_ENTRIES_BY_KEYS.getMask()) ?
-                value.fieldErrors().entrySet().stream().sorted(Map.Entry.comparingByKey()).toList()
+                  value.fieldErrors().entrySet().stream().sorted(Map.Entry.comparingByKey()).toList()
                 : value.fieldErrors().entrySet();
 
         for (var entry : entries) {

javalidation-jackson/src/main/java/io/github/raniagus/javalidation/jackson/JavalidationModule.java

@@ -1,5 +1,6 @@
 package io.github.raniagus.javalidation.jackson;
 
+import io.github.raniagus.javalidation.Result;
 import io.github.raniagus.javalidation.ValidationErrors;
 import io.github.raniagus.javalidation.format.TemplateString;
 import io.github.raniagus.javalidation.format.TemplateStringFormatter;
@@ -8,11 +9,12 @@
 import tools.jackson.databind.module.SimpleModule;
 
 /**
- * Jackson module for serializing javalidation types ({@link TemplateString} and {@link ValidationErrors}).
+ * Jackson module for serializing javalidation types ({@link Result}, {@link TemplateString}, and {@link ValidationErrors}).
  * <p>
- * This module registers custom serializers to control how validation errors are serialized to JSON.
+ * This module registers custom serializers to control how validation types are serialized to JSON.
  * By default, it uses:
  * <ul>
+ *   <li>{@link ResultSerializer} for {@link Result} - discriminated union with {@code ok} boolean field</li>
  *   <li>{@link TemplateStringSerializer} for {@link TemplateString} - formats templates using {@link TemplateStringFormatter}</li>
  *   <li>{@link ValidationErrorsMixIn} for {@link ValidationErrors} - structures errors as {@code {root: [...], fields: {...}}}</li>
  * </ul>
@@ -38,6 +40,7 @@
  *     .build();
  * }</pre>
  *
+ * @see ResultSerializer
  * @see TemplateStringSerializer
  * @see FlattenedErrorsSerializer
  * @see ValidationErrorsMixIn
@@ -51,6 +54,7 @@ private JavalidationModule(
     ) {
         super(JavalidationModule.class.getSimpleName());
 
+        addSerializer(new ResultSerializer());
         addSerializer(TemplateString.class, templateStringSerializer);
 
         if (validationErrorsSerializer != null) {

javalidation-jackson/src/main/java/io/github/raniagus/javalidation/jackson/ResultSerializer.java

@@ -0,0 +1,64 @@
+package io.github.raniagus.javalidation.jackson;
+
+import static tools.jackson.databind.SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS;
+
+import io.github.raniagus.javalidation.Result;
+import io.github.raniagus.javalidation.ValidationErrors;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ValueSerializer;
+
+/**
+ * Jackson serializer for {@link Result} types.
+ * <p>
+ * Serializes {@link Result} as a discriminated union with an {@code "ok"} boolean field:
+ * <ul>
+ *   <li>{@link Result.Ok} is serialized as {@code {"ok": true, "value": ...}}</li>
+ *   <li>{@link Result.Err} is serialized as {@code {"ok": false, "errors": ...}}</li>
+ * </ul>
+ * <p>
+ * The {@code value} field is serialized using the configured Jackson serializer for type {@code T}.
+ * The {@code errors} field is serialized using the configured {@link ValidationErrors} serializer.
+ * <p>
+ * Example output:
+ * <pre>{@code
+ * // Result.ok("hello")
+ * {"ok": true, "value": "hello"}
+ *
+ * // Result.err("Invalid input")
+ * {"ok": false, "errors": {"rootErrors": ["Invalid input"], "fieldErrors": {}}}
+ * }</pre>
+ *
+ * @see Result
+ * @see JavalidationModule
+ */
+class ResultSerializer extends ValueSerializer<Result<?>> {
+
+    @Override
+    public Class<?> handledType() {
+        return Result.class;
+    }
+
+    @Override
+    public void serialize(Result result, JsonGenerator gen, SerializationContext context) {
+        gen.writeStartObject();
+
+        switch (result) {
+            case Result.Ok<?>(Object value) -> {
+                context.defaultSerializeProperty("ok", true, gen);
+                context.defaultSerializeProperty("value", value, gen);
+            }
+            case Result.Err<?>(ValidationErrors errors) -> {
+                if (context.hasSerializationFeatures(ORDER_MAP_ENTRIES_BY_KEYS.getMask())) {
+                    context.defaultSerializeProperty("errors", errors, gen);
+                    context.defaultSerializeProperty("ok", false, gen);
+                } else {
+                    context.defaultSerializeProperty("ok", false, gen);
+                    context.defaultSerializeProperty("errors", errors, gen);
+                }
+            }
+        }
+
+        gen.writeEndObject();
+    }
+}

javalidation-jackson/src/test/java/io/github/raniagus/javalidation/jackson/ResultSerializerTest.java

@@ -0,0 +1,125 @@
+package io.github.raniagus.javalidation.jackson;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.github.raniagus.javalidation.Result;
+import io.github.raniagus.javalidation.Validation;
+import io.github.raniagus.javalidation.ValidationErrors;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import tools.jackson.databind.SerializationFeature;
+import tools.jackson.databind.json.JsonMapper;
+
+class ResultSerializerTest {
+    private JsonMapper mapper;
+
+    @BeforeEach
+    void setUp() {
+        mapper = JsonMapper.builder()
+                .addModule(JavalidationModule.getDefault())
+                .enable(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)
+                .build();
+    }
+
+    // -- serialize Ok --
+
+    @Test
+    void givenOkWithString_whenSerialize_thenWritesTypeAndValue() {
+        Result<String> result = Result.ok("hello");
+
+        String json = mapper.writeValueAsString(result);
+
+        assertThat(json).isEqualTo("""
+                {"ok":true,"value":"hello"}\
+                """);
+    }
+
+    @Test
+    void givenOkWithInteger_whenSerialize_thenWritesTypeAndValue() {
+        Result<Integer> result = Result.ok(42);
+
+        String json = mapper.writeValueAsString(result);
+
+        assertThat(json).isEqualTo("""
+                {"ok":true,"value":42}\
+                """);
+    }
+
+    @Test
+    void givenOkWithNull_whenSerialize_thenWritesTypeAndNullValue() {
+        Result<String> result = Result.ok(null);
+
+        String json = mapper.writeValueAsString(result);
+
+        assertThat(json).isEqualTo("""
+                {"ok":true,"value":null}\
+                """);
+    }
+
+    @Test
+    void givenOkWithComplexObject_whenSerialize_thenWritesTypeAndNestedObject() {
+        record Person(String name, int age) {}
+        Result<Person> result = Result.ok(new Person("Alice", 30));
+
+        String json = mapper.writeValueAsString(result);
+
+        assertThat(json).isEqualTo("""
+                {"ok":true,"value":{"name":"Alice","age":30}}\
+                """);
+    }
+
+    // -- serialize Err --
+
+    @Test
+    void givenErrWithRootError_whenSerialize_thenWritesTypeAndErrors() {
+        Result<String> result = Result.err("Invalid input");
+
+        String json = mapper.writeValueAsString(result);
+
+        assertThat(json).isEqualTo("""
+                {"errors":{"rootErrors":["Invalid input"],"fieldErrors":{}},"ok":false}\
+                """);
+    }
+
+    @Test
+    void givenErrWithFieldError_whenSerialize_thenWritesTypeAndErrors() {
+        Result<String> result = Result.err("email", "Invalid format");
+
+        String json = mapper.writeValueAsString(result);
+
+        assertThat(json).isEqualTo("""
+                {"errors":{"rootErrors":[],"fieldErrors":{"email":["Invalid format"]}},"ok":false}\
+                """);
+    }
+
+    @Test
+    void givenErrWithMultipleErrors_whenSerialize_thenWritesAllErrors() {
+        ValidationErrors errors = Validation.create()
+                .addRootError("Global error")
+                .addFieldError("name", "Required")
+                .addFieldError("age", "Must be positive")
+                .finish();
+        Result<String> result = Result.err(errors);
+
+        String json = mapper.writeValueAsString(result);
+
+        assertThat(json).isEqualTo("""
+                {"errors":{"rootErrors":["Global error"],"fieldErrors":{"age":["Must be positive"],"name":["Required"]}},"ok":false}\
+                """);
+    }
+
+    // -- nested in container --
+
+    @Test
+    void givenResultInContainer_whenSerialize_thenSerializesNested() {
+        record Response(String id, Result<String> result) {}
+        Response response = new Response("123", Result.ok("success"));
+
+        String json = mapper.writeValueAsString(response);
+
+        assertThat(json).isEqualTo("""
+                {"id":"123","result":{"ok":true,"value":"success"}}\
+                """);
+    }
+
+}