Make deepobject support nullable values

Author: James Waters

deepobject.go

@@ -15,6 +15,11 @@ import (
 	"github.com/oapi-codegen/runtime/types"
 )
 
+type nullableLike interface {
+	SetNull()
+	UnmarshalJSON(data []byte) error
+}
+
 func marshalDeepObject(in interface{}, path []string) ([]string, error) {
 	var result []string
 
@@ -55,8 +60,16 @@ func marshalDeepObject(in interface{}, path []string) ([]string, error) {
 		// into a deepObject style set of subscripts. [a, b, c] turns into
 		// [a][b][c]
 		prefix := "[" + strings.Join(path, "][") + "]"
+
+		var value string
+		if t == nil {
+			value = "null"
+		} else {
+			value = fmt.Sprintf("%v", t)
+		}
+
 		result = []string{
-			prefix + fmt.Sprintf("=%v", t),
+			prefix + fmt.Sprintf("=%s", value),
 		}
 	}
 	return result, nil
@@ -214,6 +227,38 @@ func assignPathValues(dst interface{}, pathValues fieldOrValue) error {
 
 	switch it.Kind() {
 	case reflect.Map:
+		// If the value looks like nullable.Nullable[T], we need to handle it properly.
+		if dst, ok := dst.(nullableLike); ok {
+			if pathValues.value == "null" {
+				dst.SetNull()
+
+				return nil
+			}
+
+			// We create a new empty value, who's type is the same as the
+			// 'T' in nullable.Nullable[T]. Because of how nullable.Nullable is
+			// implemented, we can do that by getting the type's element type.
+			data := reflect.New(it.Elem()).Interface()
+
+			// We now try to assign the path values to the new type.
+			if err := assignPathValues(data, pathValues); err != nil {
+				return err
+			}
+
+			// We'll marshal the data so that we can unmarshal it into
+			// the original nullable.Nullable value.
+			dataBytes, err := json.Marshal(data)
+			if err != nil {
+				return err
+			}
+
+			if err := dst.UnmarshalJSON(dataBytes); err != nil {
+				return err
+			}
+
+			return nil
+		}
+
 		dstMap := reflect.MakeMap(iv.Type())
 		for key, value := range pathValues.fields {
 			dstKey := reflect.ValueOf(key)

deepobject_test.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/google/uuid"
+	"github.com/oapi-codegen/nullable"
 	"github.com/oapi-codegen/runtime/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -42,6 +43,13 @@ type AllFields struct {
 	Oti *time.Time  `json:"oti,omitempty"`
 	U   types.UUID  `json:"u"`
 	Ou  *types.UUID `json:"ou,omitempty"`
+
+	// Nullable
+	NiSet   nullable.Nullable[int]         `json:"ni_set,omitempty"`
+	NiNull  nullable.Nullable[int]         `json:"ni_null,omitempty"`
+	NiUnset nullable.Nullable[int]         `json:"ni_unset,omitempty"`
+	No      nullable.Nullable[InnerObject] `json:"no,omitempty"`
+	Nu      nullable.Nullable[uuid.UUID]   `json:"nu,omitempty"`
 }
 
 func TestDeepObject(t *testing.T) {
@@ -89,6 +97,15 @@ func TestDeepObject(t *testing.T) {
 		Oti: &ti,
 		U:   u,
 		Ou:  &u,
+
+		// Nullable
+		NiSet:  nullable.NewNullableWithValue(5),
+		NiNull: nullable.NewNullNullable[int](),
+		No: nullable.NewNullableWithValue(InnerObject{
+			Name: "John Smith",
+			ID:   456,
+		}),
+		Nu: nullable.NewNullableWithValue(uuid.New()),
 	}
 
 	marshaled, err := MarshalDeepObject(srcObj, "p")