Merge pull request #19 from avaje/feature/JsonRaw

Add @Json.Raw support (similar to Jackson @JsonRawValue)

Author: rbygrave

blackbox-test/src/main/java/org/example/customer/raw/WithRawContent.java

@@ -0,0 +1,36 @@
+package org.example.customer.raw;
+
+import io.avaje.jsonb.Json;
+
+@Json
+public class WithRawContent {
+
+  final long id;
+
+  final String name;
+
+  @Json.Raw
+  String content;
+
+  public WithRawContent(long id, String name) {
+    this.id = id;
+    this.name = name;
+  }
+
+  public long id() {
+    return id;
+  }
+
+  public String name() {
+    return name;
+  }
+
+  public String content() {
+    return content;
+  }
+
+  public WithRawContent content(String content) {
+    this.content = content;
+    return this;
+  }
+}

blackbox-test/src/test/java/org/example/customer/raw/WithRawContentTest.java

@@ -0,0 +1,110 @@
+package org.example.customer.raw;
+
+import io.avaje.jsonb.JsonType;
+import io.avaje.jsonb.Jsonb;
+import org.junit.jupiter.api.Test;
+
+import java.io.StringReader;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class WithRawContentTest {
+
+  Jsonb jsonb = Jsonb.newBuilder().build();
+  JsonType<WithRawContent> withRawType = jsonb.type(WithRawContent.class);
+
+  @Test
+  void toJson() {
+    String rawJsonContent = "{\"foo\": 99, \"bar\": \"aaa\", \"bazz\":[1,2,3]}";
+
+    WithRawContent withRaw = new WithRawContent(42, "rob");
+    withRaw.content(rawJsonContent);
+
+    String asJson = jsonb.toJson(withRaw);
+    assertThat(asJson).isEqualTo("{\"id\":42,\"name\":\"rob\",\"content\":{\"foo\": 99, \"bar\": \"aaa\", \"bazz\":[1,2,3]}}");
+  }
+
+  @Test
+  void toJson_when_null() {
+    WithRawContent withRaw = new WithRawContent(42, "rob");
+    String asJson = jsonb.toJson(withRaw);
+
+    assertThat(asJson).isEqualTo("{\"id\":42,\"name\":\"rob\"}");
+  }
+
+  @Test
+  void toJson_array() {
+    WithRawContent withRaw = new WithRawContent(42, "rob");
+    withRaw.content(" [ 1 , 2 , 3 ] ");
+
+    String asJson = jsonb.toJson(withRaw);
+    assertThat(asJson).isEqualTo("{\"id\":42,\"name\":\"rob\",\"content\": [ 1 , 2 , 3 ] }");
+  }
+
+  @Test
+  void toFromJson_when_null() {
+    WithRawContent withRaw = new WithRawContent(42, "rob");
+
+    String asJson = jsonb.toJson(withRaw);
+    assertThat(asJson).isEqualTo("{\"id\":42,\"name\":\"rob\"}");
+
+    WithRawContent bean = withRawType.fromJson(asJson);
+    String content = bean.content();
+    assertThat(content).isNull();
+  }
+
+  @Test
+  void toFromJson_when_literalNull() {
+
+    WithRawContent withRaw = new WithRawContent(42, "rob");
+    withRaw.content("null");
+
+    String asJson = jsonb.toJson(withRaw);
+    assertThat(asJson).isEqualTo("{\"id\":42,\"name\":\"rob\"}");
+
+    WithRawContent bean = withRawType.fromJson(asJson);
+    String content = bean.content();
+    assertThat(content).isNull();
+  }
+
+  @Test
+  void toFromJson() {
+    toFromJsonWith("{\"foo\":99}");
+    toFromJsonWith("[1,2,3]");
+    toFromJsonWith("42");
+    toFromJsonWith("true");
+    toFromJsonWith("false");
+    toFromJsonWith("{\"foo\": 99, \"bar\": \"aaa\", \"bazz\":[1,2,3]}");
+  }
+
+  @Test
+  void toFromJson_with_stream() {
+    toFromJsonWith("{\"foo\":99}", true);
+    toFromJsonWith("[1,2,3]", true);
+    toFromJsonWith("42", true);
+    toFromJsonWith("true", true);
+    toFromJsonWith("false", true);
+    toFromJsonWith("{\"foo\": 99, \"bar\": \"aaa\", \"bazz\":[1,2,3]}", true);
+  }
+
+  private void toFromJsonWith(String rawJsonContent) {
+    toFromJsonWith(rawJsonContent, false);
+  }
+
+  private void toFromJsonWith(String rawJsonContent, boolean stream) {
+    WithRawContent withRaw = new WithRawContent(42, "rob");
+    withRaw.content(rawJsonContent);
+
+    String asJson = jsonb.toJson(withRaw);
+    assertThat(asJson).isEqualTo("{\"id\":42,\"name\":\"rob\",\"content\":" + rawJsonContent + "}");
+
+    WithRawContent bean;
+    if (stream) {
+      bean = withRawType.fromJson(new StringReader(asJson));
+    } else {
+      bean = withRawType.fromJson(asJson);
+    }
+    String content = bean.content();
+    assertThat(content).isEqualTo(rawJsonContent);
+  }
+}

