Merge pull request #251 from jlburkhead/plural

add ability to override default plural check

Author: wwwdata

jsonapi/fixtures_test.go

@@ -476,3 +476,26 @@ type ImagePort struct {
 	Protocol string `json:"protocol"`
 	Number   int    `json:"number"`
 }
+
+type Article struct {
+	IDs          []string         `json:"-"`
+	Type         string           `json:"-"`
+	Name         string           `json:"-"`
+	Relationship RelationshipType `json:"-"`
+}
+
+func (a Article) GetID() string {
+	return "id"
+}
+
+func (a Article) GetReferences() []Reference {
+	return []Reference{{Type: a.Type, Name: a.Name, Relationship: a.Relationship}}
+}
+
+func (a Article) GetReferencedIDs() []ReferenceID {
+	referenceIDs := []ReferenceID{}
+	for _, id := range a.IDs {
+		referenceIDs = append(referenceIDs, ReferenceID{ID: id, Type: a.Type, Name: a.Name, Relationship: a.Relationship})
+	}
+	return referenceIDs
+}

jsonapi/marshal.go

@@ -8,6 +8,18 @@ import (
 	"strings"
 )
 
+// RelationshipType is used to specify whether the relationship with referenced objects are to-one or to-many
+type RelationshipType int
+
+const (
+	// DefaultRelationship guesses the relationship type based on the pluralization of the reference name
+	DefaultRelationship RelationshipType = iota
+	// ToOneRelationship forces the relationship to be to-one
+	ToOneRelationship
+	// ToManyRelationship forces the relationship to be to-many
+	ToManyRelationship
+)
+
 // MarshalIdentifier interface is necessary to give an element
 // a unique ID. This interface must be implemented for
 // marshal and unmarshal in order to let them store
@@ -19,9 +31,10 @@ type MarshalIdentifier interface {
 // ReferenceID contains all necessary information in order
 // to reference another struct in jsonapi
 type ReferenceID struct {
-	ID   string
-	Type string
-	Name string
+	ID           string
+	Type         string
+	Name         string
+	Relationship RelationshipType
 }
 
 // Reference information about possible references of a struct
@@ -30,9 +43,10 @@ type ReferenceID struct {
 // Otherwise, if IsNotLoaded is false and GetReferencedIDs() returns no IDs for this reference name, an
 // empty `data` field will be added which means that there are no references.
 type Reference struct {
-	Type        string
-	Name        string
-	IsNotLoaded bool
+	Type         string
+	Name         string
+	IsNotLoaded  bool
+	Relationship RelationshipType
 }
 
 // MarshalReferences must be implemented if the struct to be serialized has relations. This must be done
@@ -191,6 +205,13 @@ func marshalData(element MarshalIdentifier, information ServerInformation) (*Dat
 	return result, err
 }
 
+func isToMany(relationshipType RelationshipType, name string) bool {
+	if relationshipType == DefaultRelationship {
+		return Pluralize(name) == name
+	}
+	return relationshipType == ToManyRelationship
+}
+
 // getStructRelationships returns the relationships struct with ids
 func getStructRelationships(relationer MarshalLinkedRelations, information ServerInformation) *map[string]Relationship {
 	referencedIDs := relationer.GetReferencedIDs()
@@ -213,7 +234,7 @@ func getStructRelationships(relationer MarshalLinkedRelations, information Serve
 		relationships[name] = Relationship{}
 		// if referenceType is plural, we need to use an array for data, otherwise it's just an object
 		container := RelationshipDataContainer{}
-		if Pluralize(name) == name {
+		if isToMany(referenceIDs[0].Relationship, referenceIDs[0].Name) {
 			// multiple elements in links
 			container.DataArray = []RelationshipData{}
 			for _, referenceID := range referenceIDs {
@@ -247,7 +268,7 @@ func getStructRelationships(relationer MarshalLinkedRelations, information Serve
 	for name, reference := range notIncludedReferences {
 		container := RelationshipDataContainer{}
 		// Plural empty relationships need an empty array and empty to-one need a null in the json
-		if !reference.IsNotLoaded && Pluralize(name) == name {
+		if !reference.IsNotLoaded && isToMany(reference.Relationship, reference.Name) {
 			container.DataArray = []RelationshipData{}
 		}
 

jsonapi/marshal_test.go

@@ -950,4 +950,101 @@ var _ = Describe("Marshalling", func() {
 			`))
 		})
 	})
+
+	Context("when overriding default relationship type", func() {
+
+		It("defaults to relationship name pluralization - singular", func() {
+			article := Article{Name: "author", Relationship: DefaultRelationship}
+			result, err := Marshal(article)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(result).To(MatchJSON(`
+			{
+				"data": {
+					"type": "articles",
+					"id": "id",
+					"attributes": {},
+					"relationships": {
+						"author": {
+                                                        "data": null
+                                                }
+					}
+				}
+			}
+			`))
+		})
+
+		It("defaults to relationship name pluralization - plural", func() {
+			article := Article{Name: "authors", Relationship: DefaultRelationship}
+			result, err := Marshal(article)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(result).To(MatchJSON(`
+			{
+				"data": {
+					"type": "articles",
+					"id": "id",
+					"attributes": {},
+					"relationships": {
+						"authors": {
+                                                        "data": []
+                                                }
+					}
+				}
+			}
+			`))
+		})
+
+		It("can make a to-many relationship", func() {
+			article := Article{
+				IDs:          []string{"1", "2"},
+				Name:         "author",
+				Type:         "users",
+				Relationship: ToManyRelationship,
+			}
+			result, err := Marshal(article)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(result).To(MatchJSON(`
+			{
+				"data": {
+					"type": "articles",
+					"id": "id",
+					"attributes": {},
+					"relationships": {
+						"author": {
+		                                        "data": [
+                                                                {"type": "users", "id": "1"},
+                                                                {"type": "users", "id": "2"}
+                                                        ]
+		                                }
+					}
+				}
+			}
+			`))
+		})
+
+		It("can make a to-one relationship", func() {
+			article := Article{
+				IDs:          []string{"1"},
+				Name:         "authors",
+				Type:         "users",
+				Relationship: ToOneRelationship,
+			}
+			result, err := Marshal(article)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(result).To(MatchJSON(`
+			{
+				"data": {
+					"type": "articles",
+					"id": "id",
+					"attributes": {},
+					"relationships": {
+						"authors": {
+		                                        "data": {"type": "users", "id": "1"}
+		                                }
+					}
+				}
+			}
+			`))
+		})
+
+	})
 })