Nailing down initial types, requests, responses

Author: Derek Dowling

README.md

@@ -0,0 +1,15 @@
+Go JSON API
+---
+
+Go API helpers for achieving a [JSON API Specification](http://jsonapi.org/)
+compatible backend.
+
+## Mission
+
+To make dealing with JSON APIs in Go simple, consistent, and easy.
+
+## Installation
+
+```
+$ go get github.com/derekdowling/go-jsonapi
+```

error.go

@@ -0,0 +1,11 @@
+package japi
+
+// Error represents a JSON Spec Error
+type Error struct {
+	Title  string `json:"title"`
+	Detail string `json:"detail"`
+	Status int    `json:"status"`
+	Source struct {
+		Pointer string `json:"pointer"`
+	} `json:"source"`
+}

object.go

@@ -0,0 +1,8 @@
+package japi
+
+// Object represents the default JSON spec for objects
+type Object struct {
+	Type       string      `json:"type"`
+	ID         string      `json:"id"`
+	Attributes interface{} `json:"attributes"`
+}

request.go

@@ -0,0 +1,56 @@
+package japi
+
+import (
+	"encoding/json"
+	"io"
+	"io/ioutil"
+)
+
+const (
+	// ContentType is the data encoding of choice for HTTP Request and Response Headers
+	ContentType = "application/vnd.api+json"
+)
+
+// ParseObject returns a JSON object for a given io.ReadCloser containing
+// a raw JSON payload
+func ParseObject(reader io.ReadCloser) (*Object, error) {
+	defer reader.Close()
+
+	byteData, err := ioutil.ReadAll(reader)
+	if err != nil {
+		return nil, err
+	}
+
+	request := struct {
+		Object *Object `json:"data"`
+	}{}
+
+	err = json.Unmarshal(byteData, request)
+	if err != nil {
+		return nil, err
+	}
+
+	return request.Object, nil
+}
+
+// ParseList returns a JSON List for a given io.ReadCloser containing
+// a raw JSON payload
+func ParseList(reader io.ReadCloser) ([]*Object, error) {
+	defer reader.Close()
+
+	byteData, err := ioutil.ReadAll(reader)
+	if err != nil {
+		return nil, err
+	}
+
+	request := struct {
+		List []*Object `json:"data"`
+	}{}
+
+	err = json.Unmarshal(byteData, request)
+	if err != nil {
+		return nil, err
+	}
+
+	return request.List, nil
+}

request_test.go

@@ -0,0 +1,35 @@
+package japi
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestRequest(t *testing.T) {
+
+	Convey("Request Tests", t, func() {
+
+		Convey("->ParseObject()", func() {
+			jsonStr := `{"data": {"type": "user", "id": "sweetID123", "attributes": {"ID":"123"}}}`
+
+			closer := createIOCloser([]byte(jsonStr))
+
+			object, err := ParseObject(closer)
+			So(err, ShouldBeNil)
+			So(object, ShouldNotBeEmpty)
+			So(err, ShouldBeNil)
+			So(object.Type, ShouldEqual, "user")
+			So(object.ID, ShouldEqual, "sweetID123")
+			So(object.Attributes, ShouldResemble, map[string]interface{}{"ID": "123"})
+		})
+	})
+}
+
+func createIOCloser(data []byte) io.ReadCloser {
+	reader := bytes.NewReader(data)
+	return ioutil.NopCloser(reader)
+}

response.go

@@ -0,0 +1,75 @@
+package japi
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+type DataResponse struct {
+	Data interface{} `json:"data"`
+}
+
+// ErrorResponse for API requests
+type ErrorResponse struct {
+	Errors []*Error `json:"errors"`
+}
+
+// RespondWithObject sends a single data object as a JSON response
+func RespondWithObject(w http.ResponseWriter, status int, object *Object) error {
+	payload := struct {
+		Data *Object `json:"data"`
+	}{object}
+
+	return respond(w, status, payload)
+}
+
+// RespondWithList sends a list of data objects as a JSON response
+func RespondWithList(w http.ResponseWriter, status int, list []*Object) error {
+	payload := struct {
+		Data []*Object `json:"data"`
+	}{list}
+	return respond(w, status, payload)
+}
+
+// RespondWithError is a convenience function that puts an error into an array
+// and then calls RespondWithErrors which is the correct error response format
+func RespondWithError(w http.ResponseWriter, err *Error) error {
+	errors := []*Error{err}
+	return RespondWithErrors(w, errors)
+}
+
+// RespondWithErrors sends the expected error response format for a
+// request that cannot be fulfilled in someway. Allows the user
+// to compile multiple errors that can be sent back to a user. Uses
+// the first error status as the HTTP Status to return.
+func RespondWithErrors(w http.ResponseWriter, errors []*Error) error {
+
+	if len(errors) == 0 {
+		return fmt.Errorf("No errors provided for attempted error response.")
+	}
+
+	// use the first error to set the error status
+	status := errors[0].Status
+	payload := ErrorResponse{errors}
+	return respond(w, status, payload)
+}
+
+// Respond formats a JSON response with the appropriate headers.
+func respond(w http.ResponseWriter, status int, payload interface{}) error {
+	w.Header().Add("Content-Type", ContentType)
+	w.WriteHeader(status)
+	return json.NewEncoder(w).Encode(payload)
+}
+
+func prepareError(error *Error) *ErrorResponse {
+	return &ErrorResponse{}
+}
+
+func prepareObject(object *Object) *DataResponse {
+	return &DataResponse{object}
+}
+
+func prepareList(list []*Object) *DataResponse {
+	return &DataResponse{list}
+}