jsonapi/response.go

package jsonapi

import (
	"errors"
	"fmt"
	"reflect"
	"strings"
)

type JsonApiResponse struct {
	Data     *JsonApiNode   `json:"data"`
	Included []*JsonApiNode `json:"included,omitempty"`
}

func CreateJsonApiResponse(model interface{}) (*JsonApiResponse, error) {
	rootNode, included, err := visitModelNode(model)
	if err != nil {
		return nil, err
	}

	resp := &JsonApiResponse{Data: rootNode}

	uniqueIncluded := make(map[string]*JsonApiNode)

	for i, n := range included {
		k := fmt.Sprintf("%s,%s", n.Type, n.Id)
		if uniqueIncluded[k] == nil {
			uniqueIncluded[k] = n
		} else {
			included = append(included[:i], included[i+1:]...)
		}
	}

	resp.Included = included

	return resp, nil
}

func visitModelNode(model interface{}) (*JsonApiNode, []*JsonApiNode, error) {
	node := new(JsonApiNode)

	var err error
	var included []*JsonApiNode

	modelType := reflect.TypeOf(model)

	modelType.FieldByNameFunc(func(name string) bool {
		field, found := modelType.FieldByName(name)

		if found {
			fieldValue := reflect.ValueOf(model).FieldByName(name)
			tag := field.Tag.Get("jsonapi")
			args := strings.Split(tag, ",")
			if len(args) >= 1 && args[0] != "" {
				annotation := args[0]

				if annotation == "primary" {
					if len(args) >= 2 {
						node.Id = fmt.Sprintf("%v", fieldValue.Interface())
						node.Type = args[1]
					} else {
						err = errors.New("'type' as second argument required for 'primary'")
					}
				} else if annotation == "attr" {
					if node.Attributes == nil {
						node.Attributes = make(map[string]interface{})
					}

					if len(args) >= 2 {
						node.Attributes[args[1]] = fieldValue.Interface()
					} else {
						err = errors.New("'type' as second argument required for 'primary'")
					}
				} else if annotation == "relation" {
					if node.Relationships == nil {
						node.Relationships = make(map[string]interface{})
					}
					if included == nil {
						included = make([]*JsonApiNode, 0)
					}

					if fieldValue.Type().Kind() == reflect.Slice {
						relationship, err := visitModelNodeRelationships(args[1], fieldValue)

						if err == nil {
							shallowNodes := make([]*JsonApiNode, 0)
							for k, v := range relationship {
								for _, node := range v {
									included = append(included, node)

									shallowNode := *node
									shallowNode.Attributes = nil
									shallowNodes = append(shallowNodes, &shallowNode)
								}

								node.Relationships[k] = shallowNodes
							}
						} else {
							err = err
						}
					} else {
						relationship, _, err := visitModelNode(fieldValue.Interface())
						if err == nil {
							shallowNode := *relationship
							shallowNode.Attributes = nil

							included = append(included, relationship)

							node.Relationships[args[1]] = &shallowNode
						} else {
							err = err
						}
					}

				} else {
					err = errors.New(fmt.Sprintf("Unsupported jsonapi tag annotation, %s", annotation))
				}
			}
		}

		return false
	})

	if err != nil {
		return nil, nil, err
	}

	return node, included, nil
}

func visitModelNodeRelationships(relationName string, models reflect.Value) (map[string][]*JsonApiNode, error) {
	relationship := make(map[string][]*JsonApiNode)
	nodes := make([]*JsonApiNode, 0)

	for i := 0; i < models.Len(); i++ {
		node, _, err := visitModelNode(models.Index(i).Interface())
		if err != nil {
			return nil, err
		}

		nodes = append(nodes, node)
	}

	relationship[relationName] = nodes

	return relationship, nil
}

func handleField(field reflect.StructField) {

}