Support nested objects within attributes when Marshaling

Unmarshaling an attribute that is a struct or struct pointer that is
decorated with jsonapi tags has historically worked as expected, but,
curiously, marshaling did not and required the use of `json` tags
instead, making struct reuse difficult for both input and output
object attributes.

Now, you can specify a struct or struct pointer as an attribute and
it will be marshaled into the correct keys.

Note that this implemenation does not yet support slices of structs or
struct pointers.

Author: brandonc

models_test.go

@@ -184,6 +184,7 @@ type Company struct {
 	ID        string    `jsonapi:"primary,companies"`
 	Name      string    `jsonapi:"attr,name"`
 	Boss      Employee  `jsonapi:"attr,boss"`
+	Manager   *Employee `jsonapi:"attr,manager"`
 	Teams     []Team    `jsonapi:"attr,teams"`
 	People    []*People `jsonapi:"attr,people"`
 	FoundedAt time.Time `jsonapi:"attr,founded-at,iso8601"`

response.go

@@ -226,14 +226,20 @@ func visitModelNode(model interface{}, included *map[string]*Node,
 	node := new(Node)
 
 	var er error
+	var modelValue reflect.Value
+	var modelType reflect.Type
 	value := reflect.ValueOf(model)
-	if value.IsNil() {
-		return nil, nil
+	if value.Type().Kind() == reflect.Pointer {
+		if value.IsNil() {
+			return nil, nil
+		}
+		modelValue = value.Elem()
+		modelType = value.Type().Elem()
+	} else {
+		modelValue = value
+		modelType = value.Type()
 	}
 
-	modelValue := value.Elem()
-	modelType := value.Type().Elem()
-
 	for i := 0; i < modelValue.NumField(); i++ {
 		fieldValue := modelValue.Field(i)
 		structField := modelValue.Type().Field(i)
@@ -395,11 +401,20 @@ func visitModelNode(model interface{}, included *map[string]*Node,
 					continue
 				}
 
-				strAttr, ok := fieldValue.Interface().(string)
-				if ok {
-					node.Attributes[args[1]] = strAttr
+				if fieldValue.Type().Kind() == reflect.Struct || (fieldValue.Type().Kind() == reflect.Pointer && fieldValue.Elem().Kind() == reflect.Struct) {
+					nested, err := visitModelNode(fieldValue.Interface(), nil, false)
+					if err != nil {
+						er = fmt.Errorf("failed to marshal nested attribute %q: %w", args[1], err)
+						break
+					}
+					node.Attributes[args[1]] = nested.Attributes
 				} else {
-					node.Attributes[args[1]] = fieldValue.Interface()
+					strAttr, ok := fieldValue.Interface().(string)
+					if ok {
+						node.Attributes[args[1]] = strAttr
+					} else {
+						node.Attributes[args[1]] = fieldValue.Interface()
+					}
 				}
 			}
 		} else if annotation == annotationRelation || annotation == annotationPolyRelation {

response_test.go

@@ -682,6 +682,60 @@ func TestSupportsAttributes(t *testing.T) {
 	}
 }
 
+func TestMarshalObjectAttribute(t *testing.T) {
+	now := time.Now()
+	testModel := &Company{
+		ID:   "5",
+		Name: "test",
+		Boss: Employee{
+			HiredAt: &now,
+		},
+		Manager: &Employee{
+			Firstname: "Dave",
+			HiredAt:   &now,
+		},
+	}
+
+	out := bytes.NewBuffer(nil)
+	if err := MarshalPayload(out, testModel); err != nil {
+		t.Fatal(err)
+	}
+
+	resp := new(OnePayload)
+	if err := json.NewDecoder(out).Decode(resp); err != nil {
+		t.Fatal(err)
+	}
+
+	data := resp.Data
+
+	if data.Attributes == nil {
+		t.Fatalf("Expected attributes")
+	}
+
+	boss, ok := data.Attributes["boss"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("Expected boss attribute, got %v", data.Attributes)
+	}
+
+	hiredAt, ok := boss["hired-at"]
+	if !ok {
+		t.Fatalf("Expected boss attribute to contain a \"hired-at\" property, got %v", boss)
+	}
+
+	if hiredAt != now.UTC().Format(iso8601TimeFormat) {
+		t.Fatalf("Expected hired-at to be %s, got %s", now.UTC().Format(iso8601TimeFormat), hiredAt)
+	}
+
+	manager, ok := data.Attributes["manager"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("Expected manager attribute, got %v", data.Attributes)
+	}
+
+	if manager["firstname"] != "Dave" {
+		t.Fatalf("Expected manager.firstname to be \"Dave\", got %v", manager)
+	}
+}
+
 func TestOmitsZeroTimes(t *testing.T) {
 	testModel := &Blog{
 		ID:        5,