transparently convert empty raw JSON value to null

ldvalue/value_base.go

@@ -79,6 +79,18 @@ func String(value string) Value {
 }
 
 // Raw creates an unparsed JSON Value.
+//
+// This constructor will store the json.RawMessage value as-is without syntax validation, and will set
+// the type of the Value to ldvalue.RawType. That means, for instance, that ldvalue.Raw(json.RawMessage("true"))
+// is not logically equivalent to ldvalue.Bool(true), even though they will produce the same result if
+// they are re-encoded to JSON.
+//
+// That also means that if you pass malformed data that is not valid JSON, you will get malformed data if
+// it is re-encoded to JSON. It is the caller's responsibility to make sure the json.RawMessage really is
+// valid JSON. However, since it is easy to mistakenly write json.RawMessage(nil) (a zero-length value)
+// when what is really meant is a JSON null value, the ldvalue.Value JSON encoder will detect any use of
+// json.RawMessage(nil) or json.RawMessage("") and transparently convert it to "null" when it is
+// being encoded to JSON.
 func Raw(value json.RawMessage) Value {
 	return Value{valueType: RawType, stringValue: string(value)}
 }
@@ -355,6 +367,10 @@ func (v Value) AsOptionalString() OptionalString {
 //
 // If the value was originally created from a RawMessage, it returns the same value. For all other
 // values, it converts the value to its JSON representation and returns that representation.
+//
+// Note that the ldvalue.Raw(json.RawMessage) constructor does not do any syntax validation, so
+// if you create a Value from a malformed string such as ldvalue.Raw(json.RawMessage("{{{")), you
+// will get back the same string from AsRaw().
 func (v Value) AsRaw() json.RawMessage {
 	if v.valueType == RawType {
 		return json.RawMessage(v.stringValue)

ldvalue/value_serialization.go

@@ -77,7 +77,11 @@ func (v Value) MarshalJSON() ([]byte, error) {
 	case ObjectType:
 		return v.objectValue.MarshalJSON()
 	case RawType:
-		return []byte(v.stringValue), nil
+		if len(v.stringValue) == 0 {
+			return nullAsJSONBytes, nil // we don't check for other kinds of malformed JSON here, but if it was nil/"" we can assume they meant null
+		} else {
+			return []byte(v.stringValue), nil
+		}
 	}
 	return nil, errors.New("unknown data type") // should not be possible
 }
@@ -137,7 +141,11 @@ func (v Value) WriteToJSONWriter(w *jwriter.Writer) {
 	case ObjectType:
 		v.objectValue.WriteToJSONWriter(w)
 	case RawType:
-		w.Raw([]byte(v.stringValue))
+		if len(v.stringValue) == 0 {
+			w.Null() // we don't check for other kinds of malformed JSON here, but if it was nil/"" we can assume they meant null
+		} else {
+			w.Raw([]byte(v.stringValue))
+		}
 	}
 }
 

ldvalue/value_serialization_easyjson.go

@@ -1,3 +1,4 @@
+//go:build launchdarkly_easyjson
 // +build launchdarkly_easyjson
 
 package ldvalue
@@ -34,6 +35,12 @@ func (v Value) MarshalEasyJSON(writer *ej_jwriter.Writer) {
 		v.arrayValue.MarshalEasyJSON(writer)
 	case ObjectType:
 		v.objectValue.MarshalEasyJSON(writer)
+	case RawType:
+		if len(v.stringValue) == 0 {
+			writer.Raw(nullAsJSONBytes, nil) // see Value.MarshalJSON
+		} else {
+			writer.RawString(v.stringValue)
+		}
 	}
 }
 

ldvalue/value_serialization_easyjson_test.go

@@ -1,3 +1,4 @@
+//go:build launchdarkly_easyjson
 // +build launchdarkly_easyjson
 
 package ldvalue
@@ -63,3 +64,24 @@ func TestEasyJsonUnmarshalErrorConditions(t *testing.T) {
 		})
 	}
 }
+
+func TestEasyJsonMarshalRaw(t *testing.T) {
+	// This is separate from the MarshalUnmarshal test because you never get a Raw when you unmarshal.
+	for _, params := range []struct {
+		desc   string
+		input  json.RawMessage
+		output string
+	}{
+		{"valid JSON", json.RawMessage(`{"a":1}`), `{"a":1}`},
+		{"zero-length", json.RawMessage{}, `null`},
+		{"nil", json.RawMessage(nil), `null`},
+	} {
+		t.Run(params.desc, func(t *testing.T) {
+			value := Raw(params.input)
+
+			j, err := easyjson.Marshal(value)
+			assert.NoError(t, err)
+			assert.Equal(t, params.output, string(j))
+		})
+	}
+}

ldvalue/value_serialization_test.go

@@ -70,18 +70,29 @@ func TestJsonMarshalUnmarshal(t *testing.T) {
 
 func TestMarshalRaw(t *testing.T) {
 	// This is separate from the MarshalUnmarshal test because you never get a Raw when you unmarshal.
-	s := `{"a":1}`
-	value := Raw(json.RawMessage(s))
+	for _, params := range []struct {
+		desc   string
+		input  json.RawMessage
+		output string
+	}{
+		{"valid JSON", json.RawMessage(`{"a":1}`), `{"a":1}`},
+		{"zero-length", json.RawMessage{}, `null`},
+		{"nil", json.RawMessage(nil), `null`},
+	} {
+		t.Run(params.desc, func(t *testing.T) {
+			value := Raw(params.input)
 
-	bytes, err := json.Marshal(value)
-	assert.NoError(t, err)
-	assert.Equal(t, s, string(bytes))
+			bytes, err := json.Marshal(value)
+			assert.NoError(t, err)
+			assert.Equal(t, params.output, string(bytes))
 
-	var buf jsonstream.JSONBuffer
-	value.WriteToJSONBuffer(&buf)
-	bytes, err = buf.Get()
-	assert.NoError(t, err)
-	assert.Equal(t, s, string(bytes))
+			var buf jsonstream.JSONBuffer
+			value.WriteToJSONBuffer(&buf)
+			bytes, err = buf.Get()
+			assert.NoError(t, err)
+			assert.Equal(t, params.output, string(bytes))
+		})
+	}
 }
 
 func TestUnmarshalErrorConditions(t *testing.T) {