jsonb-generator/src/main/java/io/avaje/jsonb/generator/BeanReader.java

@@ -21,6 +21,7 @@ class BeanReader {
   private final TypeReader typeReader;
   private final String typeProperty;
   private FieldReader unmappedField;
+  private boolean hasRaw;
 
   BeanReader(TypeElement beanType, ProcessingContext context) {
     this.beanType = beanType;
@@ -61,6 +62,9 @@ boolean hasSubtypes() {
   void read() {
     for (FieldReader field : allFields) {
       field.addImports(importTypes);
+      if (field.isRaw()) {
+        hasRaw = true;
+      }
       if (field.isUnmapped()) {
         unmappedField = field;
       }
@@ -113,9 +117,12 @@ void writeFields(Append writer) {
       allField.writeDebug(writer);
     }
     writer.eol();
+    if (hasRaw) {
+      writer.append("  private final JsonAdapter<String> rawAdapter;").eol();
+    }
     Set<String> uniqueTypes = new HashSet<>();
     for (FieldReader allField : allFields) {
-      if (allField.include()) {
+      if (allField.include() && !allField.isRaw()) {
         if (uniqueTypes.add(allField.adapterShortType())) {
           allField.writeField(writer);
         }
@@ -126,9 +133,12 @@ void writeFields(Append writer) {
   }
 
   void writeConstructor(Append writer) {
+    if (hasRaw) {
+      writer.append("    this.rawAdapter = jsonb.rawAdapter();").eol();
+    }
     Set<String> uniqueTypes = new HashSet<>();
     for (FieldReader allField : allFields) {
-      if (allField.include()) {
+      if (allField.include() || !allField.isRaw()) {
         if (uniqueTypes.add(allField.adapterShortType())) {
           allField.writeConstructor(writer);
         }

jsonb-generator/src/main/java/io/avaje/jsonb/generator/FieldReader.java

@@ -22,6 +22,7 @@ class FieldReader {
   private final boolean serialize;
   private final boolean deserialize;
   private final boolean unmapped;
+  private final boolean raw;
 
   private MethodReader setter;
   private MethodReader getter;
@@ -38,10 +39,16 @@ class FieldReader {
 
     PropertyIgnoreReader ignoreReader = new PropertyIgnoreReader(element);
     this.unmapped = ignoreReader.unmapped();
+    this.raw = ignoreReader.raw();
     this.serialize = ignoreReader.serialize();
     this.deserialize = ignoreReader.deserialize();
-
-    if (unmapped) {
+    if (raw) {
+      genericType = GenericType.parse("java.lang.String");
+      adapterShortType = "JsonAdapter<String>";
+      adapterFieldName = "rawAdapter";
+      defaultValue = "null";
+      primitive = false;
+    } else if (unmapped) {
       genericType = GenericType.parse("java.lang.Object");
       adapterShortType = "JsonAdapter<Object>";
       adapterFieldName = "objectJsonAdapter";
@@ -70,6 +77,10 @@ String propertyName() {
     return propertyName;
   }
 
+  boolean isRaw() {
+    return raw;
+  }
+
   boolean isUnmapped() {
     return unmapped;
   }
@@ -100,11 +111,13 @@ void addImports(Set<String> importTypes) {
     if (unmapped) {
       importTypes.add("java.util.*");
     }
-    genericType.addImports(importTypes);
+    if (!raw) {
+      genericType.addImports(importTypes);
+    }
   }
 
   void cascadeTypes(Set<String> types) {
-    if (!unmapped) {
+    if (!raw && !unmapped) {
       String topType = genericType.topType();
       if (topType.equals("java.util.List") || topType.equals("java.util.Set")) {
         types.add(genericType.firstParamType());
@@ -165,8 +178,12 @@ void writeField(Append writer) {
   }
 
   void writeConstructor(Append writer) {
-    String asType = genericType.asTypeDeclaration();
-    writer.append("    this.%s = jsonb.adapter(%s);", adapterFieldName, asType).eol();
+    if (raw) {
+      writer.append("    this.%s = jsonb.rawAdapter();", adapterFieldName).eol();
+    } else {
+      String asType = genericType.asTypeDeclaration();
+      writer.append("    this.%s = jsonb.adapter(%s);", adapterFieldName, asType).eol();
+    }
   }
 
   void writeToJson(Append writer, String varName, String prefix) {

jsonb-generator/src/main/java/io/avaje/jsonb/generator/PropertyIgnoreReader.java

@@ -10,8 +10,10 @@ class PropertyIgnoreReader {
 
   private static final String JSON_IGNORE = "io.avaje.jsonb.Json.Ignore";
   private static final String JSON_UNMAPPED = "io.avaje.jsonb.Json.Unmapped";
+  private static final String JSON_RAW = "io.avaje.jsonb.Json.Raw";
 
   private boolean unmapped;
+  private boolean raw;
   private boolean ignoreSerialize;
   private boolean ignoreDeserialize;
 
@@ -23,6 +25,10 @@ boolean unmapped() {
     return unmapped;
   }
 
+  boolean raw() {
+    return raw;
+  }
+
   boolean serialize() {
     return !ignoreSerialize;
   }
@@ -38,6 +44,8 @@ void read(Element element) {
     for (AnnotationMirror mirror : element.getAnnotationMirrors()) {
       if (JSON_UNMAPPED.equals(mirror.getAnnotationType().toString())) {
         unmapped = true;
+      } else if (JSON_RAW.equals(mirror.getAnnotationType().toString())) {
+        raw = true;
       } else if (JSON_IGNORE.equals(mirror.getAnnotationType().toString())) {
         ignoreDeserialize = true;
         ignoreSerialize = true;

jsonb-jackson/src/main/java/io/avaje/jsonb/jackson/JacksonReader.java

@@ -2,6 +2,7 @@
 
 import com.fasterxml.jackson.core.JsonParser;
 import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.core.TreeNode;
 import io.avaje.jsonb.JsonIoException;
 import io.avaje.jsonb.JsonReader;
 import io.avaje.jsonb.spi.PropertyNames;
@@ -50,6 +51,16 @@ public void skipValue() {
     }
   }
 
+  @Override
+  public String readRaw() {
+    try {
+      TreeNode tree = parser.getCodec().readTree(parser);
+      return tree.toString();
+    } catch (IOException e) {
+      throw new JsonIoException(e);
+    }
+  }
+
   @Override
   public void beginArray() {
     try {

jsonb-jackson/src/main/java/io/avaje/jsonb/jackson/JacksonWriter.java

@@ -342,6 +342,20 @@ public void value(byte[] value) {
     }
   }
 
+  @Override
+  public void rawValue(String value) {
+    if (value == null) {
+      nullValue();
+    } else {
+      try {
+        writeDeferredName();
+        generator.writeRaw(value);
+      } catch (IOException e) {
+        throw new JsonIoException(e);
+      }
+    }
+  }
+
   @Override
   public void writeNewLine() {
     try {

jsonb-jakarta/src/main/java/io/avaje/jsonb/jakarta/JakartaJsonReader.java

@@ -113,6 +113,11 @@ public byte[] readBinary() {
     return new byte[0];
   }
 
+  @Override
+  public String readRaw() {
+    throw new RuntimeException("Not Supported");
+  }
+
   @Override
   public boolean isNullValue() {
     return currenEvent == JsonParser.Event.VALUE_NULL;

jsonb-jakarta/src/main/java/io/avaje/jsonb/jakarta/JakartaJsonWriter.java

@@ -219,12 +219,17 @@ public void value(BigInteger value) {
 
   @Override
   public void value(byte[] value) {
+    throw new RuntimeException("Not supported");
+  }
 
+  @Override
+  public void rawValue(String value) {
+    throw new RuntimeException("Not supported");
   }
 
   @Override
   public void writeNewLine() {
-    // TODO: No support to write new line characters for x-json-stream
+    throw new RuntimeException("Not supported");
   }
 
   @Override

jsonb/src/main/java/io/avaje/jsonb/Json.java

@@ -182,6 +182,14 @@
     SubType[] value();
   }
 
+  /**
+   * Marks a String field as containing raw JSON content.
+   */
+  @Retention(CLASS)
+  @Target({ElementType.FIELD})
+  @interface Raw {
+
+  }
 
   /**
    * The naming convention that we can use for a given type.