merge prerelease branch

Author: eli-darkly

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to the project will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [2.5.1] - 2022-06-30
+### Changed:
+- If you create an `ldvalue.Value` with the `ldvalue.Raw(json.RawMessage)` constructor, and you pass a zero-length or nil value to the constructor, and then encode the `Value` to JSON with `json.Marshal` or an equivalent method, the JSON output will now be `null` (that is, the literal characters `null` representing a JSON null value). Previously it would have been a zero-length string, which is not valid as the JSON encoding of any value and could cause the SDK to output a malformed JSON document if the document contained such a value.
+
 ## [2.5.0] - 2021-10-14
 _This release was unintended and can be ignored. It contains no code changes, only changes to the CI build._
 

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

@@ -75,6 +75,10 @@ func (v Value) MarshalJSON() ([]byte, error) {
 	case ObjectType:
 		return v.objectValue.MarshalJSON()
 	case RawType:
+		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
+		}
 		return []byte(v.stringValue), nil
 	}
 	return nil, errors.New("unknown data type") // should not be possible
@@ -135,6 +139,10 @@ 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

@@ -35,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

@@ -64,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

@@ -62,17 +62,28 @@ 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))
 
-	w := jwriter.NewWriter()
-	value.WriteToJSONWriter(&w)
-	assert.NoError(t, w.Error())
-	assert.Equal(t, s, string(w.Bytes()))
+			w := jwriter.NewWriter()
+			value.WriteToJSONWriter(&w)
+			assert.NoError(t, w.Error())
+			assert.Equal(t, params.output, string(w.Bytes()))
+		})
+	}
 }
 
 func TestUnmarshalErrorConditions(t *testing.T) {