Add ResultMixIn for improved JSON serialization of Result types

Author: RaniAgus

README.md

@@ -782,13 +782,13 @@ Set `io.github.raniagus.javalidation.flatten-errors: true`:
 **Ok variant:**
 ```java
 Result<String> result = Result.ok("success");
-// Serializes to: {"ok": true, "value": "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"]}}}
+// Serializes to: {"ok": "false", "errors": {"rootErrors": [], "fieldErrors": {"email": ["Invalid format"]}}}
 ```
 
 **Nested in API responses:**

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

@@ -14,7 +14,7 @@
  * 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 ResultMixIn} 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>
@@ -40,36 +40,47 @@
  *     .build();
  * }</pre>
  *
- * @see ResultSerializer
  * @see TemplateStringSerializer
  * @see FlattenedErrorsSerializer
  * @see ValidationErrorsMixIn
  */
 public class JavalidationModule extends SimpleModule {
-    private final boolean useDefaultSerializer;
+    private final boolean useDefaultResultSerializer;
+    private final boolean useDefaultErrorSerializer;
 
     private JavalidationModule(
-            ValueSerializer<Result<?>> resultSerializer,
+            @Nullable ValueSerializer<Result<?>> resultSerializer,
             ValueSerializer<TemplateString> templateStringSerializer,
             @Nullable ValueSerializer<ValidationErrors> validationErrorsSerializer
     ) {
         super(JavalidationModule.class.getSimpleName());
 
-        addSerializer(resultSerializer);
+        if (resultSerializer != null) {
+            addSerializer(resultSerializer);
+            this.useDefaultResultSerializer = false;
+        } else {
+            this.useDefaultResultSerializer = true;
+        }
+
         addSerializer(TemplateString.class, templateStringSerializer);
 
         if (validationErrorsSerializer != null) {
             addSerializer(ValidationErrors.class, validationErrorsSerializer);
-            this.useDefaultSerializer = false;
+            this.useDefaultErrorSerializer = false;
         } else {
-            this.useDefaultSerializer = true;
+            this.useDefaultErrorSerializer = true;
         }
     }
 
     @Override
     public void setupModule(SetupContext context) {
         super.setupModule(context);
-        if (useDefaultSerializer) {
+        if (useDefaultResultSerializer) {
+            context.setMixIn(Result.class, ResultMixIn.class);
+            context.setMixIn(Result.Ok.class, ResultMixIn.OkMixin.class);
+            context.setMixIn(Result.Err.class, ResultMixIn.ErrMixin.class);
+        }
+        if (useDefaultErrorSerializer) {
             context.setMixIn(ValidationErrors.class, ValidationErrorsMixIn.class);
         }
     }
@@ -104,7 +115,7 @@ public static Builder builder() {
      * @see #withFlattenedErrors()
      */
     public static class Builder {
-        private ValueSerializer<Result<?>> resultSerializer = new ResultSerializer();
+        private @Nullable ValueSerializer<Result<?>> resultSerializer;
         private ValueSerializer<TemplateString> templateStringSerializer = new TemplateStringSerializer();
         private @Nullable ValueSerializer<ValidationErrors> validationErrorsSerializer;
 

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

@@ -0,0 +1,37 @@
+package io.github.raniagus.javalidation.jackson;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import io.github.raniagus.javalidation.Result;
+import io.github.raniagus.javalidation.ValidationErrors;
+import org.jspecify.annotations.Nullable;
+
+@JsonTypeInfo(
+        use = JsonTypeInfo.Id.NAME,
+        include = JsonTypeInfo.As.PROPERTY,
+        property = "ok"
+)
+@JsonSubTypes({
+        @JsonSubTypes.Type(value = Result.Ok.class, name = "true"),
+        @JsonSubTypes.Type(value = Result.Err.class, name = "false")
+})
+public interface ResultMixIn {
+
+    interface OkMixin<T extends @Nullable Object> {
+        T value();
+
+        @JsonIgnore
+        ValidationErrors getErrors();
+
+        @JsonIgnore
+        T getOrThrow();
+    }
+
+    interface ErrMixin {
+        ValidationErrors errors();
+
+        @JsonIgnore
+        Object getOrThrow();
+    }
+}

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

@@ -5,15 +5,15 @@
 import java.util.List;
 import java.util.Map;
 
-public abstract class ValidationErrorsMixIn {
+public interface ValidationErrorsMixIn {
 
-    abstract List<TemplateString> rootErrors();
+    List<TemplateString> rootErrors();
 
-    abstract Map<String, List<TemplateString>> fieldErrors();
+    Map<String, List<TemplateString>> fieldErrors();
 
     @JsonIgnore
-    abstract boolean isEmpty();
+    boolean isEmpty();
 
     @JsonIgnore
-    abstract boolean isNotEmpty();
+    boolean isNotEmpty();
 }

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

@@ -30,7 +30,7 @@ void givenOkWithString_whenSerialize_thenWritesTypeAndValue() {
         String json = mapper.writeValueAsString(result);
 
         assertThat(json).isEqualTo("""
-                {"ok":true,"value":"hello"}\
+                {"ok":"true","value":"hello"}\
                 """);
     }
 
@@ -41,7 +41,7 @@ void givenOkWithInteger_whenSerialize_thenWritesTypeAndValue() {
         String json = mapper.writeValueAsString(result);
 
         assertThat(json).isEqualTo("""
-                {"ok":true,"value":42}\
+                {"ok":"true","value":42}\
                 """);
     }
 
@@ -52,7 +52,7 @@ void givenOkWithNull_whenSerialize_thenWritesTypeAndNullValue() {
         String json = mapper.writeValueAsString(result);
 
         assertThat(json).isEqualTo("""
-                {"ok":true,"value":null}\
+                {"ok":"true","value":null}\
                 """);
     }
 
@@ -64,7 +64,7 @@ record Person(String name, int age) {}
         String json = mapper.writeValueAsString(result);
 
         assertThat(json).isEqualTo("""
-                {"ok":true,"value":{"name":"Alice","age":30}}\
+                {"ok":"true","value":{"name":"Alice","age":30}}\
                 """);
     }
 
@@ -77,7 +77,7 @@ void givenErrWithRootError_whenSerialize_thenWritesTypeAndErrors() {
         String json = mapper.writeValueAsString(result);
 
         assertThat(json).isEqualTo("""
-                {"errors":{"rootErrors":["Invalid input"],"fieldErrors":{}},"ok":false}\
+                {"ok":"false","errors":{"rootErrors":["Invalid input"],"fieldErrors":{}}}\
                 """);
     }
 
@@ -88,7 +88,7 @@ void givenErrWithFieldError_whenSerialize_thenWritesTypeAndErrors() {
         String json = mapper.writeValueAsString(result);
 
         assertThat(json).isEqualTo("""
-                {"errors":{"rootErrors":[],"fieldErrors":{"email":["Invalid format"]}},"ok":false}\
+                {"ok":"false","errors":{"rootErrors":[],"fieldErrors":{"email":["Invalid format"]}}}\
                 """);
     }
 
@@ -104,7 +104,7 @@ void givenErrWithMultipleErrors_whenSerialize_thenWritesAllErrors() {
         String json = mapper.writeValueAsString(result);
 
         assertThat(json).isEqualTo("""
-                {"errors":{"rootErrors":["Global error"],"fieldErrors":{"age":["Must be positive"],"name":["Required"]}},"ok":false}\
+                {"ok":"false","errors":{"rootErrors":["Global error"],"fieldErrors":{"age":["Must be positive"],"name":["Required"]}}}\
                 """);
     }
 
@@ -118,7 +118,7 @@ record Response(String id, Result<String> result) {}
         String json = mapper.writeValueAsString(response);
 
         assertThat(json).isEqualTo("""
-                {"id":"123","result":{"ok":true,"value":"success"}}\
+                {"id":"123","result":{"ok":"true","value":"success"}}\
                 """);
     }